VirtualBox

Changeset 61064 in vbox for trunk


Ignore:
Timestamp:
May 19, 2016 10:20:40 PM (8 years ago)
Author:
vboxsync
Message:

IEM: FPU & SSE ring-0/raw-mode usage preps.

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

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/VMM/VMMAll/IEMAll.cpp

    r61015 r61064  
    52315231 * Hook for preparing to use the host FPU.
    52325232 *
    5233  * This is necessary in ring-0 and raw-mode context.
     5233 * This is necessary in ring-0 and raw-mode context (nop in ring-3).
    52345234 *
    52355235 * @param   pIemCpu             The IEM per CPU data.
    52365236 */
    52375237DECLINLINE(void) iemFpuPrepareUsage(PIEMCPU pIemCpu)
     5238{
     5239#ifdef IN_RING3
     5240    CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_FPU_REM);
     5241#else
     5242    CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_FPU_REM);
     5243/** @todo RZ: FIXME */
     5244//# error "Implement me"
     5245#endif
     5246}
     5247
     5248
     5249/**
     5250 * Hook for preparing to use the host FPU for SSE
     5251 *
     5252 * This is necessary in ring-0 and raw-mode context (nop in ring-3).
     5253 *
     5254 * @param   pIemCpu             The IEM per CPU data.
     5255 */
     5256DECLINLINE(void) iemFpuPrepareUsageSse(PIEMCPU pIemCpu)
     5257{
     5258    iemFpuPrepareUsage(pIemCpu);
     5259}
     5260
     5261
     5262/**
     5263 * Hook for actualizing the guest FPU state before the interpreter reads it.
     5264 *
     5265 * This is necessary in ring-0 and raw-mode context (nop in ring-3).
     5266 *
     5267 * @param   pIemCpu             The IEM per CPU data.
     5268 */
     5269DECLINLINE(void) iemFpuActualizeStateForRead(PIEMCPU pIemCpu)
    52385270{
    52395271#ifdef IN_RING3
     
    52475279
    52485280/**
    5249  * Hook for preparing to use the host FPU for SSE
    5250  *
    5251  * This is necessary in ring-0 and raw-mode context.
     5281 * Hook for actualizing the guest FPU state before the interpreter changes it.
     5282 *
     5283 * This is necessary in ring-0 and raw-mode context (nop in ring-3).
    52525284 *
    52535285 * @param   pIemCpu             The IEM per CPU data.
    52545286 */
    5255 DECLINLINE(void) iemFpuPrepareUsageSse(PIEMCPU pIemCpu)
    5256 {
     5287DECLINLINE(void) iemFpuActualizeStateForChange(PIEMCPU pIemCpu)
     5288{
     5289#ifdef IN_RING3
     5290    NOREF(pIemCpu);
     5291#else
     5292    //CPUMRZFpuActualizeForChange(IEMCPU_TO_VMCPU(pIemCpu));
    52575293    iemFpuPrepareUsage(pIemCpu);
     5294#endif
     5295}
     5296
     5297
     5298/**
     5299 * Hook for actualizing the guest XMM0..15 register state for read only.
     5300 *
     5301 * This is necessary in ring-0 and raw-mode context (nop in ring-3).
     5302 *
     5303 * @param   pIemCpu             The IEM per CPU data.
     5304 */
     5305DECLINLINE(void) iemFpuActualizeSseStateForRead(PIEMCPU pIemCpu)
     5306{
     5307#if defined(IN_RING3) || defined(VBOX_WITH_KERNEL_USING_XMM)
     5308    NOREF(pIemCpu);
     5309#else
     5310    iemFpuActualizeStateForRead(pIemCpu);
     5311#endif
     5312}
     5313
     5314
     5315/**
     5316 * Hook for actualizing the guest XMM0..15 register state for read+write.
     5317 *
     5318 * This is necessary in ring-0 and raw-mode context (nop in ring-3).
     5319 *
     5320 * @param   pIemCpu             The IEM per CPU data.
     5321 */
     5322DECLINLINE(void) iemFpuActualizeSseStateForChange(PIEMCPU pIemCpu)
     5323{
     5324#if defined(IN_RING3) || defined(VBOX_WITH_KERNEL_USING_XMM)
     5325    CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_FPU_REM);
     5326#else
     5327    iemFpuActualizeStateForChange(pIemCpu);
     5328#endif
    52585329}
    52595330
     
    91959266#define IEM_MC_CALL_FPU_AIMPL_1(a_pfnAImpl, a0) \
    91969267    do { \
    9197         iemFpuPrepareUsage(pIemCpu); \
    91989268        a_pfnAImpl(&pIemCpu->CTX_SUFF(pCtx)->CTX_SUFF(pXState)->x87, (a0)); \
    91999269    } while (0)
     
    92089278#define IEM_MC_CALL_FPU_AIMPL_2(a_pfnAImpl, a0, a1) \
    92099279    do { \
    9210         iemFpuPrepareUsage(pIemCpu); \
    92119280        a_pfnAImpl(&pIemCpu->CTX_SUFF(pCtx)->CTX_SUFF(pXState)->x87, (a0), (a1)); \
    92129281    } while (0)
     
    92229291#define IEM_MC_CALL_FPU_AIMPL_3(a_pfnAImpl, a0, a1, a2) \
    92239292    do { \
    9224         iemFpuPrepareUsage(pIemCpu); \
    92259293        a_pfnAImpl(&pIemCpu->CTX_SUFF(pCtx)->CTX_SUFF(pXState)->x87, (a0), (a1), (a2)); \
    92269294    } while (0)
     
    93269394#define IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(a_iEffSeg, a_GCPtrEff) \
    93279395    iemFpuStackPushOverflowWithMemOp(pIemCpu, a_iEffSeg, a_GCPtrEff)
    9328 /** Indicates that we (might) have modified the FPU state. */
    9329 #define IEM_MC_USED_FPU() \
    9330     CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_FPU_REM)
     9396/** Prepares for using the FPU state.
     9397 * Ensures that we can use the host FPU in the current context (RC+R0.
     9398 * Ensures the guest FPU state in the CPUMCTX is up to date. */
     9399#define IEM_MC_PREPARE_FPU_USAGE()              iemFpuPrepareUsage(pIemCpu)
     9400/** Actualizes the guest FPU state so it can be accessed read-only fashion. */
     9401#define IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ()   iemFpuActualizeStateForRead(pIemCpu)
     9402/** Actualizes the guest FPU state so it can be accessed and modified. */
     9403#define IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE() iemFpuActualizeStateForChange(pIemCpu)
     9404
     9405/** Prepares for using the SSE state.
     9406 * Ensures that we can use the host SSE/FPU in the current context (RC+R0.
     9407 * Ensures the guest SSE state in the CPUMCTX is up to date. */
     9408#define IEM_MC_PREPARE_SSE_USAGE()              iemFpuPrepareUsageSse(pIemCpu)
     9409/** Actualizes the guest XMM0..15 register state for read-only access. */
     9410#define IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ()   iemFpuActualizeSseStateForRead(pIemCpu)
     9411/** Actualizes the guest XMM0..15 register state for read-write access. */
     9412#define IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE() iemFpuActualizeSseStateForChange(pIemCpu)
    93319413
    93329414/**
     
    93399421#define IEM_MC_CALL_MMX_AIMPL_2(a_pfnAImpl, a0, a1) \
    93409422    do { \
    9341         iemFpuPrepareUsage(pIemCpu); \
     9423        IEM_MC_PREPARE_FPU_USAGE(); \
    93429424        a_pfnAImpl(&pIemCpu->CTX_SUFF(pCtx)->CTX_SUFF(pXState)->x87, (a0), (a1)); \
    93439425    } while (0)
     
    93539435#define IEM_MC_CALL_MMX_AIMPL_3(a_pfnAImpl, a0, a1, a2) \
    93549436    do { \
    9355         iemFpuPrepareUsage(pIemCpu); \
     9437        IEM_MC_PREPARE_FPU_USAGE(); \
    93569438        a_pfnAImpl(&pIemCpu->CTX_SUFF(pCtx)->CTX_SUFF(pXState)->x87, (a0), (a1), (a2)); \
    93579439    } while (0)
     
    93679449#define IEM_MC_CALL_SSE_AIMPL_2(a_pfnAImpl, a0, a1) \
    93689450    do { \
    9369         iemFpuPrepareUsageSse(pIemCpu); \
     9451        IEM_MC_PREPARE_SSE_USAGE(); \
    93709452        a_pfnAImpl(&pIemCpu->CTX_SUFF(pCtx)->CTX_SUFF(pXState)->x87, (a0), (a1)); \
    93719453    } while (0)
     
    93819463#define IEM_MC_CALL_SSE_AIMPL_3(a_pfnAImpl, a0, a1, a2) \
    93829464    do { \
    9383         iemFpuPrepareUsageSse(pIemCpu); \
     9465        IEM_MC_PREPARE_SSE_USAGE(); \
    93849466        a_pfnAImpl(&pIemCpu->CTX_SUFF(pCtx)->CTX_SUFF(pXState)->x87, (a0), (a1), (a2)); \
    93859467    } while (0)
    9386 
    93879468
    93889469/** @note Not for IOPL or IF testing. */
     
    94419522#define IEM_MC_IF_LOCAL_IS_Z(a_Local)                   if ((a_Local) == 0) {
    94429523#define IEM_MC_IF_GREG_BIT_SET(a_iGReg, a_iBitNo)       if (*(uint64_t *)iemGRegRef(pIemCpu, (a_iGReg)) & RT_BIT_64(a_iBitNo)) {
     9524
    94439525#define IEM_MC_IF_FPUREG_NOT_EMPTY(a_iSt) \
    94449526    if (iemFpuStRegNotEmpty(pIemCpu, (a_iSt)) == VINF_SUCCESS) {
  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructions.cpp.h

    r61059 r61064  
    17101710        else
    17111711            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     1712        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    17121713        IEM_MC_COPY_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg,
    17131714                              (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     
    17301731        else
    17311732            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     1733        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    17321734
    17331735        IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     
    17571759        else
    17581760            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     1761        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    17591762        IEM_MC_COPY_XREG_U128((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB,
    17601763                              ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     
    17771780        else
    17781781            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     1782        IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    17791783
    17801784        IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     
    17931797
    17941798/** Opcode 0x0f 0x2b. */
    1795 #ifndef VBOX_WITH_REM /** @todo figure out why this causes moderate regressions when enabled... Enabled for non-REM to hopefully make some headway there... */
    17961799FNIEMOP_DEF(iemOp_movntps_Mps_Vps__movntpd_Mpd_Vpd)
    17971800{
     
    18131816        else
    18141817            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     1818        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    18151819
    18161820        IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     
    18251829    return VINF_SUCCESS;
    18261830}
    1827 #else
    1828 FNIEMOP_STUB(iemOp_movntps_Mps_Vps__movntpd_Mpd_Vpd);
    1829 #endif
    18301831
    18311832
     
    21742175                IEM_MC_ARG(uint64_t const *,     pSrc, 1);
    21752176                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     2177                IEM_MC_PREPARE_SSE_USAGE();
    21762178                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    21772179                IEM_MC_REF_XREG_U64_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     
    21962198                IEM_MC_FETCH_MEM_U64_ALIGN_U128(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
    21972199
     2200                IEM_MC_PREPARE_SSE_USAGE();
    21982201                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    21992202                IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
     
    22192222                IEM_MC_ARG(uint32_t const *,    pSrc, 1);
    22202223                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     2224                IEM_MC_PREPARE_FPU_USAGE();
    22212225                IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    22222226                IEM_MC_REF_MREG_U32_CONST(pSrc, bRm & X86_MODRM_RM_MASK);
     
    22412245                IEM_MC_FETCH_MEM_U32(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
    22422246
     2247                IEM_MC_PREPARE_FPU_USAGE();
    22432248                IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    22442249                IEM_MC_CALL_MMX_AIMPL_2(pImpl->pfnU64, pDst, pSrc);
     
    23182323                IEM_MC_ARG(uint128_t const *,    pSrc, 1);
    23192324                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     2325                IEM_MC_PREPARE_SSE_USAGE();
    23202326                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    23212327                IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     
    23402346                IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc); /* Most CPUs probably only right high qword */
    23412347
     2348                IEM_MC_PREPARE_SSE_USAGE();
    23422349                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    23432350                IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
     
    23632370                IEM_MC_ARG(uint64_t const *,    pSrc, 1);
    23642371                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     2372                IEM_MC_PREPARE_FPU_USAGE();
    23652373                IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    23662374                IEM_MC_REF_MREG_U64_CONST(pSrc, bRm & X86_MODRM_RM_MASK);
     
    23852393                IEM_MC_FETCH_MEM_U64(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
    23862394
     2395                IEM_MC_PREPARE_FPU_USAGE();
    23872396                IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    23882397                IEM_MC_CALL_MMX_AIMPL_2(pImpl->pfnU64, pDst, pSrc);
     
    24562465                IEM_MC_BEGIN(0, 1);
    24572466                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     2467                IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    24582468                if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    24592469                {
     
    24762486                IEM_MC_BEGIN(0, 2);
    24772487                IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    2478                 IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     2488                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT(); /** @todo order */
    24792489                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
    24802490                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     2491                IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    24812492                if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    24822493                {
     
    25042515                IEM_MC_BEGIN(0, 1);
    25052516                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     2517                IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    25062518                IEM_MC_LOCAL(uint64_t, u64Tmp);
    25072519                if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     
    25212533                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
    25222534                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     2535                IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    25232536                if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    25242537                {
     
    25642577                 */
    25652578                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    2566                 IEM_MC_BEGIN(0, 1);
    2567                 IEM_MC_LOCAL(uint128_t, u128Tmp);
     2579                IEM_MC_BEGIN(0, 0);
    25682580                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    2569                 IEM_MC_FETCH_XREG_U128(u128Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    2570                 IEM_MC_STORE_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u128Tmp);
     2581                IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
     2582                IEM_MC_COPY_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg,
     2583                                      (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    25712584                IEM_MC_ADVANCE_RIP();
    25722585                IEM_MC_END();
     
    25842597                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    25852598                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     2599                IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    25862600                if (fAligned)
    25872601                    IEM_MC_FETCH_MEM_U128_ALIGN_SSE(u128Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
     
    26082622                IEM_MC_LOCAL(uint64_t, u64Tmp);
    26092623                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     2624                IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    26102625                IEM_MC_FETCH_MREG_U64(u64Tmp, bRm & X86_MODRM_RM_MASK);
    26112626                IEM_MC_STORE_MREG_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u64Tmp);
     
    26252640                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    26262641                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     2642                IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    26272643                IEM_MC_FETCH_MEM_U64(u64Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
    26282644                IEM_MC_STORE_MREG_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u64Tmp);
     
    26792695                IEM_MC_ARG_CONST(uint8_t,       bEvilArg, /*=*/ bEvil, 2);
    26802696                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     2697                IEM_MC_PREPARE_SSE_USAGE();
    26812698                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    26822699                IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     
    27032720
    27042721                IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     2722                IEM_MC_PREPARE_SSE_USAGE();
    27052723                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    27062724                IEM_MC_CALL_SSE_AIMPL_3(pfnAImpl, pDst, pSrc, bEvilArg);
     
    27272745                IEM_MC_ARG_CONST(uint8_t,       bEvilArg, /*=*/ bEvil, 2);
    27282746                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT_CHECK_SSE_OR_MMXEXT();
     2747                IEM_MC_PREPARE_FPU_USAGE();
    27292748                IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    27302749                IEM_MC_REF_MREG_U64_CONST(pSrc, bRm & X86_MODRM_RM_MASK);
     
    27512770
    27522771                IEM_MC_FETCH_MEM_U64(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     2772                IEM_MC_PREPARE_FPU_USAGE();
    27532773                IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    27542774                IEM_MC_CALL_MMX_AIMPL_3(iemAImpl_pshufw, pDst, pSrc, bEvilArg);
     
    29592979                IEM_MC_ARG(uint128_t const *,    pSrc, 1);
    29602980                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     2981                IEM_MC_PREPARE_SSE_USAGE();
    29612982                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    29622983                IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     
    29813002                IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
    29823003
     3004                IEM_MC_PREPARE_SSE_USAGE();
    29833005                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    29843006                IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
     
    30023024                IEM_MC_ARG(uint64_t const *,    pSrc, 1);
    30033025                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     3026                IEM_MC_PREPARE_FPU_USAGE();
    30043027                IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    30053028                IEM_MC_REF_MREG_U64_CONST(pSrc, bRm & X86_MODRM_RM_MASK);
     
    30243047                IEM_MC_FETCH_MEM_U64(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
    30253048
     3049                IEM_MC_PREPARE_FPU_USAGE();
    30263050                IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    30273051                IEM_MC_CALL_MMX_AIMPL_2(pImpl->pfnU64, pDst, pSrc);
     
    30883112                IEM_MC_BEGIN(0, 1);
    30893113                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     3114                IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    30903115                if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    30913116                {
     
    31113136                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
    31123137                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     3138                IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    31133139                if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    31143140                {
     
    31363162                IEM_MC_BEGIN(0, 1);
    31373163                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     3164                IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    31383165                if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    31393166                {
     
    31593186                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
    31603187                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     3188                IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    31613189                if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    31623190                {
     
    32023230                 */
    32033231                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    3204                 IEM_MC_BEGIN(0, 1);
    3205                 IEM_MC_LOCAL(uint128_t, u128Tmp);
     3232                IEM_MC_BEGIN(0, 0);
    32063233                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    3207                 IEM_MC_FETCH_XREG_U128(u128Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    3208                 IEM_MC_STORE_XREG_U128((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u128Tmp);
     3234                IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
     3235                IEM_MC_COPY_XREG_U128((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB,
     3236                                      ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    32093237                IEM_MC_ADVANCE_RIP();
    32103238                IEM_MC_END();
     
    32223250                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    32233251                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     3252                IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
     3253
    32243254                IEM_MC_FETCH_XREG_U128(u128Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    32253255                if (fAligned)
     
    32473277                IEM_MC_LOCAL(uint64_t, u64Tmp);
    32483278                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     3279                IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    32493280                IEM_MC_FETCH_MREG_U64(u64Tmp, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    32503281                IEM_MC_STORE_MREG_U64(bRm & X86_MODRM_RM_MASK, u64Tmp);
     
    32643295                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    32653296                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     3297                IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
     3298
    32663299                IEM_MC_FETCH_MREG_U64(u64Tmp, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    32673300                IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffSrc, u64Tmp);
     
    67716804            IEM_MC_ARG(uint128_t const *,    pSrc, 1);
    67726805            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     6806            IEM_MC_PREPARE_SSE_USAGE();
    67736807            IEM_MC_REF_GREG_U64(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    67746808            IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     
    67856819            IEM_MC_ARG(uint64_t const *,    pSrc, 1);
    67866820            IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT_CHECK_SSE_OR_MMXEXT();
     6821            IEM_MC_PREPARE_FPU_USAGE();
    67876822            IEM_MC_REF_GREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    67886823            IEM_MC_REF_MREG_U64_CONST(pSrc, bRm & X86_MODRM_RM_MASK);
     
    68316866
    68326867/** Opcode 0x0f 0xe7. */
    6833 #if 0 //ndef VBOX_WITH_REM
    68346868FNIEMOP_DEF(iemOp_movntq_Mq_Pq__movntdq_Mdq_Vdq)
    68356869{
     
    68536887                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    68546888                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
     6889                IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    68556890
    68566891                IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     
    68696904                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    68706905                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     6906                IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    68716907
    68726908                IEM_MC_FETCH_MREG_U64(uSrc, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
     
    68866922    return VINF_SUCCESS;
    68876923}
    6888 #else
    6889 FNIEMOP_STUB(iemOp_movntq_Mq_Pq__movntdq_Mdq_Vdq);
    6890 #endif
    68916924
    68926925
     
    1312613159    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1312713160    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13161    IEM_MC_PREPARE_FPU_USAGE();
    1312813162    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, bRm & X86_MODRM_RM_MASK)
    1312913163        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pr80Value2);
     
    1313213166        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1313313167    IEM_MC_ENDIF();
    13134     IEM_MC_USED_FPU();
    1313513168    IEM_MC_ADVANCE_RIP();
    1313613169
     
    1315813191    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1315913192    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13193    IEM_MC_PREPARE_FPU_USAGE();
    1316013194    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, bRm & X86_MODRM_RM_MASK)
    1316113195        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pu16Fsw, pr80Value1, pr80Value2);
     
    1316413198        IEM_MC_FPU_STACK_UNDERFLOW(UINT8_MAX);
    1316513199    IEM_MC_ENDIF();
    13166     IEM_MC_USED_FPU();
    1316713200    IEM_MC_ADVANCE_RIP();
    1316813201
     
    1319013223    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1319113224    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13225    IEM_MC_PREPARE_FPU_USAGE();
    1319213226    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, bRm & X86_MODRM_RM_MASK)
    1319313227        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pu16Fsw, pr80Value1, pr80Value2);
     
    1319613230        IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP(UINT8_MAX);
    1319713231    IEM_MC_ENDIF();
    13198     IEM_MC_USED_FPU();
    1319913232    IEM_MC_ADVANCE_RIP();
    1320013233
     
    1329113324    IEM_MC_FETCH_MEM_R32(r32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1329213325
     13326    IEM_MC_PREPARE_FPU_USAGE();
    1329313327    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1329413328        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pr32Val2);
     
    1329713331        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1329813332    IEM_MC_ENDIF();
    13299     IEM_MC_USED_FPU();
    1330013333    IEM_MC_ADVANCE_RIP();
    1330113334
     
    1334113374    IEM_MC_FETCH_MEM_R32(r32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1334213375
     13376    IEM_MC_PREPARE_FPU_USAGE();
    1334313377    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1334413378        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r32, pu16Fsw, pr80Value1, pr32Val2);
     
    1334713381        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
    1334813382    IEM_MC_ENDIF();
    13349     IEM_MC_USED_FPU();
    1335013383    IEM_MC_ADVANCE_RIP();
    1335113384
     
    1337513408    IEM_MC_FETCH_MEM_R32(r32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1337613409
     13410    IEM_MC_PREPARE_FPU_USAGE();
    1337713411    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1337813412        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r32, pu16Fsw, pr80Value1, pr32Val2);
     
    1338113415        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
    1338213416    IEM_MC_ENDIF();
    13383     IEM_MC_USED_FPU();
    1338413417    IEM_MC_ADVANCE_RIP();
    1338513418
     
    1348013513    IEM_MC_FETCH_MEM_R32(r32Val, pIemCpu->iEffSeg, GCPtrEffSrc);
    1348113514
     13515    IEM_MC_PREPARE_FPU_USAGE();
    1348213516    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1348313517        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r32_to_r80, pFpuRes, pr32Val);
     
    1348613520        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
    1348713521    IEM_MC_ENDIF();
    13488     IEM_MC_USED_FPU();
    1348913522    IEM_MC_ADVANCE_RIP();
    1349013523
     
    1351113544
    1351213545    IEM_MC_MEM_MAP(pr32Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     13546    IEM_MC_PREPARE_FPU_USAGE();
    1351313547    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1351413548        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r32, pu16Fsw, pr32Dst, pr80Value);
     
    1352213556        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1352313557    IEM_MC_ENDIF();
    13524     IEM_MC_USED_FPU();
    1352513558    IEM_MC_ADVANCE_RIP();
    1352613559
     
    1354713580
    1354813581    IEM_MC_MEM_MAP(pr32Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     13582    IEM_MC_PREPARE_FPU_USAGE();
    1354913583    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1355013584        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r32, pu16Fsw, pr32Dst, pr80Value);
     
    1355813592        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1355913593    IEM_MC_ENDIF();
    13560     IEM_MC_USED_FPU();
    1356113594    IEM_MC_ADVANCE_RIP();
    1356213595
     
    1362913662    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    1363013663    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
     13664    IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    1363113665    IEM_MC_FETCH_FCW(u16Fcw);
    1363213666    IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Fcw);
     
    1364613680    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1364713681    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13682    IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    1364813683    /** @todo Testcase: looks like FNOP leaves FOP alone but updates FPUIP. Could be
    1364913684     *        intel optimizations. Investigate. */
    1365013685    IEM_MC_UPDATE_FPU_OPCODE_IP();
    13651     IEM_MC_USED_FPU();
    1365213686    IEM_MC_ADVANCE_RIP(); /* C0-C3 are documented as undefined, we leave them unmodified. */
    1365313687    IEM_MC_END();
     
    1366913703    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1367013704    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13705
     13706    IEM_MC_PREPARE_FPU_USAGE();
    1367113707    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, bRm & X86_MODRM_RM_MASK)
    1367213708        IEM_MC_SET_FPU_RESULT(FpuRes, 0 /*FSW*/, pr80Value);
     
    1367513711        IEM_MC_FPU_STACK_PUSH_UNDERFLOW();
    1367613712    IEM_MC_ENDIF();
    13677     IEM_MC_USED_FPU();
     13713
    1367813714    IEM_MC_ADVANCE_RIP();
    1367913715    IEM_MC_END();
     
    1369813734    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1369913735    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13736
     13737    IEM_MC_PREPARE_FPU_USAGE();
    1370013738    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, bRm & X86_MODRM_RM_MASK)
    1370113739        IEM_MC_SET_FPU_RESULT(FpuRes, X86_FSW_C1, pr80Value2);
     
    1370513743        IEM_MC_CALL_CIMPL_1(iemCImpl_fxch_underflow, iStReg);
    1370613744    IEM_MC_ENDIF();
    13707     IEM_MC_USED_FPU();
     13745
    1370813746    IEM_MC_ADVANCE_RIP();
    1370913747    IEM_MC_END();
     
    1372713765        IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1372813766        IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13767
     13768        IEM_MC_PREPARE_FPU_USAGE();
    1372913769        IEM_MC_IF_FPUREG_NOT_EMPTY(0)
    1373013770            IEM_MC_UPDATE_FSW_THEN_POP(u16Fsw);
     
    1373213772            IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP(0);
    1373313773        IEM_MC_ENDIF();
    13734         IEM_MC_USED_FPU();
     13774
    1373513775        IEM_MC_ADVANCE_RIP();
    1373613776        IEM_MC_END();
     
    1374313783        IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1374413784        IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13785
     13786        IEM_MC_PREPARE_FPU_USAGE();
    1374513787        IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1374613788            IEM_MC_SET_FPU_RESULT(FpuRes, 0 /*FSW*/, pr80Value);
     
    1374913791            IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP(iDstReg);
    1375013792        IEM_MC_ENDIF();
    13751         IEM_MC_USED_FPU();
     13793
    1375213794        IEM_MC_ADVANCE_RIP();
    1375313795        IEM_MC_END();
     
    1377413816    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1377513817    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13818    IEM_MC_PREPARE_FPU_USAGE();
    1377613819    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1377713820        IEM_MC_CALL_FPU_AIMPL_2(pfnAImpl, pFpuRes, pr80Value);
     
    1378013823        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1378113824    IEM_MC_ENDIF();
    13782     IEM_MC_USED_FPU();
    1378313825    IEM_MC_ADVANCE_RIP();
    1378413826
     
    1382013862    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1382113863    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13864    IEM_MC_PREPARE_FPU_USAGE();
    1382213865    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1382313866        IEM_MC_CALL_FPU_AIMPL_2(pfnAImpl, pu16Fsw, pr80Value);
     
    1382613869        IEM_MC_FPU_STACK_UNDERFLOW(UINT8_MAX);
    1382713870    IEM_MC_ENDIF();
    13828     IEM_MC_USED_FPU();
    1382913871    IEM_MC_ADVANCE_RIP();
    1383013872
     
    1386513907    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1386613908    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     13909    IEM_MC_PREPARE_FPU_USAGE();
    1386713910    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1386813911        IEM_MC_CALL_FPU_AIMPL_1(pfnAImpl, pFpuRes);
     
    1387113914        IEM_MC_FPU_STACK_PUSH_OVERFLOW();
    1387213915    IEM_MC_ENDIF();
    13873     IEM_MC_USED_FPU();
    1387413916    IEM_MC_ADVANCE_RIP();
    1387513917
     
    1396614008    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1396714009    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     14010    IEM_MC_PREPARE_FPU_USAGE();
    1396814011    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1396914012        IEM_MC_CALL_FPU_AIMPL_2(pfnAImpl, pFpuResTwo, pr80Value);
     
    1397214015        IEM_MC_FPU_STACK_PUSH_UNDERFLOW_TWO();
    1397314016    IEM_MC_ENDIF();
    13974     IEM_MC_USED_FPU();
    1397514017    IEM_MC_ADVANCE_RIP();
    1397614018
     
    1400714049    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1400814050
     14051    IEM_MC_PREPARE_FPU_USAGE();
    1400914052    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, bRm & X86_MODRM_RM_MASK, pr80Value2, 0)
    1401014053        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pr80Value2);
     
    1401314056        IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP(bRm & X86_MODRM_RM_MASK);
    1401414057    IEM_MC_ENDIF();
    14015     IEM_MC_USED_FPU();
    1401614058    IEM_MC_ADVANCE_RIP();
    1401714059
     
    1405914101    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1406014102
     14103    IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    1406114104    IEM_MC_FPU_STACK_DEC_TOP();
    1406214105    IEM_MC_UPDATE_FSW_CONST(0);
    1406314106
    14064     IEM_MC_USED_FPU();
    1406514107    IEM_MC_ADVANCE_RIP();
    1406614108    IEM_MC_END();
     
    1408314125    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1408414126
     14127    IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    1408514128    IEM_MC_FPU_STACK_INC_TOP();
    1408614129    IEM_MC_UPDATE_FSW_CONST(0);
    1408714130
    14088     IEM_MC_USED_FPU();
    1408914131    IEM_MC_ADVANCE_RIP();
    1409014132    IEM_MC_END();
     
    1425014292    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1425114293
     14294    IEM_MC_PREPARE_FPU_USAGE();
    1425214295    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, bRm & X86_MODRM_RM_MASK, 0)
    1425314296        IEM_MC_IF_EFL_BIT_SET(X86_EFL_CF)
     
    1425814301        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1425914302    IEM_MC_ENDIF();
    14260     IEM_MC_USED_FPU();
    1426114303    IEM_MC_ADVANCE_RIP();
    1426214304
     
    1427814320    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1427914321
     14322    IEM_MC_PREPARE_FPU_USAGE();
    1428014323    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, bRm & X86_MODRM_RM_MASK, 0)
    1428114324        IEM_MC_IF_EFL_BIT_SET(X86_EFL_ZF)
     
    1428614329        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1428714330    IEM_MC_ENDIF();
    14288     IEM_MC_USED_FPU();
    1428914331    IEM_MC_ADVANCE_RIP();
    1429014332
     
    1430614348    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1430714349
     14350    IEM_MC_PREPARE_FPU_USAGE();
    1430814351    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, bRm & X86_MODRM_RM_MASK, 0)
    1430914352        IEM_MC_IF_EFL_ANY_BITS_SET(X86_EFL_CF | X86_EFL_ZF)
     
    1431414357        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1431514358    IEM_MC_ENDIF();
    14316     IEM_MC_USED_FPU();
    1431714359    IEM_MC_ADVANCE_RIP();
    1431814360
     
    1433414376    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1433514377
     14378    IEM_MC_PREPARE_FPU_USAGE();
    1433614379    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, bRm & X86_MODRM_RM_MASK, 0)
    1433714380        IEM_MC_IF_EFL_BIT_SET(X86_EFL_PF)
     
    1434214385        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1434314386    IEM_MC_ENDIF();
    14344     IEM_MC_USED_FPU();
    1434514387    IEM_MC_ADVANCE_RIP();
    1434614388
     
    1436814410    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1436914411    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     14412
     14413    IEM_MC_PREPARE_FPU_USAGE();
    1437014414    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, 1)
    1437114415        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pu16Fsw, pr80Value1, pr80Value2);
     
    1437414418        IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP_POP();
    1437514419    IEM_MC_ENDIF();
    14376     IEM_MC_USED_FPU();
    1437714420    IEM_MC_ADVANCE_RIP();
    1437814421
     
    1441314456    IEM_MC_FETCH_MEM_I32(i32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1441414457
     14458    IEM_MC_PREPARE_FPU_USAGE();
    1441514459    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1441614460        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pi32Val2);
     
    1441914463        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1442014464    IEM_MC_ENDIF();
    14421     IEM_MC_USED_FPU();
    1442214465    IEM_MC_ADVANCE_RIP();
    1442314466
     
    1446314506    IEM_MC_FETCH_MEM_I32(i32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1446414507
     14508    IEM_MC_PREPARE_FPU_USAGE();
    1446514509    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1446614510        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i32, pu16Fsw, pr80Value1, pi32Val2);
     
    1446914513        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
    1447014514    IEM_MC_ENDIF();
    14471     IEM_MC_USED_FPU();
    1447214515    IEM_MC_ADVANCE_RIP();
    1447314516
     
    1449714540    IEM_MC_FETCH_MEM_I32(i32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1449814541
     14542    IEM_MC_PREPARE_FPU_USAGE();
    1449914543    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1450014544        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i32, pu16Fsw, pr80Value1, pi32Val2);
     
    1450314547        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
    1450414548    IEM_MC_ENDIF();
    14505     IEM_MC_USED_FPU();
    1450614549    IEM_MC_ADVANCE_RIP();
    1450714550
     
    1460314646    IEM_MC_FETCH_MEM_I32(i32Val, pIemCpu->iEffSeg, GCPtrEffSrc);
    1460414647
     14648    IEM_MC_PREPARE_FPU_USAGE();
    1460514649    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1460614650        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fild_i32_to_r80, pFpuRes, pi32Val);
     
    1460914653        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
    1461014654    IEM_MC_ENDIF();
    14611     IEM_MC_USED_FPU();
    1461214655    IEM_MC_ADVANCE_RIP();
    1461314656
     
    1463414677
    1463514678    IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     14679    IEM_MC_PREPARE_FPU_USAGE();
    1463614680    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1463714681        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fistt_r80_to_i32, pu16Fsw, pi32Dst, pr80Value);
     
    1464514689        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1464614690    IEM_MC_ENDIF();
    14647     IEM_MC_USED_FPU();
    1464814691    IEM_MC_ADVANCE_RIP();
    1464914692
     
    1467014713
    1467114714    IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     14715    IEM_MC_PREPARE_FPU_USAGE();
    1467214716    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1467314717        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i32, pu16Fsw, pi32Dst, pr80Value);
     
    1468114725        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1468214726    IEM_MC_ENDIF();
    14683     IEM_MC_USED_FPU();
    1468414727    IEM_MC_ADVANCE_RIP();
    1468514728
     
    1470614749
    1470714750    IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     14751    IEM_MC_PREPARE_FPU_USAGE();
    1470814752    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1470914753        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i32, pu16Fsw, pi32Dst, pr80Value);
     
    1471714761        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1471814762    IEM_MC_ENDIF();
    14719     IEM_MC_USED_FPU();
    1472014763    IEM_MC_ADVANCE_RIP();
    1472114764
     
    1474414787    IEM_MC_FETCH_MEM_R80(r80Val, pIemCpu->iEffSeg, GCPtrEffSrc);
    1474514788
     14789    IEM_MC_PREPARE_FPU_USAGE();
    1474614790    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1474714791        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r80_from_r80, pFpuRes, pr80Val);
     
    1475014794        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
    1475114795    IEM_MC_ENDIF();
    14752     IEM_MC_USED_FPU();
    1475314796    IEM_MC_ADVANCE_RIP();
    1475414797
     
    1477514818
    1477614819    IEM_MC_MEM_MAP(pr80Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     14820    IEM_MC_PREPARE_FPU_USAGE();
    1477714821    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1477814822        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r80, pu16Fsw, pr80Dst, pr80Value);
     
    1478614830        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1478714831    IEM_MC_ENDIF();
    14788     IEM_MC_USED_FPU();
    1478914832    IEM_MC_ADVANCE_RIP();
    1479014833
     
    1480614849    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1480714850
     14851    IEM_MC_PREPARE_FPU_USAGE();
    1480814852    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, bRm & X86_MODRM_RM_MASK, 0)
    1480914853        IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_CF)
     
    1481414858        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1481514859    IEM_MC_ENDIF();
    14816     IEM_MC_USED_FPU();
    1481714860    IEM_MC_ADVANCE_RIP();
    1481814861
     
    1483414877    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1483514878
     14879    IEM_MC_PREPARE_FPU_USAGE();
    1483614880    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, bRm & X86_MODRM_RM_MASK, 0)
    1483714881        IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF)
     
    1484214886        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1484314887    IEM_MC_ENDIF();
    14844     IEM_MC_USED_FPU();
    1484514888    IEM_MC_ADVANCE_RIP();
    1484614889
     
    1486214905    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1486314906
     14907    IEM_MC_PREPARE_FPU_USAGE();
    1486414908    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, bRm & X86_MODRM_RM_MASK, 0)
    1486514909        IEM_MC_IF_EFL_NO_BITS_SET(X86_EFL_CF | X86_EFL_ZF)
     
    1487014914        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1487114915    IEM_MC_ENDIF();
    14872     IEM_MC_USED_FPU();
    1487314916    IEM_MC_ADVANCE_RIP();
    1487414917
     
    1489014933    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1489114934
     14935    IEM_MC_PREPARE_FPU_USAGE();
    1489214936    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, bRm & X86_MODRM_RM_MASK, 0)
    1489314937        IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_PF)
     
    1489814942        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1489914943    IEM_MC_ENDIF();
    14900     IEM_MC_USED_FPU();
    1490114944    IEM_MC_ADVANCE_RIP();
    1490214945
     
    1507215115    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1507315116
     15117    IEM_MC_PREPARE_FPU_USAGE();
    1507415118    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, bRm & X86_MODRM_RM_MASK, pr80Value2, 0)
    1507515119        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pr80Value2);
     
    1507815122        IEM_MC_FPU_STACK_UNDERFLOW(bRm & X86_MODRM_RM_MASK);
    1507915123    IEM_MC_ENDIF();
    15080     IEM_MC_USED_FPU();
    1508115124    IEM_MC_ADVANCE_RIP();
    1508215125
     
    1515615199
    1515715200    IEM_MC_FETCH_MEM_R64(r64Factor2, pIemCpu->iEffSeg, GCPtrEffSrc);
     15201    IEM_MC_PREPARE_FPU_USAGE();
    1515815202    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Factor1, 0)
    1515915203        IEM_MC_CALL_FPU_AIMPL_3(pfnImpl, pFpuRes, pr80Factor1, pr64Factor2);
     
    1516215206        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(0, pIemCpu->iEffSeg, GCPtrEffSrc);
    1516315207    IEM_MC_ENDIF();
    15164     IEM_MC_USED_FPU();
    1516515208    IEM_MC_ADVANCE_RIP();
    1516615209
     
    1520615249    IEM_MC_FETCH_MEM_R64(r64Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1520715250
     15251    IEM_MC_PREPARE_FPU_USAGE();
    1520815252    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1520915253        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r64, pu16Fsw, pr80Value1, pr64Val2);
     
    1521215256        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
    1521315257    IEM_MC_ENDIF();
    15214     IEM_MC_USED_FPU();
    1521515258    IEM_MC_ADVANCE_RIP();
    1521615259
     
    1524015283    IEM_MC_FETCH_MEM_R64(r64Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1524115284
     15285    IEM_MC_PREPARE_FPU_USAGE();
    1524215286    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1524315287        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r64, pu16Fsw, pr80Value1, pr64Val2);
     
    1524615290        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
    1524715291    IEM_MC_ENDIF();
    15248     IEM_MC_USED_FPU();
    1524915292    IEM_MC_ADVANCE_RIP();
    1525015293
     
    1534315386
    1534415387    IEM_MC_FETCH_MEM_R64(r64Val, pIemCpu->iEffSeg, GCPtrEffSrc);
     15388    IEM_MC_PREPARE_FPU_USAGE();
    1534515389    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1534615390        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r64_to_r80, pFpuRes, pr64Val);
     
    1534915393        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
    1535015394    IEM_MC_ENDIF();
    15351     IEM_MC_USED_FPU();
    1535215395    IEM_MC_ADVANCE_RIP();
    1535315396
     
    1537415417
    1537515418    IEM_MC_MEM_MAP(pi64Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     15419    IEM_MC_PREPARE_FPU_USAGE();
    1537615420    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1537715421        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fistt_r80_to_i64, pu16Fsw, pi64Dst, pr80Value);
     
    1538515429        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1538615430    IEM_MC_ENDIF();
    15387     IEM_MC_USED_FPU();
    1538815431    IEM_MC_ADVANCE_RIP();
    1538915432
     
    1541015453
    1541115454    IEM_MC_MEM_MAP(pr64Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     15455    IEM_MC_PREPARE_FPU_USAGE();
    1541215456    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1541315457        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r64, pu16Fsw, pr64Dst, pr80Value);
     
    1542115465        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1542215466    IEM_MC_ENDIF();
    15423     IEM_MC_USED_FPU();
    1542415467    IEM_MC_ADVANCE_RIP();
    1542515468
     
    1544815491
    1544915492    IEM_MC_MEM_MAP(pr64Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     15493    IEM_MC_PREPARE_FPU_USAGE();
    1545015494    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1545115495        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r64, pu16Fsw, pr64Dst, pr80Value);
     
    1545915503        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1546015504    IEM_MC_ENDIF();
    15461     IEM_MC_USED_FPU();
    1546215505    IEM_MC_ADVANCE_RIP();
    1546315506
     
    1551615559    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1551715560
     15561    IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    1551815562    IEM_MC_FETCH_FSW(u16Tmp);
    1551915563    IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Tmp);
     
    1554115585    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1554215586
     15587    IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    1554315588    IEM_MC_FPU_STACK_FREE(bRm & X86_MODRM_RM_MASK);
    1554415589    IEM_MC_UPDATE_FPU_OPCODE_IP();
    1554515590
    15546     IEM_MC_USED_FPU();
    1554715591    IEM_MC_ADVANCE_RIP();
    1554815592    IEM_MC_END();
     
    1556215606    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1556315607    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     15608
     15609    IEM_MC_PREPARE_FPU_USAGE();
    1556415610    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1556515611        IEM_MC_SET_FPU_RESULT(FpuRes, 0 /*FSW*/, pr80Value);
     
    1556815614        IEM_MC_FPU_STACK_UNDERFLOW(bRm & X86_MODRM_RM_MASK);
    1556915615    IEM_MC_ENDIF();
    15570     IEM_MC_USED_FPU();
     15616
    1557115617    IEM_MC_ADVANCE_RIP();
    1557215618    IEM_MC_END();
     
    1570815754    IEM_MC_FETCH_MEM_I16(i16Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1570915755
     15756    IEM_MC_PREPARE_FPU_USAGE();
    1571015757    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1571115758        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pi16Val2);
     
    1571415761        IEM_MC_FPU_STACK_UNDERFLOW(0);
    1571515762    IEM_MC_ENDIF();
    15716     IEM_MC_USED_FPU();
    1571715763    IEM_MC_ADVANCE_RIP();
    1571815764
     
    1575815804    IEM_MC_FETCH_MEM_I16(i16Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1575915805
     15806    IEM_MC_PREPARE_FPU_USAGE();
    1576015807    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1576115808        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i16, pu16Fsw, pr80Value1, pi16Val2);
     
    1576415811        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
    1576515812    IEM_MC_ENDIF();
    15766     IEM_MC_USED_FPU();
    1576715813    IEM_MC_ADVANCE_RIP();
    1576815814
     
    1579215838    IEM_MC_FETCH_MEM_I16(i16Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
    1579315839
     15840    IEM_MC_PREPARE_FPU_USAGE();
    1579415841    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1579515842        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i16, pu16Fsw, pr80Value1, pi16Val2);
     
    1579815845        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
    1579915846    IEM_MC_ENDIF();
    15800     IEM_MC_USED_FPU();
    1580115847    IEM_MC_ADVANCE_RIP();
    1580215848
     
    1589015936    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1589115937
     15938    IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    1589215939    IEM_MC_FPU_STACK_FREE(bRm & X86_MODRM_RM_MASK);
    1589315940    IEM_MC_FPU_STACK_INC_TOP();
    1589415941    IEM_MC_UPDATE_FPU_OPCODE_IP();
    1589515942
    15896     IEM_MC_USED_FPU();
    1589715943    IEM_MC_ADVANCE_RIP();
    1589815944    IEM_MC_END();
     
    1591015956    IEM_MC_LOCAL(uint16_t, u16Tmp);
    1591115957    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
     15958    IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    1591215959    IEM_MC_FETCH_FSW(u16Tmp);
    1591315960    IEM_MC_STORE_GREG_U16(X86_GREG_xAX, u16Tmp);
     
    1595316000    IEM_MC_FETCH_MEM_I16(i16Val, pIemCpu->iEffSeg, GCPtrEffSrc);
    1595416001
     16002    IEM_MC_PREPARE_FPU_USAGE();
    1595516003    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1595616004        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fild_i16_to_r80, pFpuRes, pi16Val);
     
    1595916007        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
    1596016008    IEM_MC_ENDIF();
    15961     IEM_MC_USED_FPU();
    1596216009    IEM_MC_ADVANCE_RIP();
    1596316010
     
    1598416031
    1598516032    IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     16033    IEM_MC_PREPARE_FPU_USAGE();
    1598616034    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1598716035        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fistt_r80_to_i16, pu16Fsw, pi16Dst, pr80Value);
     
    1599516043        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1599616044    IEM_MC_ENDIF();
    15997     IEM_MC_USED_FPU();
    1599816045    IEM_MC_ADVANCE_RIP();
    1599916046
     
    1602016067
    1602116068    IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     16069    IEM_MC_PREPARE_FPU_USAGE();
    1602216070    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1602316071        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i16, pu16Fsw, pi16Dst, pr80Value);
     
    1603116079        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1603216080    IEM_MC_ENDIF();
    16033     IEM_MC_USED_FPU();
    1603416081    IEM_MC_ADVANCE_RIP();
    1603516082
     
    1605616103
    1605716104    IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     16105    IEM_MC_PREPARE_FPU_USAGE();
    1605816106    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1605916107        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i16, pu16Fsw, pi16Dst, pr80Value);
     
    1606716115        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1606816116    IEM_MC_ENDIF();
    16069     IEM_MC_USED_FPU();
    1607016117    IEM_MC_ADVANCE_RIP();
    1607116118
     
    1609816145    IEM_MC_FETCH_MEM_I64(i64Val, pIemCpu->iEffSeg, GCPtrEffSrc);
    1609916146
     16147    IEM_MC_PREPARE_FPU_USAGE();
    1610016148    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1610116149        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fild_i64_to_r80, pFpuRes, pi64Val);
     
    1610416152        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
    1610516153    IEM_MC_ENDIF();
    16106     IEM_MC_USED_FPU();
    1610716154    IEM_MC_ADVANCE_RIP();
    1610816155
     
    1613316180
    1613416181    IEM_MC_MEM_MAP(pi64Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     16182    IEM_MC_PREPARE_FPU_USAGE();
    1613516183    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1613616184        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i64, pu16Fsw, pi64Dst, pr80Value);
     
    1614416192        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
    1614516193    IEM_MC_ENDIF();
    16146     IEM_MC_USED_FPU();
    1614716194    IEM_MC_ADVANCE_RIP();
    1614816195
  • trunk/src/VBox/VMM/testcase/tstIEMCheckMc.cpp

    r60992 r61064  
    401401#define IEM_MC_FETCH_EFLAGS(a_EFlags)                   do { (a_EFlags) = 0; CHK_TYPE(uint32_t, a_EFlags); } while (0)
    402402#define IEM_MC_FETCH_EFLAGS_U8(a_EFlags)                do { (a_EFlags) = 0; CHK_TYPE(uint8_t,  a_EFlags); } while (0)
    403 #define IEM_MC_FETCH_FSW(a_u16Fsw)                      do { (a_u16Fsw) = 0; CHK_TYPE(uint16_t, a_u16Fsw); } while (0)
    404 #define IEM_MC_FETCH_FCW(a_u16Fcw)                      do { (a_u16Fcw) = 0; CHK_TYPE(uint16_t, a_u16Fcw); } while (0)
     403#define IEM_MC_FETCH_FSW(a_u16Fsw)                      do { (a_u16Fsw) = 0; CHK_TYPE(uint16_t, a_u16Fsw); (void)fFpuRead; } while (0)
     404#define IEM_MC_FETCH_FCW(a_u16Fcw)                      do { (a_u16Fcw) = 0; CHK_TYPE(uint16_t, a_u16Fcw); (void)fFpuRead; } while (0)
    405405#define IEM_MC_STORE_GREG_U8(a_iGReg, a_u8Value)        do { CHK_TYPE(uint8_t, a_u8Value); } while (0)
    406406#define IEM_MC_STORE_GREG_U16(a_iGReg, a_u16Value)      do { CHK_TYPE(uint16_t, a_u16Value); } while (0)
     
    470470
    471471
    472 #define IEM_MC_FETCH_MREG_U64(a_u64Value, a_iMReg)          do { (a_u64Value) = 0; CHK_TYPE(uint64_t, a_u64Value); } while (0)
    473 #define IEM_MC_FETCH_MREG_U32(a_u32Value, a_iMReg)          do { (a_u32Value) = 0; CHK_TYPE(uint32_t, a_u32Value); } while (0)
    474 #define IEM_MC_STORE_MREG_U64(a_iMReg, a_u64Value)          do { CHK_TYPE(uint64_t, a_u64Value); } while (0)
    475 #define IEM_MC_STORE_MREG_U32_ZX_U64(a_iMReg, a_u32Value)   do { CHK_TYPE(uint32_t, a_u32Value); } while (0)
    476 #define IEM_MC_REF_MREG_U64(a_pu64Dst, a_iMReg)             do { (a_pu64Dst) = (uint64_t *)((uintptr_t)0); CHK_PTYPE(uint64_t *, a_pu64Dst); } while (0)
    477 #define IEM_MC_REF_MREG_U64_CONST(a_pu64Dst, a_iMReg)       do { (a_pu64Dst) = (uint64_t const *)((uintptr_t)0); CHK_PTYPE(uint64_t const *, a_pu64Dst); } while (0)
    478 #define IEM_MC_REF_MREG_U32_CONST(a_pu32Dst, a_iMReg)       do { (a_pu32Dst) = (uint32_t const *)((uintptr_t)0); CHK_PTYPE(uint32_t const *, a_pu32Dst); } while (0)
    479 
    480 #define IEM_MC_FETCH_XREG_U128(a_u128Value, a_iXReg)        do { (a_u128Value) = g_u128Zero; CHK_TYPE(uint128_t, a_u128Value); } while (0)
    481 #define IEM_MC_FETCH_XREG_U64(a_u64Value, a_iXReg)          do { (a_u64Value) = 0; CHK_TYPE(uint64_t, a_u64Value); } while (0)
    482 #define IEM_MC_FETCH_XREG_U32(a_u32Value, a_iXReg)          do { (a_u32Value) = 0; CHK_TYPE(uint32_t, a_u32Value); } while (0)
    483 #define IEM_MC_STORE_XREG_U128(a_iXReg, a_u128Value)        do { CHK_TYPE(uint128_t, a_u128Value); } while (0)
    484 #define IEM_MC_STORE_XREG_U64_ZX_U128(a_iXReg, a_u64Value)  do { CHK_TYPE(uint64_t, a_u64Value); } while (0)
    485 #define IEM_MC_STORE_XREG_U32_ZX_U128(a_iXReg, a_u32Value)  do { CHK_TYPE(uint32_t, a_u32Value); } while (0)
    486 #define IEM_MC_REF_XREG_U128(a_pu128Dst, a_iXReg)           do { (a_pu128Dst) = (uint128_t *)((uintptr_t)0);        CHK_PTYPE(uint128_t *, a_pu128Dst); } while (0)
    487 #define IEM_MC_REF_XREG_U128_CONST(a_pu128Dst, a_iXReg)     do { (a_pu128Dst) = (uint128_t const *)((uintptr_t)0);  CHK_PTYPE(uint128_t const *, a_pu128Dst); } while (0)
    488 #define IEM_MC_REF_XREG_U64_CONST(a_pu64Dst, a_iXReg)       do { (a_pu64Dst)  = (uint64_t const *)((uintptr_t)0);   CHK_PTYPE(uint64_t const *, a_pu64Dst); } while (0)
    489 #define IEM_MC_COPY_XREG_U128(a_iXRegDst, a_iXRegSrc)       do { } while (0)
     472#define IEM_MC_FETCH_MREG_U64(a_u64Value, a_iMReg)          do { (a_u64Value) = 0; CHK_TYPE(uint64_t, a_u64Value); (void)fFpuRead; } while (0)
     473#define IEM_MC_FETCH_MREG_U32(a_u32Value, a_iMReg)          do { (a_u32Value) = 0; CHK_TYPE(uint32_t, a_u32Value); (void)fFpuRead; } while (0)
     474#define IEM_MC_STORE_MREG_U64(a_iMReg, a_u64Value)          do { CHK_TYPE(uint64_t, a_u64Value); (void)fFpuWrite; } while (0)
     475#define IEM_MC_STORE_MREG_U32_ZX_U64(a_iMReg, a_u32Value)   do { CHK_TYPE(uint32_t, a_u32Value); (void)fFpuWrite; } while (0)
     476#define IEM_MC_REF_MREG_U64(a_pu64Dst, a_iMReg)             do { (a_pu64Dst) = (uint64_t *)((uintptr_t)0); CHK_PTYPE(uint64_t *, a_pu64Dst);             (void)fFpuWrite; } while (0)
     477#define IEM_MC_REF_MREG_U64_CONST(a_pu64Dst, a_iMReg)       do { (a_pu64Dst) = (uint64_t const *)((uintptr_t)0); CHK_PTYPE(uint64_t const *, a_pu64Dst); (void)fFpuWrite; } while (0)
     478#define IEM_MC_REF_MREG_U32_CONST(a_pu32Dst, a_iMReg)       do { (a_pu32Dst) = (uint32_t const *)((uintptr_t)0); CHK_PTYPE(uint32_t const *, a_pu32Dst); (void)fFpuWrite; } while (0)
     479
     480#define IEM_MC_FETCH_XREG_U128(a_u128Value, a_iXReg)        do { (a_u128Value) = g_u128Zero; CHK_TYPE(uint128_t, a_u128Value); (void)fSseRead;  } while (0)
     481#define IEM_MC_FETCH_XREG_U64(a_u64Value, a_iXReg)          do { (a_u64Value) = 0; CHK_TYPE(uint64_t, a_u64Value); (void)fSseRead; } while (0)
     482#define IEM_MC_FETCH_XREG_U32(a_u32Value, a_iXReg)          do { (a_u32Value) = 0; CHK_TYPE(uint32_t, a_u32Value); (void)fSseRead; } while (0)
     483#define IEM_MC_STORE_XREG_U128(a_iXReg, a_u128Value)        do { CHK_TYPE(uint128_t, a_u128Value); (void)fSseWrite; } while (0)
     484#define IEM_MC_STORE_XREG_U64_ZX_U128(a_iXReg, a_u64Value)  do { CHK_TYPE(uint64_t,  a_u64Value);  (void)fSseWrite; } while (0)
     485#define IEM_MC_STORE_XREG_U32_ZX_U128(a_iXReg, a_u32Value)  do { CHK_TYPE(uint32_t,  a_u32Value);  (void)fSseWrite; } while (0)
     486#define IEM_MC_REF_XREG_U128(a_pu128Dst, a_iXReg)           do { (a_pu128Dst) = (uint128_t *)((uintptr_t)0);        CHK_PTYPE(uint128_t *, a_pu128Dst);       (void)fSseWrite; } while (0)
     487#define IEM_MC_REF_XREG_U128_CONST(a_pu128Dst, a_iXReg)     do { (a_pu128Dst) = (uint128_t const *)((uintptr_t)0);  CHK_PTYPE(uint128_t const *, a_pu128Dst); (void)fSseWrite; } while (0)
     488#define IEM_MC_REF_XREG_U64_CONST(a_pu64Dst, a_iXReg)       do { (a_pu64Dst)  = (uint64_t const *)((uintptr_t)0);   CHK_PTYPE(uint64_t const *, a_pu64Dst);   (void)fSseWrite; } while (0)
     489#define IEM_MC_COPY_XREG_U128(a_iXRegDst, a_iXRegSrc)       do { (void)fSseWrite; } while (0)
    490490
    491491#define IEM_MC_FETCH_MEM_U8(a_u8Dst, a_iSeg, a_GCPtrMem)                do { CHK_GCPTR(a_GCPtrMem); } while (0)
     
    588588
    589589#define IEM_MC_CALL_FPU_AIMPL_1(a_pfnAImpl, a0) \
    590     do { CHK_CALL_ARG(a0, 0);  } while (0)
     590    do { (void)fFpuHost; (void)fFpuWrite; CHK_CALL_ARG(a0, 0);  } while (0)
    591591#define IEM_MC_CALL_FPU_AIMPL_2(a_pfnAImpl, a0, a1) \
    592     do { CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); } while (0)
     592    do { (void)fFpuHost; (void)fFpuWrite; CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); } while (0)
    593593#define IEM_MC_CALL_FPU_AIMPL_3(a_pfnAImpl, a0, a1, a2) \
    594     do { CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); CHK_CALL_ARG(a2, 2); } while (0)
    595 #define IEM_MC_SET_FPU_RESULT(a_FpuData, a_FSW, a_pr80Value)            do { } while (0)
    596 #define IEM_MC_PUSH_FPU_RESULT(a_FpuData)                               do { } while (0)
    597 #define IEM_MC_PUSH_FPU_RESULT_MEM_OP(a_FpuData, a_iEffSeg, a_GCPtrEff) do { } while (0)
    598 #define IEM_MC_PUSH_FPU_RESULT_TWO(a_FpuDataTwo)                        do { } while (0)
    599 #define IEM_MC_STORE_FPU_RESULT(a_FpuData, a_iStReg)                    do { } while (0)
    600 #define IEM_MC_STORE_FPU_RESULT_THEN_POP(a_FpuData, a_iStReg)           do { } while (0)
    601 #define IEM_MC_STORE_FPU_RESULT_MEM_OP(a_FpuData, a_iStReg, a_iEffSeg, a_GCPtrEff)              do { } while (0)
    602 #define IEM_MC_STORE_FPU_RESULT_MEM_OP_THEN_POP(a_FpuData, a_iStReg, a_iEffSeg, a_GCPtrEff)     do { } while (0)
    603 #define IEM_MC_FPU_STACK_UNDERFLOW(a_iStReg)                                                    do { } while (0)
    604 #define IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(a_iStReg, a_iEffSeg, a_GCPtrEff)                      do { } while (0)
    605 #define IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP(a_iStReg)                                           do { } while (0)
    606 #define IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(a_iStReg, a_iEffSeg, a_GCPtrEff)             do { } while (0)
    607 #define IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP_POP()                                               do { } while (0)
    608 #define IEM_MC_FPU_STACK_PUSH_UNDERFLOW()                                                       do { } while (0)
    609 #define IEM_MC_FPU_STACK_PUSH_UNDERFLOW_TWO()                                                   do { } while (0)
    610 #define IEM_MC_FPU_STACK_PUSH_OVERFLOW()                                                        do { } while (0)
    611 #define IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(a_iEffSeg, a_GCPtrEff)                            do { } while (0)
    612 #define IEM_MC_UPDATE_FPU_OPCODE_IP()                                                           do { } while (0)
    613 #define IEM_MC_FPU_STACK_DEC_TOP()                                                              do { } while (0)
    614 #define IEM_MC_FPU_STACK_INC_TOP()                                                              do { } while (0)
    615 #define IEM_MC_FPU_STACK_FREE(a_iStReg)                                                         do { } while (0)
    616 #define IEM_MC_UPDATE_FSW(a_u16FSW)                                                             do { } while (0)
    617 #define IEM_MC_UPDATE_FSW_CONST(a_u16FSW)                                                       do { } while (0)
    618 #define IEM_MC_UPDATE_FSW_WITH_MEM_OP(a_u16FSW, a_iEffSeg, a_GCPtrEff)                          do { } while (0)
    619 #define IEM_MC_UPDATE_FSW_THEN_POP(a_u16FSW)                                                    do { } while (0)
    620 #define IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(a_u16FSW, a_iEffSeg, a_GCPtrEff)                 do { } while (0)
    621 #define IEM_MC_UPDATE_FSW_THEN_POP_POP(a_u16FSW)                                                do { } while (0)
    622 #define IEM_MC_USED_FPU()                                                                       do { } while (0)
     594    do { (void)fFpuHost; (void)fFpuWrite; CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); CHK_CALL_ARG(a2, 2); } while (0)
     595#define IEM_MC_SET_FPU_RESULT(a_FpuData, a_FSW, a_pr80Value)            do { (void)fFpuWrite; } while (0)
     596#define IEM_MC_PUSH_FPU_RESULT(a_FpuData)                               do { (void)fFpuWrite; } while (0)
     597#define IEM_MC_PUSH_FPU_RESULT_MEM_OP(a_FpuData, a_iEffSeg, a_GCPtrEff) do { (void)fFpuWrite; } while (0)
     598#define IEM_MC_PUSH_FPU_RESULT_TWO(a_FpuDataTwo)                        do { (void)fFpuWrite; } while (0)
     599#define IEM_MC_STORE_FPU_RESULT(a_FpuData, a_iStReg)                    do { (void)fFpuWrite; } while (0)
     600#define IEM_MC_STORE_FPU_RESULT_THEN_POP(a_FpuData, a_iStReg)           do { (void)fFpuWrite; } while (0)
     601#define IEM_MC_STORE_FPU_RESULT_MEM_OP(a_FpuData, a_iStReg, a_iEffSeg, a_GCPtrEff)              do { (void)fFpuWrite; } while (0)
     602#define IEM_MC_STORE_FPU_RESULT_MEM_OP_THEN_POP(a_FpuData, a_iStReg, a_iEffSeg, a_GCPtrEff)     do { (void)fFpuWrite; } while (0)
     603#define IEM_MC_FPU_STACK_UNDERFLOW(a_iStReg)                                                    do { (void)fFpuWrite; } while (0)
     604#define IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(a_iStReg, a_iEffSeg, a_GCPtrEff)                      do { (void)fFpuWrite; } while (0)
     605#define IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP(a_iStReg)                                           do { (void)fFpuWrite; } while (0)
     606#define IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(a_iStReg, a_iEffSeg, a_GCPtrEff)             do { (void)fFpuWrite; } while (0)
     607#define IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP_POP()                                               do { (void)fFpuWrite; } while (0)
     608#define IEM_MC_FPU_STACK_PUSH_UNDERFLOW()                                                       do { (void)fFpuWrite; } while (0)
     609#define IEM_MC_FPU_STACK_PUSH_UNDERFLOW_TWO()                                                   do { (void)fFpuWrite; } while (0)
     610#define IEM_MC_FPU_STACK_PUSH_OVERFLOW()                                                        do { (void)fFpuWrite; } while (0)
     611#define IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(a_iEffSeg, a_GCPtrEff)                            do { (void)fFpuWrite; } while (0)
     612#define IEM_MC_UPDATE_FPU_OPCODE_IP()                                                           do { (void)fFpuWrite; } while (0)
     613#define IEM_MC_FPU_STACK_DEC_TOP()                                                              do { (void)fFpuWrite; } while (0)
     614#define IEM_MC_FPU_STACK_INC_TOP()                                                              do { (void)fFpuWrite; } while (0)
     615#define IEM_MC_FPU_STACK_FREE(a_iStReg)                                                         do { (void)fFpuWrite; } while (0)
     616#define IEM_MC_UPDATE_FSW(a_u16FSW)                                                             do { (void)fFpuWrite; } while (0)
     617#define IEM_MC_UPDATE_FSW_CONST(a_u16FSW)                                                       do { (void)fFpuWrite; } while (0)
     618#define IEM_MC_UPDATE_FSW_WITH_MEM_OP(a_u16FSW, a_iEffSeg, a_GCPtrEff)                          do { (void)fFpuWrite; } while (0)
     619#define IEM_MC_UPDATE_FSW_THEN_POP(a_u16FSW)                                                    do { (void)fFpuWrite; } while (0)
     620#define IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(a_u16FSW, a_iEffSeg, a_GCPtrEff)                 do { (void)fFpuWrite; } while (0)
     621#define IEM_MC_UPDATE_FSW_THEN_POP_POP(a_u16FSW)                                                do { (void)fFpuWrite; } while (0)
     622#define IEM_MC_PREPARE_FPU_USAGE() \
     623    const int fFpuRead = 1, fFpuWrite = 1, fFpuHost = 1, fSseRead = 1, fSseWrite = 1, fSseHost = 1
     624#define IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ()   const int fFpuRead = 1, fSseRead = 1
     625#define IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE() const int fFpuRead = 1, fFpuWrite = 1, fSseRead = 1, fSseWrite = 1
     626#define IEM_MC_PREPARE_SSE_USAGE()              const int fSseRead = 1, fSseWrite = 1, fSseHost = 1
     627#define IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ()   const int fSseRead = 1
     628#define IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE() const int fSseRead = 1, fSseWrite = 1
    623629
    624630#define IEM_MC_CALL_MMX_AIMPL_2(a_pfnAImpl, a0, a1) \
    625     do { CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); } while (0)
     631    do { (void)fFpuHost; (void)fFpuWrite; CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); } while (0)
    626632#define IEM_MC_CALL_MMX_AIMPL_3(a_pfnAImpl, a0, a1, a2) \
    627     do { CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); CHK_CALL_ARG(a2, 2);} while (0)
     633    do { (void)fFpuHost; (void)fFpuWrite; CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); CHK_CALL_ARG(a2, 2);} while (0)
    628634#define IEM_MC_CALL_SSE_AIMPL_2(a_pfnAImpl, a0, a1) \
    629     do { CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); } while (0)
     635    do { (void)fSseHost; (void)fSseWrite; CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); } while (0)
    630636#define IEM_MC_CALL_SSE_AIMPL_3(a_pfnAImpl, a0, a1, a2) \
    631     do { CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); CHK_CALL_ARG(a2, 2);} while (0)
     637    do { (void)fSseHost; (void)fSseWrite; CHK_CALL_ARG(a0, 0); CHK_CALL_ARG(a1, 1); CHK_CALL_ARG(a2, 2);} while (0)
    632638
    633639#define IEM_MC_IF_EFL_BIT_SET(a_fBit)                                   if (g_fRandom) {
     
    650656#define IEM_MC_IF_LOCAL_IS_Z(a_Local)                                   if ((a_Local) == 0) {
    651657#define IEM_MC_IF_GREG_BIT_SET(a_iGReg, a_iBitNo)                       if (g_fRandom) {
    652 #define IEM_MC_IF_FPUREG_NOT_EMPTY(a_iSt)                               if (g_fRandom) {
    653 #define IEM_MC_IF_FPUREG_IS_EMPTY(a_iSt)                                if (g_fRandom) {
     658#define IEM_MC_IF_FPUREG_NOT_EMPTY(a_iSt)                               if (g_fRandom != fFpuRead) {
     659#define IEM_MC_IF_FPUREG_IS_EMPTY(a_iSt)                                if (g_fRandom != fFpuRead) {
    654660#define IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(a_pr80Dst, a_iSt) \
    655661    a_pr80Dst = NULL; \
    656     if (g_fRandom) {
     662    if (g_fRandom != fFpuRead) {
    657663#define IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(p0, i0, p1, i1) \
    658664    p0 = NULL; \
    659665    p1 = NULL; \
    660     if (g_fRandom) {
     666    if (g_fRandom != fFpuRead) {
    661667#define IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(p0, i0, i1) \
    662668    p0 = NULL; \
    663     if (g_fRandom) {
    664 #define IEM_MC_IF_FCW_IM()                                              if (g_fRandom) {
     669    if (g_fRandom != fFpuRead) {
     670#define IEM_MC_IF_FCW_IM()                                              if (g_fRandom != fFpuRead) {
    665671#define IEM_MC_ELSE()                                                   } else {
    666672#define IEM_MC_ENDIF()                                                  } do {} 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