VirtualBox

Ignore:
Timestamp:
Jul 4, 2016 7:58:28 PM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
108473
Message:

IEM: Switched from using IEMCPU directly to using with via VMCPU. This saves 4-5 KB in 64-bit mode (~1.2%), but the 32-bit code is larger (suspecting because we lost a few some 8-bit displacements).

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r61885 r62015  
    4545        IEM_MC_ARG(uint32_t *, pEFlags, 2);
    4646
    47         IEM_MC_FETCH_GREG_U8(u8Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    48         IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     47        IEM_MC_FETCH_GREG_U8(u8Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     48        IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    4949        IEM_MC_REF_EFLAGS(pEFlags);
    5050        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, u8Src, pEFlags);
    … …  
    6868
    6969        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    70         IEM_MC_MEM_MAP(pu8Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    71         IEM_MC_FETCH_GREG_U8(u8Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     70        IEM_MC_MEM_MAP(pu8Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     71        IEM_MC_FETCH_GREG_U8(u8Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    7272        IEM_MC_FETCH_EFLAGS(EFlags);
    73         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     73        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    7474            IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, u8Src, pEFlags);
    7575        else
    … …  
    102102        IEMOP_HLP_NO_LOCK_PREFIX();
    103103
    104         switch (pIemCpu->enmEffOpSize)
     104        switch (pVCpu->iem.s.enmEffOpSize)
    105105        {
    106106            case IEMMODE_16BIT:
    … …  
    110110                IEM_MC_ARG(uint32_t *, pEFlags, 2);
    111111
    112                 IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    113                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     112                IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     113                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    114114                IEM_MC_REF_EFLAGS(pEFlags);
    115115                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    … …  
    125125                IEM_MC_ARG(uint32_t *, pEFlags, 2);
    126126
    127                 IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    128                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     127                IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     128                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    129129                IEM_MC_REF_EFLAGS(pEFlags);
    130130                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    … …  
    142142                IEM_MC_ARG(uint32_t *, pEFlags, 2);
    143143
    144                 IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    145                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     144                IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     145                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    146146                IEM_MC_REF_EFLAGS(pEFlags);
    147147                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    … …  
    160160         */
    161161        uint32_t const fAccess = pImpl->pfnLockedU8 ? IEM_ACCESS_DATA_RW : IEM_ACCESS_DATA_R /* CMP,TEST */;
    162         switch (pIemCpu->enmEffOpSize)
     162        switch (pVCpu->iem.s.enmEffOpSize)
    163163        {
    164164            case IEMMODE_16BIT:
    … …  
    170170
    171171                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    172                 IEM_MC_MEM_MAP(pu16Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    173                 IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     172                IEM_MC_MEM_MAP(pu16Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     173                IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    174174                IEM_MC_FETCH_EFLAGS(EFlags);
    175                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     175                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    176176                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    177177                else
    … …  
    192192
    193193                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    194                 IEM_MC_MEM_MAP(pu32Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    195                 IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     194                IEM_MC_MEM_MAP(pu32Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     195                IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    196196                IEM_MC_FETCH_EFLAGS(EFlags);
    197                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     197                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    198198                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    199199                else
    … …  
    214214
    215215                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    216                 IEM_MC_MEM_MAP(pu64Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    217                 IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     216                IEM_MC_MEM_MAP(pu64Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     217                IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    218218                IEM_MC_FETCH_EFLAGS(EFlags);
    219                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     219                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    220220                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    221221                else
    … …  
    254254        IEM_MC_ARG(uint32_t *, pEFlags, 2);
    255255
    256         IEM_MC_FETCH_GREG_U8(u8Src, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    257         IEM_MC_REF_GREG_U8(pu8Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     256        IEM_MC_FETCH_GREG_U8(u8Src, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     257        IEM_MC_REF_GREG_U8(pu8Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    258258        IEM_MC_REF_EFLAGS(pEFlags);
    259259        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, u8Src, pEFlags);
    … …  
    274274
    275275        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    276         IEM_MC_FETCH_MEM_U8(u8Src, pIemCpu->iEffSeg, GCPtrEffDst);
    277         IEM_MC_REF_GREG_U8(pu8Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     276        IEM_MC_FETCH_MEM_U8(u8Src, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     277        IEM_MC_REF_GREG_U8(pu8Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    278278        IEM_MC_REF_EFLAGS(pEFlags);
    279279        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, u8Src, pEFlags);
    … …  
    302302    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    303303    {
    304         switch (pIemCpu->enmEffOpSize)
     304        switch (pVCpu->iem.s.enmEffOpSize)
    305305        {
    306306            case IEMMODE_16BIT:
    … …  
    310310                IEM_MC_ARG(uint32_t *, pEFlags, 2);
    311311
    312                 IEM_MC_FETCH_GREG_U16(u16Src, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    313                 IEM_MC_REF_GREG_U16(pu16Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     312                IEM_MC_FETCH_GREG_U16(u16Src, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     313                IEM_MC_REF_GREG_U16(pu16Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    314314                IEM_MC_REF_EFLAGS(pEFlags);
    315315                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    … …  
    325325                IEM_MC_ARG(uint32_t *, pEFlags, 2);
    326326
    327                 IEM_MC_FETCH_GREG_U32(u32Src, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    328                 IEM_MC_REF_GREG_U32(pu32Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     327                IEM_MC_FETCH_GREG_U32(u32Src, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     328                IEM_MC_REF_GREG_U32(pu32Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    329329                IEM_MC_REF_EFLAGS(pEFlags);
    330330                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    … …  
    341341                IEM_MC_ARG(uint32_t *, pEFlags, 2);
    342342
    343                 IEM_MC_FETCH_GREG_U64(u64Src, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    344                 IEM_MC_REF_GREG_U64(pu64Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     343                IEM_MC_FETCH_GREG_U64(u64Src, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     344                IEM_MC_REF_GREG_U64(pu64Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    345345                IEM_MC_REF_EFLAGS(pEFlags);
    346346                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    … …  
    356356         * We're accessing memory.
    357357         */
    358         switch (pIemCpu->enmEffOpSize)
     358        switch (pVCpu->iem.s.enmEffOpSize)
    359359        {
    360360            case IEMMODE_16BIT:
    … …  
    366366
    367367                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    368                 IEM_MC_FETCH_MEM_U16(u16Src, pIemCpu->iEffSeg, GCPtrEffDst);
    369                 IEM_MC_REF_GREG_U16(pu16Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     368                IEM_MC_FETCH_MEM_U16(u16Src, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     369                IEM_MC_REF_GREG_U16(pu16Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    370370                IEM_MC_REF_EFLAGS(pEFlags);
    371371                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    … …  
    383383
    384384                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    385                 IEM_MC_FETCH_MEM_U32(u32Src, pIemCpu->iEffSeg, GCPtrEffDst);
    386                 IEM_MC_REF_GREG_U32(pu32Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     385                IEM_MC_FETCH_MEM_U32(u32Src, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     386                IEM_MC_REF_GREG_U32(pu32Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    387387                IEM_MC_REF_EFLAGS(pEFlags);
    388388                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    … …  
    401401
    402402                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    403                 IEM_MC_FETCH_MEM_U64(u64Src, pIemCpu->iEffSeg, GCPtrEffDst);
    404                 IEM_MC_REF_GREG_U64(pu64Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     403                IEM_MC_FETCH_MEM_U64(u64Src, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     404                IEM_MC_REF_GREG_U64(pu64Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    405405                IEM_MC_REF_EFLAGS(pEFlags);
    406406                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    … …  
    449449FNIEMOP_DEF_1(iemOpHlpBinaryOperator_rAX_Iz, PCIEMOPBINSIZES, pImpl)
    450450{
    451     switch (pIemCpu->enmEffOpSize)
     451    switch (pVCpu->iem.s.enmEffOpSize)
    452452    {
    453453        case IEMMODE_16BIT:
    … …  
    555555    {
    556556        IEMOP_HLP_DECODED_NL_1(OP_SLDT, IEMOPFORM_M_REG, OP_PARM_Ew, DISOPTYPE_DANGEROUS | DISOPTYPE_PRIVILEGED_NOTRAP);
    557         switch (pIemCpu->enmEffOpSize)
     557        switch (pVCpu->iem.s.enmEffOpSize)
    558558        {
    559559            case IEMMODE_16BIT:
    … …  
    561561                IEM_MC_LOCAL(uint16_t, u16Ldtr);
    562562                IEM_MC_FETCH_LDTR_U16(u16Ldtr);
    563                 IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u16Ldtr);
     563                IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u16Ldtr);
    564564                IEM_MC_ADVANCE_RIP();
    565565                IEM_MC_END();
    … …  
    570570                IEM_MC_LOCAL(uint32_t, u32Ldtr);
    571571                IEM_MC_FETCH_LDTR_U32(u32Ldtr);
    572                 IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u32Ldtr);
     572                IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u32Ldtr);
    573573                IEM_MC_ADVANCE_RIP();
    574574                IEM_MC_END();
    … …  
    579579                IEM_MC_LOCAL(uint64_t, u64Ldtr);
    580580                IEM_MC_FETCH_LDTR_U64(u64Ldtr);
    581                 IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u64Ldtr);
     581                IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u64Ldtr);
    582582                IEM_MC_ADVANCE_RIP();
    583583                IEM_MC_END();
    … …  
    595595        IEMOP_HLP_DECODED_NL_1(OP_SLDT, IEMOPFORM_M_MEM, OP_PARM_Ew, DISOPTYPE_DANGEROUS | DISOPTYPE_PRIVILEGED_NOTRAP);
    596596        IEM_MC_FETCH_LDTR_U16(u16Ldtr);
    597         IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Ldtr);
     597        IEM_MC_STORE_MEM_U16(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u16Ldtr);
    598598        IEM_MC_ADVANCE_RIP();
    599599        IEM_MC_END();
    … …  
    613613    {
    614614        IEMOP_HLP_DECODED_NL_1(OP_STR, IEMOPFORM_M_REG, OP_PARM_Ew, DISOPTYPE_DANGEROUS | DISOPTYPE_PRIVILEGED_NOTRAP);
    615         switch (pIemCpu->enmEffOpSize)
     615        switch (pVCpu->iem.s.enmEffOpSize)
    616616        {
    617617            case IEMMODE_16BIT:
    … …  
    619619                IEM_MC_LOCAL(uint16_t, u16Tr);
    620620                IEM_MC_FETCH_TR_U16(u16Tr);
    621                 IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u16Tr);
     621                IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u16Tr);
    622622                IEM_MC_ADVANCE_RIP();
    623623                IEM_MC_END();
    … …  
    628628                IEM_MC_LOCAL(uint32_t, u32Tr);
    629629                IEM_MC_FETCH_TR_U32(u32Tr);
    630                 IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u32Tr);
     630                IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u32Tr);
    631631                IEM_MC_ADVANCE_RIP();
    632632                IEM_MC_END();
    … …  
    637637                IEM_MC_LOCAL(uint64_t, u64Tr);
    638638                IEM_MC_FETCH_TR_U64(u64Tr);
    639                 IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u64Tr);
     639                IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u64Tr);
    640640                IEM_MC_ADVANCE_RIP();
    641641                IEM_MC_END();
    … …  
    653653        IEMOP_HLP_DECODED_NL_1(OP_STR, IEMOPFORM_M_MEM, OP_PARM_Ew, DISOPTYPE_DANGEROUS | DISOPTYPE_PRIVILEGED_NOTRAP);
    654654        IEM_MC_FETCH_TR_U16(u16Tr);
    655         IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Tr);
     655        IEM_MC_STORE_MEM_U16(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u16Tr);
    656656        IEM_MC_ADVANCE_RIP();
    657657        IEM_MC_END();
    … …  
    673673        IEM_MC_BEGIN(1, 0);
    674674        IEM_MC_ARG(uint16_t, u16Sel, 0);
    675         IEM_MC_FETCH_GREG_U16(u16Sel, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     675        IEM_MC_FETCH_GREG_U16(u16Sel, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    676676        IEM_MC_CALL_CIMPL_1(iemCImpl_lldt, u16Sel);
    677677        IEM_MC_END();
    … …  
    685685        IEMOP_HLP_DECODED_NL_1(OP_LLDT, IEMOPFORM_M_MEM, OP_PARM_Ew, DISOPTYPE_DANGEROUS);
    686686        IEM_MC_RAISE_GP0_IF_CPL_NOT_ZERO(); /** @todo test order */
    687         IEM_MC_FETCH_MEM_U16(u16Sel, pIemCpu->iEffSeg, GCPtrEffSrc);
     687        IEM_MC_FETCH_MEM_U16(u16Sel, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    688688        IEM_MC_CALL_CIMPL_1(iemCImpl_lldt, u16Sel);
    689689        IEM_MC_END();
    … …  
    705705        IEM_MC_BEGIN(1, 0);
    706706        IEM_MC_ARG(uint16_t, u16Sel, 0);
    707         IEM_MC_FETCH_GREG_U16(u16Sel, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     707        IEM_MC_FETCH_GREG_U16(u16Sel, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    708708        IEM_MC_CALL_CIMPL_1(iemCImpl_ltr, u16Sel);
    709709        IEM_MC_END();
    … …  
    717717        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    718718        IEM_MC_RAISE_GP0_IF_CPL_NOT_ZERO(); /** @todo test ordre */
    719         IEM_MC_FETCH_MEM_U16(u16Sel, pIemCpu->iEffSeg, GCPtrEffSrc);
     719        IEM_MC_FETCH_MEM_U16(u16Sel, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    720720        IEM_MC_CALL_CIMPL_1(iemCImpl_ltr, u16Sel);
    721721        IEM_MC_END();
    … …  
    737737        IEM_MC_ARG(uint16_t,    u16Sel,            0);
    738738        IEM_MC_ARG_CONST(bool,  fWriteArg, fWrite, 1);
    739         IEM_MC_FETCH_GREG_U16(u16Sel, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     739        IEM_MC_FETCH_GREG_U16(u16Sel, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    740740        IEM_MC_CALL_CIMPL_2(iemCImpl_VerX, u16Sel, fWriteArg);
    741741        IEM_MC_END();
    … …  
    749749        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    750750        IEMOP_HLP_DECODED_NL_1(fWrite ? OP_VERW : OP_VERR, IEMOPFORM_M_MEM, OP_PARM_Ew, DISOPTYPE_DANGEROUS | DISOPTYPE_PRIVILEGED_NOTRAP);
    751         IEM_MC_FETCH_MEM_U16(u16Sel, pIemCpu->iEffSeg, GCPtrEffSrc);
     751        IEM_MC_FETCH_MEM_U16(u16Sel, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    752752        IEM_MC_CALL_CIMPL_2(iemCImpl_VerX, u16Sel, fWriteArg);
    753753        IEM_MC_END();
    … …  
    809809    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    810810    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    811     IEM_MC_ASSIGN(iEffSeg, pIemCpu->iEffSeg);
     811    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
    812812    IEM_MC_CALL_CIMPL_2(iemCImpl_sgdt, iEffSeg, GCPtrEffSrc);
    813813    IEM_MC_END();
    … …  
    859859    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    860860    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    861     IEM_MC_ASSIGN(iEffSeg, pIemCpu->iEffSeg);
     861    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
    862862    IEM_MC_CALL_CIMPL_2(iemCImpl_sidt, iEffSeg, GCPtrEffSrc);
    863863    IEM_MC_END();
    … …  
    871871    IEMOP_MNEMONIC("monitor");
    872872    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX(); /** @todo Verify that monitor is allergic to lock prefixes. */
    873     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_monitor, pIemCpu->iEffSeg);
     873    return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_monitor, pVCpu->iem.s.iEffSeg);
    874874}
    875875
    … …  
    892892    IEM_MC_ARG(uint8_t,         iEffSeg,                                    0);
    893893    IEM_MC_ARG(RTGCPTR,         GCPtrEffSrc,                                1);
    894     IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSizeArg,/*=*/pIemCpu->enmEffOpSize, 2);
     894    IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSizeArg,/*=*/pVCpu->iem.s.enmEffOpSize, 2);
    895895    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    896896    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    897     IEM_MC_ASSIGN(iEffSeg, pIemCpu->iEffSeg);
     897    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
    898898    IEM_MC_CALL_CIMPL_3(iemCImpl_lgdt, iEffSeg, GCPtrEffSrc, enmEffOpSizeArg);
    899899    IEM_MC_END();
    … …  
    906906{
    907907    IEMOP_MNEMONIC("xgetbv");
    908     if (IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fXSaveRstor)
     908    if (IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fXSaveRstor)
    909909    {
    910910        IEMOP_HLP_DONE_DECODING_NO_LOCK_REPZ_OR_REPNZ_PREFIXES();
    … …  
    919919{
    920920    IEMOP_MNEMONIC("xsetbv");
    921     if (IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fXSaveRstor)
     921    if (IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fXSaveRstor)
    922922    {
    923923        IEMOP_HLP_DONE_DECODING_NO_LOCK_REPZ_OR_REPNZ_PREFIXES();
    … …  
    931931FNIEMOP_DEF_1(iemOp_Grp7_lidt, uint8_t, bRm)
    932932{
    933     IEMMODE enmEffOpSize = pIemCpu->enmCpuMode == IEMMODE_64BIT
     933    IEMMODE enmEffOpSize = pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT
    934934                         ? IEMMODE_64BIT
    935                          : pIemCpu->enmEffOpSize;
     935                         : pVCpu->iem.s.enmEffOpSize;
    936936    IEM_MC_BEGIN(3, 1);
    937937    IEM_MC_ARG(uint8_t,         iEffSeg,                            0);
    … …  
    940940    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    941941    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    942     IEM_MC_ASSIGN(iEffSeg, pIemCpu->iEffSeg);
     942    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
    943943    IEM_MC_CALL_CIMPL_3(iemCImpl_lidt, iEffSeg, GCPtrEffSrc, enmEffOpSizeArg);
    944944    IEM_MC_END();
    … …  
    979979    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    980980    {
    981         switch (pIemCpu->enmEffOpSize)
     981        switch (pVCpu->iem.s.enmEffOpSize)
    982982        {
    983983            case IEMMODE_16BIT:
    … …  
    985985                IEM_MC_LOCAL(uint16_t, u16Tmp);
    986986                IEM_MC_FETCH_CR0_U16(u16Tmp);
    987                 if (IEM_GET_TARGET_CPU(pIemCpu) > IEMTARGETCPU_386)
     987                if (IEM_GET_TARGET_CPU(pVCpu) > IEMTARGETCPU_386)
    988988                { /* likely */ }
    989                 else if (IEM_GET_TARGET_CPU(pIemCpu) >= IEMTARGETCPU_386)
     989                else if (IEM_GET_TARGET_CPU(pVCpu) >= IEMTARGETCPU_386)
    990990                    IEM_MC_OR_LOCAL_U16(u16Tmp, 0xffe0);
    991991                else
    992992                    IEM_MC_OR_LOCAL_U16(u16Tmp, 0xfff0);
    993                 IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u16Tmp);
     993                IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u16Tmp);
    994994                IEM_MC_ADVANCE_RIP();
    995995                IEM_MC_END();
    … …  
    10001000                IEM_MC_LOCAL(uint32_t, u32Tmp);
    10011001                IEM_MC_FETCH_CR0_U32(u32Tmp);
    1002                 IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u32Tmp);
     1002                IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u32Tmp);
    10031003                IEM_MC_ADVANCE_RIP();
    10041004                IEM_MC_END();
    … …  
    10091009                IEM_MC_LOCAL(uint64_t, u64Tmp);
    10101010                IEM_MC_FETCH_CR0_U64(u64Tmp);
    1011                 IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u64Tmp);
     1011                IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u64Tmp);
    10121012                IEM_MC_ADVANCE_RIP();
    10131013                IEM_MC_END();
    … …  
    10251025        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10261026        IEM_MC_FETCH_CR0_U16(u16Tmp);
    1027         if (IEM_GET_TARGET_CPU(pIemCpu) > IEMTARGETCPU_386)
     1027        if (IEM_GET_TARGET_CPU(pVCpu) > IEMTARGETCPU_386)
    10281028        { /* likely */ }
    1029         else if (pIemCpu->uTargetCpu >= IEMTARGETCPU_386)
     1029        else if (pVCpu->iem.s.uTargetCpu >= IEMTARGETCPU_386)
    10301030            IEM_MC_OR_LOCAL_U16(u16Tmp, 0xffe0);
    10311031        else
    10321032            IEM_MC_OR_LOCAL_U16(u16Tmp, 0xfff0);
    1033         IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Tmp);
     1033        IEM_MC_STORE_MEM_U16(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u16Tmp);
    10341034        IEM_MC_ADVANCE_RIP();
    10351035        IEM_MC_END();
    … …  
    10511051        IEM_MC_BEGIN(1, 0);
    10521052        IEM_MC_ARG(uint16_t, u16Tmp, 0);
    1053         IEM_MC_FETCH_GREG_U16(u16Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1053        IEM_MC_FETCH_GREG_U16(u16Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    10541054        IEM_MC_CALL_CIMPL_1(iemCImpl_lmsw, u16Tmp);
    10551055        IEM_MC_END();
    … …  
    10611061        IEM_MC_LOCAL(RTGCPTR,  GCPtrEffDst);
    10621062        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    1063         IEM_MC_FETCH_MEM_U16(u16Tmp, pIemCpu->iEffSeg, GCPtrEffDst);
     1063        IEM_MC_FETCH_MEM_U16(u16Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    10641064        IEM_MC_CALL_CIMPL_1(iemCImpl_lmsw, u16Tmp);
    10651065        IEM_MC_END();
    … …  
    10971097FNIEMOP_DEF(iemOp_Grp7_rdtscp)
    10981098{
    1099     NOREF(pIemCpu);
     1099    NOREF(pVCpu);
    11001100    IEMOP_BITCH_ABOUT_STUB();
    11011101    return VERR_IEM_INSTR_NOT_IMPLEMENTED;
    … …  
    11891189    {
    11901190        IEMOP_HLP_DECODED_NL_2(fIsLar ? OP_LAR : OP_LSL, IEMOPFORM_RM_REG, OP_PARM_Gv, OP_PARM_Ew, DISOPTYPE_DANGEROUS | DISOPTYPE_PRIVILEGED_NOTRAP);
    1191         switch (pIemCpu->enmEffOpSize)
     1191        switch (pVCpu->iem.s.enmEffOpSize)
    11921192        {
    11931193            case IEMMODE_16BIT:
    … …  
    11991199                IEM_MC_ARG_CONST(bool,  fIsLarArg, fIsLar, 3);
    12001200
    1201                 IEM_MC_REF_GREG_U16(pu16Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    1202                 IEM_MC_FETCH_GREG_U16(u16Sel, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1201                IEM_MC_REF_GREG_U16(pu16Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1202                IEM_MC_FETCH_GREG_U16(u16Sel, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    12031203                IEM_MC_REF_EFLAGS(pEFlags);
    12041204                IEM_MC_CALL_CIMPL_4(iemCImpl_LarLsl_u16, pu16Dst, u16Sel, pEFlags, fIsLarArg);
    … …  
    12171217                IEM_MC_ARG_CONST(bool,  fIsLarArg, fIsLar, 3);
    12181218
    1219                 IEM_MC_REF_GREG_U64(pu64Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    1220                 IEM_MC_FETCH_GREG_U16(u16Sel, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1219                IEM_MC_REF_GREG_U64(pu64Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1220                IEM_MC_FETCH_GREG_U16(u16Sel, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    12211221                IEM_MC_REF_EFLAGS(pEFlags);
    12221222                IEM_MC_CALL_CIMPL_4(iemCImpl_LarLsl_u64, pu64Dst, u16Sel, pEFlags, fIsLarArg);
    … …  
    12311231    else
    12321232    {
    1233         switch (pIemCpu->enmEffOpSize)
     1233        switch (pVCpu->iem.s.enmEffOpSize)
    12341234        {
    12351235            case IEMMODE_16BIT:
    … …  
    12451245                IEMOP_HLP_DECODED_NL_2(fIsLar ? OP_LAR : OP_LSL, IEMOPFORM_RM_MEM, OP_PARM_Gv, OP_PARM_Ew, DISOPTYPE_DANGEROUS | DISOPTYPE_PRIVILEGED_NOTRAP);
    12461246
    1247                 IEM_MC_FETCH_MEM_U16(u16Sel, pIemCpu->iEffSeg, GCPtrEffSrc);
    1248                 IEM_MC_REF_GREG_U16(pu16Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     1247                IEM_MC_FETCH_MEM_U16(u16Sel, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     1248                IEM_MC_REF_GREG_U16(pu16Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    12491249                IEM_MC_REF_EFLAGS(pEFlags);
    12501250                IEM_MC_CALL_CIMPL_4(iemCImpl_LarLsl_u16, pu16Dst, u16Sel, pEFlags, fIsLarArg);
    … …  
    12681268/** @todo testcase: make sure it's a 16-bit read. */
    12691269
    1270                 IEM_MC_FETCH_MEM_U16(u16Sel, pIemCpu->iEffSeg, GCPtrEffSrc);
    1271                 IEM_MC_REF_GREG_U64(pu64Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     1270                IEM_MC_FETCH_MEM_U16(u16Sel, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     1271                IEM_MC_REF_GREG_U64(pu64Dst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    12721272                IEM_MC_REF_EFLAGS(pEFlags);
    12731273                IEM_MC_CALL_CIMPL_4(iemCImpl_LarLsl_u64, pu64Dst, u16Sel, pEFlags, fIsLarArg);
    … …  
    13571357{
    13581358    /* AMD prefetch group, Intel implements this as NOP Ev (and so do we). */
    1359     if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->f3DNowPrefetch)
     1359    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->f3DNowPrefetch)
    13601360    {
    13611361        IEMOP_MNEMONIC("GrpP");
    … …  
    14741474FNIEMOP_DEF(iemOp_3Dnow)
    14751475{
    1476     if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->f3DNow)
     1476    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->f3DNow)
    14771477    {
    14781478        IEMOP_MNEMONIC("3Dnow");
    … …  
    15221522{
    15231523    /* Quick hack. Need to restructure all of this later some time. */
    1524     uint32_t const fRelevantPrefix = pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ);
     1524    uint32_t const fRelevantPrefix = pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ);
    15251525    if (fRelevantPrefix == 0)
    15261526    {
    … …  
    15361536            IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    15371537            IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    1538             IEM_MC_COPY_XREG_U128((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB,
    1539                                   ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     1538            IEM_MC_COPY_XREG_U128((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
     1539                                  ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    15401540            IEM_MC_ADVANCE_RIP();
    15411541            IEM_MC_END();
    … …  
    15551555            IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    15561556
    1557             IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    1558             IEM_MC_STORE_MEM_U128(pIemCpu->iEffSeg, GCPtrEffSrc, uSrc);
     1557            IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1558            IEM_MC_STORE_MEM_U128(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
    15591559
    15601560            IEM_MC_ADVANCE_RIP();
    … …  
    15771577            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    15781578            IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    1579             IEM_MC_FETCH_XREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    1580             IEM_MC_STORE_XREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, uSrc);
     1579            IEM_MC_FETCH_XREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1580            IEM_MC_STORE_XREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, uSrc);
    15811581
    15821582            IEM_MC_ADVANCE_RIP();
    … …  
    15971597            IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    15981598
    1599             IEM_MC_FETCH_XREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    1600             IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffSrc, uSrc);
     1599            IEM_MC_FETCH_XREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1600            IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
    16011601
    16021602            IEM_MC_ADVANCE_RIP();
    … …  
    16211621{
    16221622    /* Quick hack. Need to restructure all of this later some time. */
    1623     if (pIemCpu->fPrefixes == IEM_OP_PRF_SIZE_OP)
     1623    if (pVCpu->iem.s.fPrefixes == IEM_OP_PRF_SIZE_OP)
    16241624    {
    16251625        IEMOP_MNEMONIC("movlpd Mq,Vq");
    … …  
    16361636            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    16371637            IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    1638             IEM_MC_FETCH_XREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    1639             IEM_MC_STORE_XREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, uSrc);
     1638            IEM_MC_FETCH_XREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1639            IEM_MC_STORE_XREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, uSrc);
    16401640            IEM_MC_ADVANCE_RIP();
    16411641            IEM_MC_END();
    … …  
    16581658            IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    16591659
    1660             IEM_MC_FETCH_XREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    1661             IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffSrc, uSrc);
     1660            IEM_MC_FETCH_XREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1661            IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
    16621662
    16631663            IEM_MC_ADVANCE_RIP();
    … …  
    17451745    IEMOP_MNEMONIC("mov Rd,Cd");
    17461746    IEMOP_HLP_MIN_386();
    1747     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    1748         pIemCpu->enmEffOpSize = pIemCpu->enmDefOpSize = IEMMODE_64BIT;
     1747    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
     1748        pVCpu->iem.s.enmEffOpSize = pVCpu->iem.s.enmDefOpSize = IEMMODE_64BIT;
    17491749    else
    1750         pIemCpu->enmEffOpSize = pIemCpu->enmDefOpSize = IEMMODE_32BIT;
     1750        pVCpu->iem.s.enmEffOpSize = pVCpu->iem.s.enmDefOpSize = IEMMODE_32BIT;
    17511751
    17521752    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    1753     uint8_t iCrReg = ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg;
    1754     if (pIemCpu->fPrefixes & IEM_OP_PRF_LOCK)
     1753    uint8_t iCrReg = ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg;
     1754    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK)
    17551755    {
    17561756        /* The lock prefix can be used to encode CR8 accesses on some CPUs. */
    1757         if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fMovCr8In32Bit)
     1757        if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fMovCr8In32Bit)
    17581758            return IEMOP_RAISE_INVALID_OPCODE(); /* #UD takes precedence over #GP(), see test. */
    17591759        iCrReg |= 8;
    … …  
    17681768    IEMOP_HLP_DONE_DECODING();
    17691769
    1770     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_mov_Rd_Cd, (X86_MODRM_RM_MASK & bRm) | pIemCpu->uRexB, iCrReg);
     1770    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_mov_Rd_Cd, (X86_MODRM_RM_MASK & bRm) | pVCpu->iem.s.uRexB, iCrReg);
    17711771}
    17721772
    … …  
    17791779    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    17801780    IEMOP_HLP_NO_LOCK_PREFIX();
    1781     if (pIemCpu->fPrefixes & IEM_OP_PRF_REX_R)
     1781    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REX_R)
    17821782        return IEMOP_RAISE_INVALID_OPCODE();
    17831783    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_mov_Rd_Dd,
    1784                                    (X86_MODRM_RM_MASK & bRm) | pIemCpu->uRexB,
     1784                                   (X86_MODRM_RM_MASK & bRm) | pVCpu->iem.s.uRexB,
    17851785                                   ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK));
    17861786}
    … …  
    17931793    IEMOP_MNEMONIC("mov Cd,Rd");
    17941794    IEMOP_HLP_MIN_386();
    1795     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    1796         pIemCpu->enmEffOpSize = pIemCpu->enmDefOpSize = IEMMODE_64BIT;
     1795    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
     1796        pVCpu->iem.s.enmEffOpSize = pVCpu->iem.s.enmDefOpSize = IEMMODE_64BIT;
    17971797    else
    1798         pIemCpu->enmEffOpSize = pIemCpu->enmDefOpSize = IEMMODE_32BIT;
     1798        pVCpu->iem.s.enmEffOpSize = pVCpu->iem.s.enmDefOpSize = IEMMODE_32BIT;
    17991799
    18001800    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    1801     uint8_t iCrReg = ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg;
    1802     if (pIemCpu->fPrefixes & IEM_OP_PRF_LOCK)
     1801    uint8_t iCrReg = ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg;
     1802    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK)
    18031803    {
    18041804        /* The lock prefix can be used to encode CR8 accesses on some CPUs. */
    1805         if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fMovCr8In32Bit)
     1805        if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fMovCr8In32Bit)
    18061806            return IEMOP_RAISE_INVALID_OPCODE(); /* #UD takes precedence over #GP(), see test. */
    18071807        iCrReg |= 8;
    … …  
    18161816    IEMOP_HLP_DONE_DECODING();
    18171817
    1818     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_mov_Cd_Rd, iCrReg, (X86_MODRM_RM_MASK & bRm) | pIemCpu->uRexB);
     1818    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_mov_Cd_Rd, iCrReg, (X86_MODRM_RM_MASK & bRm) | pVCpu->iem.s.uRexB);
    18191819}
    18201820
    … …  
    18271827    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    18281828    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    1829     if (pIemCpu->fPrefixes & IEM_OP_PRF_REX_R)
     1829    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REX_R)
    18301830        return IEMOP_RAISE_INVALID_OPCODE();
    18311831    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_mov_Dd_Rd,
    18321832                                   ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK),
    1833                                    (X86_MODRM_RM_MASK & bRm) | pIemCpu->uRexB);
     1833                                   (X86_MODRM_RM_MASK & bRm) | pVCpu->iem.s.uRexB);
    18341834}
    18351835
    … …  
    18581858FNIEMOP_DEF(iemOp_movaps_Vps_Wps__movapd_Vpd_Wpd)
    18591859{
    1860     IEMOP_MNEMONIC(!(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP) ? "movaps r,mr" : "movapd r,mr");
     1860    IEMOP_MNEMONIC(!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP) ? "movaps r,mr" : "movapd r,mr");
    18611861    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    18621862    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    18671867        IEMOP_HLP_DONE_DECODING_NO_LOCK_REPZ_OR_REPNZ_PREFIXES();
    18681868        IEM_MC_BEGIN(0, 0);
    1869         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP))
     1869        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP))
    18701870            IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    18711871        else
    18721872            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    18731873        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    1874         IEM_MC_COPY_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg,
    1875                               (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     1874        IEM_MC_COPY_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
     1875                              (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    18761876        IEM_MC_ADVANCE_RIP();
    18771877        IEM_MC_END();
    … …  
    18881888        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    18891889        IEMOP_HLP_DONE_DECODING_NO_LOCK_REPZ_OR_REPNZ_PREFIXES(); /** @todo check if this is delayed this long for REPZ/NZ */
    1890         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP))
     1890        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP))
    18911891            IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    18921892        else
    … …  
    18941894        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    18951895
    1896         IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
    1897         IEM_MC_STORE_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, uSrc);
     1896        IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     1897        IEM_MC_STORE_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
    18981898
    18991899        IEM_MC_ADVANCE_RIP();
    … …  
    19071907FNIEMOP_DEF(iemOp_movaps_Wps_Vps__movapd_Wpd_Vpd)
    19081908{
    1909     IEMOP_MNEMONIC(!(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP) ? "movaps mr,r" : "movapd mr,r");
     1909    IEMOP_MNEMONIC(!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP) ? "movaps mr,r" : "movapd mr,r");
    19101910    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    19111911    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    19161916        IEMOP_HLP_DONE_DECODING_NO_LOCK_REPZ_OR_REPNZ_PREFIXES();
    19171917        IEM_MC_BEGIN(0, 0);
    1918         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP))
     1918        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP))
    19191919            IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    19201920        else
    19211921            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    19221922        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    1923         IEM_MC_COPY_XREG_U128((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB,
    1924                               ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     1923        IEM_MC_COPY_XREG_U128((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
     1924                              ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    19251925        IEM_MC_ADVANCE_RIP();
    19261926        IEM_MC_END();
    … …  
    19371937        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    19381938        IEMOP_HLP_DONE_DECODING_NO_LOCK_REPZ_OR_REPNZ_PREFIXES(); /** @todo check if this is delayed this long for REPZ/NZ */
    1939         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP))
     1939        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP))
    19401940            IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    19411941        else
    … …  
    19431943        IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    19441944
    1945         IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    1946         IEM_MC_STORE_MEM_U128_ALIGN_SSE(pIemCpu->iEffSeg, GCPtrEffSrc, uSrc);
     1945        IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1946        IEM_MC_STORE_MEM_U128_ALIGN_SSE(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
    19471947
    19481948        IEM_MC_ADVANCE_RIP();
    … …  
    19601960FNIEMOP_DEF(iemOp_movntps_Mps_Vps__movntpd_Mpd_Vpd)
    19611961{
    1962     IEMOP_MNEMONIC(!(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP) ? "movntps mr,r" : "movntpd mr,r");
     1962    IEMOP_MNEMONIC(!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP) ? "movntps mr,r" : "movntpd mr,r");
    19631963    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    19641964    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    … …  
    19731973        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    19741974        IEMOP_HLP_DONE_DECODING_NO_LOCK_REPZ_OR_REPNZ_PREFIXES(); /** @todo check if this is delayed this long for REPZ/NZ */
    1975         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP))
     1975        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP))
    19761976            IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    19771977        else
    … …  
    19791979        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    19801980
    1981         IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    1982         IEM_MC_STORE_MEM_U128_ALIGN_SSE(pIemCpu->iEffSeg, GCPtrEffSrc, uSrc);
     1981        IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1982        IEM_MC_STORE_MEM_U128_ALIGN_SSE(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
    19831983
    19841984        IEM_MC_ADVANCE_RIP();
    … …  
    20552055    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) \
    20562056    { \
    2057         switch (pIemCpu->enmEffOpSize) \
     2057        switch (pVCpu->iem.s.enmEffOpSize) \
    20582058        { \
    20592059            case IEMMODE_16BIT: \
    … …  
    20612061                IEM_MC_LOCAL(uint16_t, u16Tmp); \
    20622062                a_Cnd { \
    2063                     IEM_MC_FETCH_GREG_U16(u16Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB); \
    2064                     IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Tmp); \
     2063                    IEM_MC_FETCH_GREG_U16(u16Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB); \
     2064                    IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Tmp); \
    20652065                } IEM_MC_ENDIF(); \
    20662066                IEM_MC_ADVANCE_RIP(); \
    … …  
    20722072                IEM_MC_LOCAL(uint32_t, u32Tmp); \
    20732073                a_Cnd { \
    2074                     IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB); \
    2075                     IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp); \
     2074                    IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB); \
     2075                    IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp); \
    20762076                } IEM_MC_ELSE() { \
    2077                     IEM_MC_CLEAR_HIGH_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg); \
     2077                    IEM_MC_CLEAR_HIGH_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg); \
    20782078                } IEM_MC_ENDIF(); \
    20792079                IEM_MC_ADVANCE_RIP(); \
    … …  
    20852085                IEM_MC_LOCAL(uint64_t, u64Tmp); \
    20862086                a_Cnd { \
    2087                     IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB); \
    2088                     IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp); \
     2087                    IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB); \
     2088                    IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp); \
    20892089                } IEM_MC_ENDIF(); \
    20902090                IEM_MC_ADVANCE_RIP(); \
    … …  
    20972097    else \
    20982098    { \
    2099         switch (pIemCpu->enmEffOpSize) \
     2099        switch (pVCpu->iem.s.enmEffOpSize) \
    21002100        { \
    21012101            case IEMMODE_16BIT: \
    … …  
    21042104                IEM_MC_LOCAL(uint16_t, u16Tmp); \
    21052105                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0); \
    2106                 IEM_MC_FETCH_MEM_U16(u16Tmp, pIemCpu->iEffSeg, GCPtrEffSrc); \
     2106                IEM_MC_FETCH_MEM_U16(u16Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc); \
    21072107                a_Cnd { \
    2108                     IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Tmp); \
     2108                    IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Tmp); \
    21092109                } IEM_MC_ENDIF(); \
    21102110                IEM_MC_ADVANCE_RIP(); \
    … …  
    21172117                IEM_MC_LOCAL(uint32_t, u32Tmp); \
    21182118                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0); \
    2119                 IEM_MC_FETCH_MEM_U32(u32Tmp, pIemCpu->iEffSeg, GCPtrEffSrc); \
     2119                IEM_MC_FETCH_MEM_U32(u32Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc); \
    21202120                a_Cnd { \
    2121                     IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp); \
     2121                    IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp); \
    21222122                } IEM_MC_ELSE() { \
    2123                     IEM_MC_CLEAR_HIGH_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg); \
     2123                    IEM_MC_CLEAR_HIGH_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg); \
    21242124                } IEM_MC_ENDIF(); \
    21252125                IEM_MC_ADVANCE_RIP(); \
    … …  
    21322132                IEM_MC_LOCAL(uint64_t, u64Tmp); \
    21332133                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0); \
    2134                 IEM_MC_FETCH_MEM_U64(u64Tmp, pIemCpu->iEffSeg, GCPtrEffSrc); \
     2134                IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc); \
    21352135                a_Cnd { \
    2136                     IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp); \
     2136                    IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp); \
    21372137                } IEM_MC_ENDIF(); \
    21382138                IEM_MC_ADVANCE_RIP(); \
    … …  
    23232323{
    23242324    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    2325     switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     2325    switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    23262326    {
    23272327        case IEM_OP_PRF_SIZE_OP: /* SSE */
    … …  
    23372337                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    23382338                IEM_MC_PREPARE_SSE_USAGE();
    2339                 IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    2340                 IEM_MC_REF_XREG_U64_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     2339                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     2340                IEM_MC_REF_XREG_U64_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    23412341                IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
    23422342                IEM_MC_ADVANCE_RIP();
    … …  
    23572357                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    23582358                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    2359                 IEM_MC_FETCH_MEM_U64_ALIGN_U128(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     2359                IEM_MC_FETCH_MEM_U64_ALIGN_U128(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    23602360
    23612361                IEM_MC_PREPARE_SSE_USAGE();
    2362                 IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     2362                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    23632363                IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
    23642364
    … …  
    24042404                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    24052405                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    2406                 IEM_MC_FETCH_MEM_U32(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     2406                IEM_MC_FETCH_MEM_U32(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    24072407
    24082408                IEM_MC_PREPARE_FPU_USAGE();
    … …  
    24712471{
    24722472    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    2473     switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     2473    switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    24742474    {
    24752475        case IEM_OP_PRF_SIZE_OP: /* SSE */
    … …  
    24852485                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    24862486                IEM_MC_PREPARE_SSE_USAGE();
    2487                 IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    2488                 IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     2487                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     2488                IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    24892489                IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
    24902490                IEM_MC_ADVANCE_RIP();
    … …  
    25052505                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    25062506                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    2507                 IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc); /* Most CPUs probably only right high qword */
     2507                IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc); /* Most CPUs probably only right high qword */
    25082508
    25092509                IEM_MC_PREPARE_SSE_USAGE();
    2510                 IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     2510                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    25112511                IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
    25122512
    … …  
    25522552                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    25532553                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    2554                 IEM_MC_FETCH_MEM_U64(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     2554                IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    25552555
    25562556                IEM_MC_PREPARE_FPU_USAGE();
    … …  
    26162616{
    26172617    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    2618     switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     2618    switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    26192619    {
    26202620        case IEM_OP_PRF_SIZE_OP: /* SSE */
    … …  
    26272627                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    26282628                IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    2629                 if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     2629                if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    26302630                {
    26312631                    IEM_MC_LOCAL(uint64_t, u64Tmp);
    2632                     IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    2633                     IEM_MC_STORE_XREG_U64_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp);
     2632                    IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     2633                    IEM_MC_STORE_XREG_U64_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp);
    26342634                }
    26352635                else
    26362636                {
    26372637                    IEM_MC_LOCAL(uint32_t, u32Tmp);
    2638                     IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    2639                     IEM_MC_STORE_XREG_U32_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp);
     2638                    IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     2639                    IEM_MC_STORE_XREG_U32_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp);
    26402640                }
    26412641                IEM_MC_ADVANCE_RIP();
    … …  
    26512651                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    26522652                IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    2653                 if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     2653                if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    26542654                {
    26552655                    IEM_MC_LOCAL(uint64_t, u64Tmp);
    2656                     IEM_MC_FETCH_MEM_U64(u64Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
    2657                     IEM_MC_STORE_XREG_U64_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp);
     2656                    IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     2657                    IEM_MC_STORE_XREG_U64_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp);
    26582658                }
    26592659                else
    26602660                {
    26612661                    IEM_MC_LOCAL(uint32_t, u32Tmp);
    2662                     IEM_MC_FETCH_MEM_U32(u32Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
    2663                     IEM_MC_STORE_XREG_U32_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp);
     2662                    IEM_MC_FETCH_MEM_U32(u32Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     2663                    IEM_MC_STORE_XREG_U32_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp);
    26642664                }
    26652665                IEM_MC_ADVANCE_RIP();
    … …  
    26782678                IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    26792679                IEM_MC_LOCAL(uint64_t, u64Tmp);
    2680                 if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    2681                     IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     2680                if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     2681                    IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    26822682                else
    2683                     IEM_MC_FETCH_GREG_U32_ZX_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     2683                    IEM_MC_FETCH_GREG_U32_ZX_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    26842684                IEM_MC_STORE_MREG_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u64Tmp);
    26852685                IEM_MC_ADVANCE_RIP();
    … …  
    26952695                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    26962696                IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    2697                 if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     2697                if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    26982698                {
    26992699                    IEM_MC_LOCAL(uint64_t, u64Tmp);
    2700                     IEM_MC_FETCH_MEM_U64(u64Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
     2700                    IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    27012701                    IEM_MC_STORE_MREG_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u64Tmp);
    27022702                }
    … …  
    27042704                {
    27052705                    IEM_MC_LOCAL(uint32_t, u32Tmp);
    2706                     IEM_MC_FETCH_MEM_U32(u32Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
     2706                    IEM_MC_FETCH_MEM_U32(u32Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    27072707                    IEM_MC_STORE_MREG_U32_ZX_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u32Tmp);
    27082708                }
    … …  
    27232723    bool fAligned = false;
    27242724    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    2725     switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     2725    switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    27262726    {
    27272727        case IEM_OP_PRF_SIZE_OP: /* SSE aligned */
    … …  
    27412741                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    27422742                IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    2743                 IEM_MC_COPY_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg,
    2744                                       (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     2743                IEM_MC_COPY_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
     2744                                      (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    27452745                IEM_MC_ADVANCE_RIP();
    27462746                IEM_MC_END();
    … …  
    27602760                IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    27612761                if (fAligned)
    2762                     IEM_MC_FETCH_MEM_U128_ALIGN_SSE(u128Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
     2762                    IEM_MC_FETCH_MEM_U128_ALIGN_SSE(u128Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    27632763                else
    2764                     IEM_MC_FETCH_MEM_U128(u128Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
    2765                 IEM_MC_STORE_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u128Tmp);
     2764                    IEM_MC_FETCH_MEM_U128(u128Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     2765                IEM_MC_STORE_XREG_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u128Tmp);
    27662766
    27672767                IEM_MC_ADVANCE_RIP();
    … …  
    28022802                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    28032803                IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    2804                 IEM_MC_FETCH_MEM_U64(u64Tmp, pIemCpu->iEffSeg, GCPtrEffSrc);
     2804                IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    28052805                IEM_MC_STORE_MREG_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u64Tmp);
    28062806
    … …  
    28202820{
    28212821    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    2822     switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     2822    switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    28232823    {
    28242824        case IEM_OP_PRF_SIZE_OP: /* SSE */
    … …  
    28272827        {
    28282828            PFNIEMAIMPLMEDIAPSHUF pfnAImpl;
    2829             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     2829            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    28302830            {
    28312831                case IEM_OP_PRF_SIZE_OP:
    … …  
    28572857                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    28582858                IEM_MC_PREPARE_SSE_USAGE();
    2859                 IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    2860                 IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     2859                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     2860                IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    28612861                IEM_MC_CALL_SSE_AIMPL_3(pfnAImpl, pDst, pSrc, bEvilArg);
    28622862                IEM_MC_ADVANCE_RIP();
    … …  
    28802880                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    28812881
    2882                 IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     2882                IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    28832883                IEM_MC_PREPARE_SSE_USAGE();
    2884                 IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     2884                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    28852885                IEM_MC_CALL_SSE_AIMPL_3(pfnAImpl, pDst, pSrc, bEvilArg);
    28862886
    … …  
    29302930                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT_CHECK_SSE_OR_MMXEXT();
    29312931
    2932                 IEM_MC_FETCH_MEM_U64(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     2932                IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    29332933                IEM_MC_PREPARE_FPU_USAGE();
    29342934                IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    … …  
    29762976            return IEMOP_RAISE_INVALID_OPCODE();
    29772977        case 2:
    2978             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     2978            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    29792979            {
    29802980                case 0:                     return FNIEMOP_CALL_1(iemOp_Grp12_psrlw_Nq_Ib, bRm);
    … …  
    29832983            }
    29842984        case 4:
    2985             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     2985            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    29862986            {
    29872987                case 0:                     return FNIEMOP_CALL_1(iemOp_Grp12_psraw_Nq_Ib, bRm);
    … …  
    29902990            }
    29912991        case 6:
    2992             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     2992            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    29932993            {
    29942994                case 0:                     return FNIEMOP_CALL_1(iemOp_Grp12_psllw_Nq_Ib, bRm);
    … …  
    30313031            return IEMOP_RAISE_INVALID_OPCODE();
    30323032        case 2:
    3033             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     3033            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    30343034            {
    30353035                case 0:                     return FNIEMOP_CALL_1(iemOp_Grp13_psrld_Nq_Ib, bRm);
    … …  
    30383038            }
    30393039        case 4:
    3040             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     3040            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    30413041            {
    30423042                case 0:                     return FNIEMOP_CALL_1(iemOp_Grp13_psrad_Nq_Ib, bRm);
    … …  
    30453045            }
    30463046        case 6:
    3047             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     3047            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    30483048            {
    30493049                case 0:                     return FNIEMOP_CALL_1(iemOp_Grp13_pslld_Nq_Ib, bRm);
    … …  
    30863086            return IEMOP_RAISE_INVALID_OPCODE();
    30873087        case 2:
    3088             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     3088            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    30893089            {
    30903090                case 0:                     return FNIEMOP_CALL_1(iemOp_Grp14_psrlq_Nq_Ib, bRm);
    … …  
    30933093            }
    30943094        case 3:
    3095             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     3095            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    30963096            {
    30973097                case IEM_OP_PRF_SIZE_OP:    return FNIEMOP_CALL_1(iemOp_Grp14_psrldq_Udq_Ib, bRm);
    … …  
    30993099            }
    31003100        case 6:
    3101             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     3101            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    31023102            {
    31033103                case 0:                     return FNIEMOP_CALL_1(iemOp_Grp14_psllq_Nq_Ib, bRm);
    … …  
    31063106            }
    31073107        case 7:
    3108             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     3108            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    31093109            {
    31103110                case IEM_OP_PRF_SIZE_OP:    return FNIEMOP_CALL_1(iemOp_Grp14_pslldq_Udq_Ib, bRm);
    … …  
    31273127{
    31283128    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    3129     switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     3129    switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    31303130    {
    31313131        case IEM_OP_PRF_SIZE_OP: /* SSE */
    … …  
    31413141                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    31423142                IEM_MC_PREPARE_SSE_USAGE();
    3143                 IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    3144                 IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     3143                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     3144                IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    31453145                IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
    31463146                IEM_MC_ADVANCE_RIP();
    … …  
    31613161                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    31623162                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    3163                 IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     3163                IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    31643164
    31653165                IEM_MC_PREPARE_SSE_USAGE();
    3166                 IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     3166                IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    31673167                IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
    31683168
    … …  
    32063206                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    32073207                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    3208                 IEM_MC_FETCH_MEM_U64(uSrc, pIemCpu->iEffSeg, GCPtrEffSrc);
     3208                IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    32093209
    32103210                IEM_MC_PREPARE_FPU_USAGE();
    … …  
    32633263{
    32643264    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    3265     switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     3265    switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    32663266    {
    32673267        case IEM_OP_PRF_SIZE_OP: /* SSE */
    … …  
    32743274                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    32753275                IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    3276                 if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     3276                if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    32773277                {
    32783278                    IEM_MC_LOCAL(uint64_t, u64Tmp);
    3279                     IEM_MC_FETCH_XREG_U64(u64Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    3280                     IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u64Tmp);
     3279                    IEM_MC_FETCH_XREG_U64(u64Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     3280                    IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u64Tmp);
    32813281                }
    32823282                else
    32833283                {
    32843284                    IEM_MC_LOCAL(uint32_t, u32Tmp);
    3285                     IEM_MC_FETCH_XREG_U32(u32Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    3286                     IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u32Tmp);
     3285                    IEM_MC_FETCH_XREG_U32(u32Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     3286                    IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u32Tmp);
    32873287                }
    32883288                IEM_MC_ADVANCE_RIP();
    … …  
    32983298                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    32993299                IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    3300                 if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     3300                if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    33013301                {
    33023302                    IEM_MC_LOCAL(uint64_t, u64Tmp);
    3303                     IEM_MC_FETCH_XREG_U64(u64Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    3304                     IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffSrc, u64Tmp);
     3303                    IEM_MC_FETCH_XREG_U64(u64Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     3304                    IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u64Tmp);
    33053305                }
    33063306                else
    33073307                {
    33083308                    IEM_MC_LOCAL(uint32_t, u32Tmp);
    3309                     IEM_MC_FETCH_XREG_U32(u32Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    3310                     IEM_MC_STORE_MEM_U32(pIemCpu->iEffSeg, GCPtrEffSrc, u32Tmp);
     3309                    IEM_MC_FETCH_XREG_U32(u32Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     3310                    IEM_MC_STORE_MEM_U32(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u32Tmp);
    33113311                }
    33123312                IEM_MC_ADVANCE_RIP();
    … …  
    33243324                IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    33253325                IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    3326                 if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     3326                if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    33273327                {
    33283328                    IEM_MC_LOCAL(uint64_t, u64Tmp);
    33293329                    IEM_MC_FETCH_MREG_U64(u64Tmp, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    3330                     IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u64Tmp);
     3330                    IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u64Tmp);
    33313331                }
    33323332                else
    … …  
    33343334                    IEM_MC_LOCAL(uint32_t, u32Tmp);
    33353335                    IEM_MC_FETCH_MREG_U32(u32Tmp, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    3336                     IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u32Tmp);
     3336                    IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u32Tmp);
    33373337                }
    33383338                IEM_MC_ADVANCE_RIP();
    … …  
    33483348                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    33493349                IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    3350                 if (pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     3350                if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    33513351                {
    33523352                    IEM_MC_LOCAL(uint64_t, u64Tmp);
    33533353                    IEM_MC_FETCH_MREG_U64(u64Tmp, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    3354                     IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffSrc, u64Tmp);
     3354                    IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u64Tmp);
    33553355                }
    33563356                else
    … …  
    33583358                    IEM_MC_LOCAL(uint32_t, u32Tmp);
    33593359                    IEM_MC_FETCH_MREG_U32(u32Tmp, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    3360                     IEM_MC_STORE_MEM_U32(pIemCpu->iEffSeg, GCPtrEffSrc, u32Tmp);
     3360                    IEM_MC_STORE_MEM_U32(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u32Tmp);
    33613361                }
    33623362                IEM_MC_ADVANCE_RIP();
    … …  
    33763376    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    33773377    bool fAligned = false;
    3378     switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     3378    switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    33793379    {
    33803380        case IEM_OP_PRF_SIZE_OP: /* SSE aligned */
    … …  
    33943394                IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    33953395                IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    3396                 IEM_MC_COPY_XREG_U128((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB,
    3397                                       ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     3396                IEM_MC_COPY_XREG_U128((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
     3397                                      ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    33983398                IEM_MC_ADVANCE_RIP();
    33993399                IEM_MC_END();
    … …  
    34133413                IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    34143414
    3415                 IEM_MC_FETCH_XREG_U128(u128Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     3415                IEM_MC_FETCH_XREG_U128(u128Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    34163416                if (fAligned)
    3417                     IEM_MC_STORE_MEM_U128_ALIGN_SSE(pIemCpu->iEffSeg, GCPtrEffSrc, u128Tmp);
     3417                    IEM_MC_STORE_MEM_U128_ALIGN_SSE(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u128Tmp);
    34183418                else
    3419                     IEM_MC_STORE_MEM_U128(pIemCpu->iEffSeg, GCPtrEffSrc, u128Tmp);
     3419                    IEM_MC_STORE_MEM_U128(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u128Tmp);
    34203420
    34213421                IEM_MC_ADVANCE_RIP();
    … …  
    34593459
    34603460                IEM_MC_FETCH_MREG_U64(u64Tmp, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    3461                 IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffSrc, u64Tmp);
     3461                IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u64Tmp);
    34623462
    34633463                IEM_MC_ADVANCE_RIP();
    … …  
    34793479    IEMOP_HLP_MIN_386();
    34803480    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3481     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3481    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    34823482    {
    34833483        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    35153515    IEMOP_HLP_MIN_386();
    35163516    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3517     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3517    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    35183518    {
    35193519        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    35513551    IEMOP_HLP_MIN_386();
    35523552    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3553     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3553    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    35543554    {
    35553555        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    35873587    IEMOP_HLP_MIN_386();
    35883588    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3589     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3589    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    35903590    {
    35913591        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    36233623    IEMOP_HLP_MIN_386();
    36243624    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3625     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3625    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    36263626    {
    36273627        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    36593659    IEMOP_HLP_MIN_386();
    36603660    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3661     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3661    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    36623662    {
    36633663        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    36953695    IEMOP_HLP_MIN_386();
    36963696    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3697     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3697    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    36983698    {
    36993699        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    37313731    IEMOP_HLP_MIN_386();
    37323732    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3733     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3733    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    37343734    {
    37353735        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    37673767    IEMOP_HLP_MIN_386();
    37683768    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3769     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3769    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    37703770    {
    37713771        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    38033803    IEMOP_HLP_MIN_386();
    38043804    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3805     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3805    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    38063806    {
    38073807        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    38393839    IEMOP_HLP_MIN_386();
    38403840    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3841     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3841    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    38423842    {
    38433843        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    38753875    IEMOP_HLP_MIN_386();
    38763876    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3877     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3877    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    38783878    {
    38793879        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    39113911    IEMOP_HLP_MIN_386();
    39123912    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3913     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3913    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    39143914    {
    39153915        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    39473947    IEMOP_HLP_MIN_386();
    39483948    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3949     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3949    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    39503950    {
    39513951        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    39833983    IEMOP_HLP_MIN_386();
    39843984    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    3985     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     3985    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    39863986    {
    39873987        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    40194019    IEMOP_HLP_MIN_386();
    40204020    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    4021     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     4021    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    40224022    {
    40234023        int16_t i16Imm; IEM_OPCODE_GET_NEXT_S16(&i16Imm);
    … …  
    40654065        IEM_MC_BEGIN(0, 0);
    40664066        IEM_MC_IF_EFL_BIT_SET(X86_EFL_OF) {
    4067             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4067            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    40684068        } IEM_MC_ELSE() {
    4069             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4069            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    40704070        } IEM_MC_ENDIF();
    40714071        IEM_MC_ADVANCE_RIP();
    … …  
    40794079        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    40804080        IEM_MC_IF_EFL_BIT_SET(X86_EFL_OF) {
    4081             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4081            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    40824082        } IEM_MC_ELSE() {
    4083             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4083            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    40844084        } IEM_MC_ENDIF();
    40854085        IEM_MC_ADVANCE_RIP();
    … …  
    41064106        IEM_MC_BEGIN(0, 0);
    41074107        IEM_MC_IF_EFL_BIT_SET(X86_EFL_OF) {
    4108             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4108            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    41094109        } IEM_MC_ELSE() {
    4110             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4110            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    41114111        } IEM_MC_ENDIF();
    41124112        IEM_MC_ADVANCE_RIP();
    … …  
    41204120        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    41214121        IEM_MC_IF_EFL_BIT_SET(X86_EFL_OF) {
    4122             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4122            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    41234123        } IEM_MC_ELSE() {
    4124             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4124            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    41254125        } IEM_MC_ENDIF();
    41264126        IEM_MC_ADVANCE_RIP();
    … …  
    41474147        IEM_MC_BEGIN(0, 0);
    41484148        IEM_MC_IF_EFL_BIT_SET(X86_EFL_CF) {
    4149             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4149            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    41504150        } IEM_MC_ELSE() {
    4151             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4151            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    41524152        } IEM_MC_ENDIF();
    41534153        IEM_MC_ADVANCE_RIP();
    … …  
    41614161        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    41624162        IEM_MC_IF_EFL_BIT_SET(X86_EFL_CF) {
    4163             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4163            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    41644164        } IEM_MC_ELSE() {
    4165             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4165            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    41664166        } IEM_MC_ENDIF();
    41674167        IEM_MC_ADVANCE_RIP();
    … …  
    41884188        IEM_MC_BEGIN(0, 0);
    41894189        IEM_MC_IF_EFL_BIT_SET(X86_EFL_CF) {
    4190             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4190            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    41914191        } IEM_MC_ELSE() {
    4192             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4192            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    41934193        } IEM_MC_ENDIF();
    41944194        IEM_MC_ADVANCE_RIP();
    … …  
    42024202        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    42034203        IEM_MC_IF_EFL_BIT_SET(X86_EFL_CF) {
    4204             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4204            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    42054205        } IEM_MC_ELSE() {
    4206             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4206            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    42074207        } IEM_MC_ENDIF();
    42084208        IEM_MC_ADVANCE_RIP();
    … …  
    42294229        IEM_MC_BEGIN(0, 0);
    42304230        IEM_MC_IF_EFL_BIT_SET(X86_EFL_ZF) {
    4231             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4231            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    42324232        } IEM_MC_ELSE() {
    4233             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4233            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    42344234        } IEM_MC_ENDIF();
    42354235        IEM_MC_ADVANCE_RIP();
    … …  
    42434243        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    42444244        IEM_MC_IF_EFL_BIT_SET(X86_EFL_ZF) {
    4245             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4245            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    42464246        } IEM_MC_ELSE() {
    4247             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4247            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    42484248        } IEM_MC_ENDIF();
    42494249        IEM_MC_ADVANCE_RIP();
    … …  
    42704270        IEM_MC_BEGIN(0, 0);
    42714271        IEM_MC_IF_EFL_BIT_SET(X86_EFL_ZF) {
    4272             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4272            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    42734273        } IEM_MC_ELSE() {
    4274             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4274            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    42754275        } IEM_MC_ENDIF();
    42764276        IEM_MC_ADVANCE_RIP();
    … …  
    42844284        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    42854285        IEM_MC_IF_EFL_BIT_SET(X86_EFL_ZF) {
    4286             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4286            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    42874287        } IEM_MC_ELSE() {
    4288             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4288            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    42894289        } IEM_MC_ENDIF();
    42904290        IEM_MC_ADVANCE_RIP();
    … …  
    43114311        IEM_MC_BEGIN(0, 0);
    43124312        IEM_MC_IF_EFL_ANY_BITS_SET(X86_EFL_CF | X86_EFL_ZF) {
    4313             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4313            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    43144314        } IEM_MC_ELSE() {
    4315             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4315            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    43164316        } IEM_MC_ENDIF();
    43174317        IEM_MC_ADVANCE_RIP();
    … …  
    43254325        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    43264326        IEM_MC_IF_EFL_ANY_BITS_SET(X86_EFL_CF | X86_EFL_ZF) {
    4327             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4327            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    43284328        } IEM_MC_ELSE() {
    4329             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4329            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    43304330        } IEM_MC_ENDIF();
    43314331        IEM_MC_ADVANCE_RIP();
    … …  
    43524352        IEM_MC_BEGIN(0, 0);
    43534353        IEM_MC_IF_EFL_ANY_BITS_SET(X86_EFL_CF | X86_EFL_ZF) {
    4354             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4354            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    43554355        } IEM_MC_ELSE() {
    4356             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4356            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    43574357        } IEM_MC_ENDIF();
    43584358        IEM_MC_ADVANCE_RIP();
    … …  
    43664366        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    43674367        IEM_MC_IF_EFL_ANY_BITS_SET(X86_EFL_CF | X86_EFL_ZF) {
    4368             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4368            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    43694369        } IEM_MC_ELSE() {
    4370             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4370            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    43714371        } IEM_MC_ENDIF();
    43724372        IEM_MC_ADVANCE_RIP();
    … …  
    43934393        IEM_MC_BEGIN(0, 0);
    43944394        IEM_MC_IF_EFL_BIT_SET(X86_EFL_SF) {
    4395             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4395            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    43964396        } IEM_MC_ELSE() {
    4397             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4397            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    43984398        } IEM_MC_ENDIF();
    43994399        IEM_MC_ADVANCE_RIP();
    … …  
    44074407        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    44084408        IEM_MC_IF_EFL_BIT_SET(X86_EFL_SF) {
    4409             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4409            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    44104410        } IEM_MC_ELSE() {
    4411             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4411            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    44124412        } IEM_MC_ENDIF();
    44134413        IEM_MC_ADVANCE_RIP();
    … …  
    44344434        IEM_MC_BEGIN(0, 0);
    44354435        IEM_MC_IF_EFL_BIT_SET(X86_EFL_SF) {
    4436             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4436            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    44374437        } IEM_MC_ELSE() {
    4438             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4438            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    44394439        } IEM_MC_ENDIF();
    44404440        IEM_MC_ADVANCE_RIP();
    … …  
    44484448        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    44494449        IEM_MC_IF_EFL_BIT_SET(X86_EFL_SF) {
    4450             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4450            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    44514451        } IEM_MC_ELSE() {
    4452             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4452            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    44534453        } IEM_MC_ENDIF();
    44544454        IEM_MC_ADVANCE_RIP();
    … …  
    44754475        IEM_MC_BEGIN(0, 0);
    44764476        IEM_MC_IF_EFL_BIT_SET(X86_EFL_PF) {
    4477             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4477            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    44784478        } IEM_MC_ELSE() {
    4479             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4479            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    44804480        } IEM_MC_ENDIF();
    44814481        IEM_MC_ADVANCE_RIP();
    … …  
    44894489        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    44904490        IEM_MC_IF_EFL_BIT_SET(X86_EFL_PF) {
    4491             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4491            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    44924492        } IEM_MC_ELSE() {
    4493             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4493            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    44944494        } IEM_MC_ENDIF();
    44954495        IEM_MC_ADVANCE_RIP();
    … …  
    45164516        IEM_MC_BEGIN(0, 0);
    45174517        IEM_MC_IF_EFL_BIT_SET(X86_EFL_PF) {
    4518             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4518            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    45194519        } IEM_MC_ELSE() {
    4520             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4520            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    45214521        } IEM_MC_ENDIF();
    45224522        IEM_MC_ADVANCE_RIP();
    … …  
    45304530        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    45314531        IEM_MC_IF_EFL_BIT_SET(X86_EFL_PF) {
    4532             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4532            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    45334533        } IEM_MC_ELSE() {
    4534             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4534            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    45354535        } IEM_MC_ENDIF();
    45364536        IEM_MC_ADVANCE_RIP();
    … …  
    45574557        IEM_MC_BEGIN(0, 0);
    45584558        IEM_MC_IF_EFL_BITS_NE(X86_EFL_SF, X86_EFL_OF) {
    4559             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4559            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    45604560        } IEM_MC_ELSE() {
    4561             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4561            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    45624562        } IEM_MC_ENDIF();
    45634563        IEM_MC_ADVANCE_RIP();
    … …  
    45714571        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    45724572        IEM_MC_IF_EFL_BITS_NE(X86_EFL_SF, X86_EFL_OF) {
    4573             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4573            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    45744574        } IEM_MC_ELSE() {
    4575             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4575            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    45764576        } IEM_MC_ENDIF();
    45774577        IEM_MC_ADVANCE_RIP();
    … …  
    45984598        IEM_MC_BEGIN(0, 0);
    45994599        IEM_MC_IF_EFL_BITS_NE(X86_EFL_SF, X86_EFL_OF) {
    4600             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4600            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    46014601        } IEM_MC_ELSE() {
    4602             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4602            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    46034603        } IEM_MC_ENDIF();
    46044604        IEM_MC_ADVANCE_RIP();
    … …  
    46124612        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    46134613        IEM_MC_IF_EFL_BITS_NE(X86_EFL_SF, X86_EFL_OF) {
    4614             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4614            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    46154615        } IEM_MC_ELSE() {
    4616             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4616            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    46174617        } IEM_MC_ENDIF();
    46184618        IEM_MC_ADVANCE_RIP();
    … …  
    46394639        IEM_MC_BEGIN(0, 0);
    46404640        IEM_MC_IF_EFL_BIT_SET_OR_BITS_NE(X86_EFL_ZF, X86_EFL_SF, X86_EFL_OF) {
    4641             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4641            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    46424642        } IEM_MC_ELSE() {
    4643             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4643            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    46444644        } IEM_MC_ENDIF();
    46454645        IEM_MC_ADVANCE_RIP();
    … …  
    46534653        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    46544654        IEM_MC_IF_EFL_BIT_SET_OR_BITS_NE(X86_EFL_ZF, X86_EFL_SF, X86_EFL_OF) {
    4655             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4655            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    46564656        } IEM_MC_ELSE() {
    4657             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4657            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    46584658        } IEM_MC_ENDIF();
    46594659        IEM_MC_ADVANCE_RIP();
    … …  
    46804680        IEM_MC_BEGIN(0, 0);
    46814681        IEM_MC_IF_EFL_BIT_SET_OR_BITS_NE(X86_EFL_ZF, X86_EFL_SF, X86_EFL_OF) {
    4682             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 0);
     4682            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 0);
    46834683        } IEM_MC_ELSE() {
    4684             IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, 1);
     4684            IEM_MC_STORE_GREG_U8_CONST((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 1);
    46854685        } IEM_MC_ENDIF();
    46864686        IEM_MC_ADVANCE_RIP();
    … …  
    46944694        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    46954695        IEM_MC_IF_EFL_BIT_SET_OR_BITS_NE(X86_EFL_ZF, X86_EFL_SF, X86_EFL_OF) {
    4696             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 0);
     4696            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    46974697        } IEM_MC_ELSE() {
    4698             IEM_MC_STORE_MEM_U8_CONST(pIemCpu->iEffSeg, GCPtrEffDst, 1);
     4698            IEM_MC_STORE_MEM_U8_CONST(pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1);
    46994699        } IEM_MC_ENDIF();
    47004700        IEM_MC_ADVANCE_RIP();
    … …  
    47154715    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    47164716
    4717     switch (pIemCpu->enmEffOpSize)
     4717    switch (pVCpu->iem.s.enmEffOpSize)
    47184718    {
    47194719        case IEMMODE_16BIT:
    … …  
    47654765    IEMOP_HLP_MIN_386();
    47664766    IEMOP_HLP_NO_LOCK_PREFIX();
    4767     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_pop_Sreg, X86_SREG_FS, pIemCpu->enmEffOpSize);
     4767    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_pop_Sreg, X86_SREG_FS, pVCpu->iem.s.enmEffOpSize);
    47684768}
    47694769
    … …  
    47924792        /* register destination. */
    47934793        IEMOP_HLP_NO_LOCK_PREFIX();
    4794         switch (pIemCpu->enmEffOpSize)
     4794        switch (pVCpu->iem.s.enmEffOpSize)
    47954795        {
    47964796            case IEMMODE_16BIT:
    … …  
    48004800                IEM_MC_ARG(uint32_t *,      pEFlags,                2);
    48014801
    4802                 IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     4802                IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    48034803                IEM_MC_AND_LOCAL_U16(u16Src, 0xf);
    4804                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     4804                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    48054805                IEM_MC_REF_EFLAGS(pEFlags);
    48064806                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    … …  
    48164816                IEM_MC_ARG(uint32_t *,      pEFlags,                2);
    48174817
    4818                 IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     4818                IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    48194819                IEM_MC_AND_LOCAL_U32(u32Src, 0x1f);
    4820                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     4820                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    48214821                IEM_MC_REF_EFLAGS(pEFlags);
    48224822                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    … …  
    48334833                IEM_MC_ARG(uint32_t *,      pEFlags,                2);
    48344834
    4835                 IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     4835                IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    48364836                IEM_MC_AND_LOCAL_U64(u64Src, 0x3f);
    4837                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     4837                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    48384838                IEM_MC_REF_EFLAGS(pEFlags);
    48394839                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    … …  
    48624862
    48634863        /** @todo test negative bit offsets! */
    4864         switch (pIemCpu->enmEffOpSize)
     4864        switch (pVCpu->iem.s.enmEffOpSize)
    48654865        {
    48664866            case IEMMODE_16BIT:
    … …  
    48734873
    48744874                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    4875                 IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     4875                IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    48764876                IEM_MC_ASSIGN(i16AddrAdj, u16Src);
    48774877                IEM_MC_AND_ARG_U16(u16Src, 0x0f);
    … …  
    48814881                IEM_MC_FETCH_EFLAGS(EFlags);
    48824882
    4883                 IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
    4884                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     4883                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
     4884                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    48854885                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    48864886                else
    … …  
    49024902
    49034903                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    4904                 IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     4904                IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    49054905                IEM_MC_ASSIGN(i32AddrAdj, u32Src);
    49064906                IEM_MC_AND_ARG_U32(u32Src, 0x1f);
    … …  
    49104910                IEM_MC_FETCH_EFLAGS(EFlags);
    49114911
    4912                 IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
    4913                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     4912                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
     4913                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    49144914                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    49154915                else
    … …  
    49314931
    49324932                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    4933                 IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     4933                IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    49344934                IEM_MC_ASSIGN(i64AddrAdj, u64Src);
    49354935                IEM_MC_AND_ARG_U64(u64Src, 0x3f);
    … …  
    49394939                IEM_MC_FETCH_EFLAGS(EFlags);
    49404940
    4941                 IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
    4942                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     4941                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
     4942                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    49434943                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    49444944                else
    … …  
    49804980        IEMOP_HLP_NO_LOCK_PREFIX();
    49814981
    4982         switch (pIemCpu->enmEffOpSize)
     4982        switch (pVCpu->iem.s.enmEffOpSize)
    49834983        {
    49844984            case IEMMODE_16BIT:
    … …  
    49894989                IEM_MC_ARG(uint32_t *,      pEFlags,                3);
    49904990
    4991                 IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    4992                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     4991                IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     4992                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    49934993                IEM_MC_REF_EFLAGS(pEFlags);
    49944994                IEM_MC_CALL_VOID_AIMPL_4(pImpl->pfnNormalU16, pu16Dst, u16Src, cShiftArg, pEFlags);
    … …  
    50055005                IEM_MC_ARG(uint32_t *,      pEFlags,                3);
    50065006
    5007                 IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5008                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     5007                IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5008                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    50095009                IEM_MC_REF_EFLAGS(pEFlags);
    50105010                IEM_MC_CALL_VOID_AIMPL_4(pImpl->pfnNormalU32, pu32Dst, u32Src, cShiftArg, pEFlags);
    … …  
    50225022                IEM_MC_ARG(uint32_t *,      pEFlags,                3);
    50235023
    5024                 IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5025                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     5024                IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5025                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    50265026                IEM_MC_REF_EFLAGS(pEFlags);
    50275027                IEM_MC_CALL_VOID_AIMPL_4(pImpl->pfnNormalU64, pu64Dst, u64Src, cShiftArg, pEFlags);
    … …  
    50385038        IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */
    50395039
    5040         switch (pIemCpu->enmEffOpSize)
     5040        switch (pVCpu->iem.s.enmEffOpSize)
    50415041        {
    50425042            case IEMMODE_16BIT:
    … …  
    50515051                uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift);
    50525052                IEM_MC_ASSIGN(cShiftArg, cShift);
    5053                 IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     5053                IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    50545054                IEM_MC_FETCH_EFLAGS(EFlags);
    5055                 IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
     5055                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    50565056                IEM_MC_CALL_VOID_AIMPL_4(pImpl->pfnNormalU16, pu16Dst, u16Src, cShiftArg, pEFlags);
    50575057
    … …  
    50735073                uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift);
    50745074                IEM_MC_ASSIGN(cShiftArg, cShift);
    5075                 IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     5075                IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    50765076                IEM_MC_FETCH_EFLAGS(EFlags);
    5077                 IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
     5077                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    50785078                IEM_MC_CALL_VOID_AIMPL_4(pImpl->pfnNormalU32, pu32Dst, u32Src, cShiftArg, pEFlags);
    50795079
    … …  
    50955095                uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift);
    50965096                IEM_MC_ASSIGN(cShiftArg, cShift);
    5097                 IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     5097                IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    50985098                IEM_MC_FETCH_EFLAGS(EFlags);
    5099                 IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
     5099                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    51005100                IEM_MC_CALL_VOID_AIMPL_4(pImpl->pfnNormalU64, pu64Dst, u64Src, cShiftArg, pEFlags);
    51015101
    … …  
    51255125        IEMOP_HLP_NO_LOCK_PREFIX();
    51265126
    5127         switch (pIemCpu->enmEffOpSize)
     5127        switch (pVCpu->iem.s.enmEffOpSize)
    51285128        {
    51295129            case IEMMODE_16BIT:
    … …  
    51345134                IEM_MC_ARG(uint32_t *,      pEFlags,                3);
    51355135
    5136                 IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5137                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     5136                IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5137                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    51385138                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    51395139                IEM_MC_REF_EFLAGS(pEFlags);
    … …  
    51515151                IEM_MC_ARG(uint32_t *,      pEFlags,                3);
    51525152
    5153                 IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5154                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     5153                IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5154                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    51555155                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    51565156                IEM_MC_REF_EFLAGS(pEFlags);
    … …  
    51695169                IEM_MC_ARG(uint32_t *,      pEFlags,                3);
    51705170
    5171                 IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5172                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     5171                IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5172                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    51735173                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    51745174                IEM_MC_REF_EFLAGS(pEFlags);
    … …  
    51865186        IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo too early? */
    51875187
    5188         switch (pIemCpu->enmEffOpSize)
     5188        switch (pVCpu->iem.s.enmEffOpSize)
    51895189        {
    51905190            case IEMMODE_16BIT:
    … …  
    51975197
    51985198                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    5199                 IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     5199                IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    52005200                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    52015201                IEM_MC_FETCH_EFLAGS(EFlags);
    5202                 IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
     5202                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    52035203                IEM_MC_CALL_VOID_AIMPL_4(pImpl->pfnNormalU16, pu16Dst, u16Src, cShiftArg, pEFlags);
    52045204
    … …  
    52185218
    52195219                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    5220                 IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     5220                IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    52215221                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    52225222                IEM_MC_FETCH_EFLAGS(EFlags);
    5223                 IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
     5223                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    52245224                IEM_MC_CALL_VOID_AIMPL_4(pImpl->pfnNormalU32, pu32Dst, u32Src, cShiftArg, pEFlags);
    52255225
    … …  
    52395239
    52405240                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    5241                 IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     5241                IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    52425242                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    52435243                IEM_MC_FETCH_EFLAGS(EFlags);
    5244                 IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
     5244                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    52455245                IEM_MC_CALL_VOID_AIMPL_4(pImpl->pfnNormalU64, pu64Dst, u64Src, cShiftArg, pEFlags);
    52465246
    … …  
    52925292    IEMOP_HLP_MIN_386();
    52935293    IEMOP_HLP_NO_LOCK_PREFIX();
    5294     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_pop_Sreg, X86_SREG_GS, pIemCpu->enmEffOpSize);
     5294    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_pop_Sreg, X86_SREG_GS, pVCpu->iem.s.enmEffOpSize);
    52955295}
    52965296
    … …  
    53325332{
    53335333    IEMOP_MNEMONIC("fxsave m512");
    5334     if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fFxSaveRstor)
     5334    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fFxSaveRstor)
    53355335        return IEMOP_RAISE_INVALID_OPCODE();
    53365336
    … …  
    53385338    IEM_MC_ARG(uint8_t,         iEffSeg,                                 0);
    53395339    IEM_MC_ARG(RTGCPTR,         GCPtrEff,                                1);
    5340     IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSize,/*=*/pIemCpu->enmEffOpSize, 2);
     5340    IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSize,/*=*/pVCpu->iem.s.enmEffOpSize, 2);
    53415341    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEff, bRm, 0);
    53425342    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    5343     IEM_MC_ASSIGN(iEffSeg, pIemCpu->iEffSeg);
     5343    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
    53445344    IEM_MC_CALL_CIMPL_3(iemCImpl_fxsave, iEffSeg, GCPtrEff, enmEffOpSize);
    53455345    IEM_MC_END();
    … …  
    53525352{
    53535353    IEMOP_MNEMONIC("fxrstor m512");
    5354     if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fFxSaveRstor)
     5354    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fFxSaveRstor)
    53555355        return IEMOP_RAISE_INVALID_OPCODE();
    53565356
    … …  
    53585358    IEM_MC_ARG(uint8_t,         iEffSeg,                                 0);
    53595359    IEM_MC_ARG(RTGCPTR,         GCPtrEff,                                1);
    5360     IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSize,/*=*/pIemCpu->enmEffOpSize, 2);
     5360    IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSize,/*=*/pVCpu->iem.s.enmEffOpSize, 2);
    53615361    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEff, bRm, 0);
    53625362    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    5363     IEM_MC_ASSIGN(iEffSeg, pIemCpu->iEffSeg);
     5363    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
    53645364    IEM_MC_CALL_CIMPL_3(iemCImpl_fxrstor, iEffSeg, GCPtrEff, enmEffOpSize);
    53655365    IEM_MC_END();
    … …  
    53925392    IEMOP_MNEMONIC("lfence");
    53935393    IEMOP_HLP_NO_LOCK_PREFIX();
    5394     if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fSse2)
     5394    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSse2)
    53955395        return IEMOP_RAISE_INVALID_OPCODE();
    53965396
    53975397    IEM_MC_BEGIN(0, 0);
    5398     if (IEM_GET_HOST_CPU_FEATURES(pIemCpu)->fSse2)
     5398    if (IEM_GET_HOST_CPU_FEATURES(pVCpu)->fSse2)
    53995399        IEM_MC_CALL_VOID_AIMPL_0(iemAImpl_lfence);
    54005400    else
    … …  
    54115411    IEMOP_MNEMONIC("mfence");
    54125412    IEMOP_HLP_NO_LOCK_PREFIX();
    5413     if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fSse2)
     5413    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSse2)
    54145414        return IEMOP_RAISE_INVALID_OPCODE();
    54155415
    54165416    IEM_MC_BEGIN(0, 0);
    5417     if (IEM_GET_HOST_CPU_FEATURES(pIemCpu)->fSse2)
     5417    if (IEM_GET_HOST_CPU_FEATURES(pVCpu)->fSse2)
    54185418        IEM_MC_CALL_VOID_AIMPL_0(iemAImpl_mfence);
    54195419    else
    … …  
    54305430    IEMOP_MNEMONIC("sfence");
    54315431    IEMOP_HLP_NO_LOCK_PREFIX();
    5432     if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fSse2)
     5432    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSse2)
    54335433        return IEMOP_RAISE_INVALID_OPCODE();
    54345434
    54355435    IEM_MC_BEGIN(0, 0);
    5436     if (IEM_GET_HOST_CPU_FEATURES(pIemCpu)->fSse2)
     5436    if (IEM_GET_HOST_CPU_FEATURES(pVCpu)->fSse2)
    54375437        IEM_MC_CALL_VOID_AIMPL_0(iemAImpl_sfence);
    54385438    else
    … …  
    54795479    else
    54805480    {
    5481         switch (pIemCpu->fPrefixes & (IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ | IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_LOCK))
     5481        switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ | IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_LOCK))
    54825482        {
    54835483            case 0:
    … …  
    55445544        IEM_MC_ARG(uint32_t *,      pEFlags,                3);
    55455545
    5546         IEM_MC_FETCH_GREG_U8(u8Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5547         IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     5546        IEM_MC_FETCH_GREG_U8(u8Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5547        IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    55485548        IEM_MC_REF_GREG_U8(pu8Al, X86_GREG_xAX);
    55495549        IEM_MC_REF_EFLAGS(pEFlags);
    5550         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     5550        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    55515551            IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u8, pu8Dst, pu8Al, u8Src, pEFlags);
    55525552        else
    … …  
    55685568        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    55695569        IEMOP_HLP_DONE_DECODING();
    5570         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
    5571         IEM_MC_FETCH_GREG_U8(u8Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     5570        IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
     5571        IEM_MC_FETCH_GREG_U8(u8Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    55725572        IEM_MC_FETCH_GREG_U8(u8Al, X86_GREG_xAX);
    55735573        IEM_MC_FETCH_EFLAGS(EFlags);
    55745574        IEM_MC_REF_LOCAL(pu8Al, u8Al);
    5575         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     5575        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    55765576            IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u8, pu8Dst, pu8Al, u8Src, pEFlags);
    55775577        else
    … …  
    55975597    {
    55985598        IEMOP_HLP_DONE_DECODING();
    5599         switch (pIemCpu->enmEffOpSize)
     5599        switch (pVCpu->iem.s.enmEffOpSize)
    56005600        {
    56015601            case IEMMODE_16BIT:
    … …  
    56065606                IEM_MC_ARG(uint32_t *,      pEFlags,                3);
    56075607
    5608                 IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5609                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     5608                IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5609                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    56105610                IEM_MC_REF_GREG_U16(pu16Ax, X86_GREG_xAX);
    56115611                IEM_MC_REF_EFLAGS(pEFlags);
    5612                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     5612                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    56135613                    IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u16, pu16Dst, pu16Ax, u16Src, pEFlags);
    56145614                else
    … …  
    56265626                IEM_MC_ARG(uint32_t *,      pEFlags,                3);
    56275627
    5628                 IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5629                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     5628                IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5629                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    56305630                IEM_MC_REF_GREG_U32(pu32Eax, X86_GREG_xAX);
    56315631                IEM_MC_REF_EFLAGS(pEFlags);
    5632                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     5632                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    56335633                    IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u32, pu32Dst, pu32Eax, u32Src, pEFlags);
    56345634                else
    … …  
    56525652                IEM_MC_ARG(uint32_t *,      pEFlags,                3);
    56535653
    5654                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     5654                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    56555655                IEM_MC_REF_GREG_U64(pu64Rax, X86_GREG_xAX);
    56565656                IEM_MC_REF_EFLAGS(pEFlags);
    56575657#ifdef RT_ARCH_X86
    5658                 IEM_MC_REF_GREG_U64(pu64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5659                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     5658                IEM_MC_REF_GREG_U64(pu64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5659                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    56605660                    IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u64, pu64Dst, pu64Rax, pu64Src, pEFlags);
    56615661                else
    56625662                    IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u64_locked, pu64Dst, pu64Rax, pu64Src, pEFlags);
    56635663#else
    5664                 IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5665                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     5664                IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5665                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    56665666                    IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u64, pu64Dst, pu64Rax, u64Src, pEFlags);
    56675667                else
    … …  
    56785678    else
    56795679    {
    5680         switch (pIemCpu->enmEffOpSize)
     5680        switch (pVCpu->iem.s.enmEffOpSize)
    56815681        {
    56825682            case IEMMODE_16BIT:
    … …  
    56915691                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    56925692                IEMOP_HLP_DONE_DECODING();
    5693                 IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
    5694                 IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     5693                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
     5694                IEM_MC_FETCH_GREG_U16(u16Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    56955695                IEM_MC_FETCH_GREG_U16(u16Ax, X86_GREG_xAX);
    56965696                IEM_MC_FETCH_EFLAGS(EFlags);
    56975697                IEM_MC_REF_LOCAL(pu16Ax, u16Ax);
    5698                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     5698                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    56995699                    IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u16, pu16Dst, pu16Ax, u16Src, pEFlags);
    57005700                else
    … …  
    57195719                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    57205720                IEMOP_HLP_DONE_DECODING();
    5721                 IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
    5722                 IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     5721                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
     5722                IEM_MC_FETCH_GREG_U32(u32Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    57235723                IEM_MC_FETCH_GREG_U32(u32Eax, X86_GREG_xAX);
    57245724                IEM_MC_FETCH_EFLAGS(EFlags);
    57255725                IEM_MC_REF_LOCAL(pu32Eax, u32Eax);
    5726                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     5726                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    57275727                    IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u32, pu32Dst, pu32Eax, u32Src, pEFlags);
    57285728                else
    … …  
    57515751                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    57525752                IEMOP_HLP_DONE_DECODING();
    5753                 IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0);
     5753                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
    57545754                IEM_MC_FETCH_GREG_U64(u64Rax, X86_GREG_xAX);
    57555755                IEM_MC_FETCH_EFLAGS(EFlags);
    57565756                IEM_MC_REF_LOCAL(pu64Rax, u64Rax);
    57575757#ifdef RT_ARCH_X86
    5758                 IEM_MC_REF_GREG_U64(pu64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5759                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     5758                IEM_MC_REF_GREG_U64(pu64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5759                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    57605760                    IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u64, pu64Dst, pu64Rax, pu64Src, pEFlags);
    57615761                else
    57625762                    IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u64_locked, pu64Dst, pu64Rax, pu64Src, pEFlags);
    57635763#else
    5764                 IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    5765                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     5764                IEM_MC_FETCH_GREG_U64(u64Src, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     5765                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    57665766                    IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg_u64, pu64Dst, pu64Rax, u64Src, pEFlags);
    57675767                else
    … …  
    57855785{
    57865786    Assert((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT)); /* Caller checks this */
    5787     uint8_t const iGReg = ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg;
    5788 
    5789     switch (pIemCpu->enmEffOpSize)
     5787    uint8_t const iGReg = ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg;
     5788
     5789    switch (pVCpu->iem.s.enmEffOpSize)
    57905790    {
    57915791        case IEMMODE_16BIT:
    … …  
    57955795            IEM_MC_ARG_CONST(uint8_t,   iSegRegArg,/*=*/iSegReg,                 2);
    57965796            IEM_MC_ARG_CONST(uint8_t,   iGRegArg,  /*=*/iGReg,                   3);
    5797             IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSize,/*=*/pIemCpu->enmEffOpSize, 4);
     5797            IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSize,/*=*/pVCpu->iem.s.enmEffOpSize, 4);
    57985798            IEM_MC_LOCAL(RTGCPTR,       GCPtrEff);
    57995799            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEff, bRm, 0);
    58005800            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    5801             IEM_MC_FETCH_MEM_U16(offSeg, pIemCpu->iEffSeg, GCPtrEff);
    5802             IEM_MC_FETCH_MEM_U16_DISP(uSel, pIemCpu->iEffSeg, GCPtrEff, 2);
     5801            IEM_MC_FETCH_MEM_U16(offSeg, pVCpu->iem.s.iEffSeg, GCPtrEff);
     5802            IEM_MC_FETCH_MEM_U16_DISP(uSel, pVCpu->iem.s.iEffSeg, GCPtrEff, 2);
    58035803            IEM_MC_CALL_CIMPL_5(iemCImpl_load_SReg_Greg, uSel, offSeg, iSegRegArg, iGRegArg, enmEffOpSize);
    58045804            IEM_MC_END();
    … …  
    58115811            IEM_MC_ARG_CONST(uint8_t,   iSegRegArg,/*=*/iSegReg,                 2);
    58125812            IEM_MC_ARG_CONST(uint8_t,   iGRegArg,  /*=*/iGReg,                   3);
    5813             IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSize,/*=*/pIemCpu->enmEffOpSize, 4);
     5813            IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSize,/*=*/pVCpu->iem.s.enmEffOpSize, 4);
    58145814            IEM_MC_LOCAL(RTGCPTR,       GCPtrEff);
    58155815            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEff, bRm, 0);
    58165816            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    5817             IEM_MC_FETCH_MEM_U32(offSeg, pIemCpu->iEffSeg, GCPtrEff);
    5818             IEM_MC_FETCH_MEM_U16_DISP(uSel, pIemCpu->iEffSeg, GCPtrEff, 4);
     5817            IEM_MC_FETCH_MEM_U32(offSeg, pVCpu->iem.s.iEffSeg, GCPtrEff);
     5818            IEM_MC_FETCH_MEM_U16_DISP(uSel, pVCpu->iem.s.iEffSeg, GCPtrEff, 4);
    58195819            IEM_MC_CALL_CIMPL_5(iemCImpl_load_SReg_Greg, uSel, offSeg, iSegRegArg, iGRegArg, enmEffOpSize);
    58205820            IEM_MC_END();
    … …  
    58275827            IEM_MC_ARG_CONST(uint8_t,   iSegRegArg,/*=*/iSegReg,                 2);
    58285828            IEM_MC_ARG_CONST(uint8_t,   iGRegArg,  /*=*/iGReg,                   3);
    5829             IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSize,/*=*/pIemCpu->enmEffOpSize, 4);
     5829            IEM_MC_ARG_CONST(IEMMODE,   enmEffOpSize,/*=*/pVCpu->iem.s.enmEffOpSize, 4);
    58305830            IEM_MC_LOCAL(RTGCPTR,       GCPtrEff);
    58315831            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEff, bRm, 0);
    58325832            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    5833             if (IEM_IS_GUEST_CPU_AMD(pIemCpu)) /** @todo testcase: rev 3.15 of the amd manuals claims it only loads a 32-bit greg. */
    5834                 IEM_MC_FETCH_MEM_U32_SX_U64(offSeg, pIemCpu->iEffSeg, GCPtrEff);
     5833            if (IEM_IS_GUEST_CPU_AMD(pVCpu)) /** @todo testcase: rev 3.15 of the amd manuals claims it only loads a 32-bit greg. */
     5834                IEM_MC_FETCH_MEM_U32_SX_U64(offSeg, pVCpu->iem.s.iEffSeg, GCPtrEff);
    58355835            else
    5836                 IEM_MC_FETCH_MEM_U64(offSeg, pIemCpu->iEffSeg, GCPtrEff);
    5837             IEM_MC_FETCH_MEM_U16_DISP(uSel, pIemCpu->iEffSeg, GCPtrEff, 8);
     5836                IEM_MC_FETCH_MEM_U64(offSeg, pVCpu->iem.s.iEffSeg, GCPtrEff);
     5837            IEM_MC_FETCH_MEM_U16_DISP(uSel, pVCpu->iem.s.iEffSeg, GCPtrEff, 8);
    58385838            IEM_MC_CALL_CIMPL_5(iemCImpl_load_SReg_Greg, uSel, offSeg, iSegRegArg, iGRegArg, enmEffOpSize);
    58395839            IEM_MC_END();
    … …  
    59035903    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    59045904    {
    5905         switch (pIemCpu->enmEffOpSize)
     5905        switch (pVCpu->iem.s.enmEffOpSize)
    59065906        {
    59075907            case IEMMODE_16BIT:
    59085908                IEM_MC_BEGIN(0, 1);
    59095909                IEM_MC_LOCAL(uint16_t, u16Value);
    5910                 IEM_MC_FETCH_GREG_U8_ZX_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    5911                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Value);
     5910                IEM_MC_FETCH_GREG_U8_ZX_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     5911                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Value);
    59125912                IEM_MC_ADVANCE_RIP();
    59135913                IEM_MC_END();
    … …  
    59175917                IEM_MC_BEGIN(0, 1);
    59185918                IEM_MC_LOCAL(uint32_t, u32Value);
    5919                 IEM_MC_FETCH_GREG_U8_ZX_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    5920                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     5919                IEM_MC_FETCH_GREG_U8_ZX_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     5920                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Value);
    59215921                IEM_MC_ADVANCE_RIP();
    59225922                IEM_MC_END();
    … …  
    59265926                IEM_MC_BEGIN(0, 1);
    59275927                IEM_MC_LOCAL(uint64_t, u64Value);
    5928                 IEM_MC_FETCH_GREG_U8_ZX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    5929                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     5928                IEM_MC_FETCH_GREG_U8_ZX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     5929                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    59305930                IEM_MC_ADVANCE_RIP();
    59315931                IEM_MC_END();
    … …  
    59405940         * We're loading a register from memory.
    59415941         */
    5942         switch (pIemCpu->enmEffOpSize)
     5942        switch (pVCpu->iem.s.enmEffOpSize)
    59435943        {
    59445944            case IEMMODE_16BIT:
    … …  
    59475947                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    59485948                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    5949                 IEM_MC_FETCH_MEM_U8_ZX_U16(u16Value, pIemCpu->iEffSeg, GCPtrEffDst);
    5950                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Value);
     5949                IEM_MC_FETCH_MEM_U8_ZX_U16(u16Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     5950                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Value);
    59515951                IEM_MC_ADVANCE_RIP();
    59525952                IEM_MC_END();
    … …  
    59585958                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    59595959                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    5960                 IEM_MC_FETCH_MEM_U8_ZX_U32(u32Value, pIemCpu->iEffSeg, GCPtrEffDst);
    5961                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     5960                IEM_MC_FETCH_MEM_U8_ZX_U32(u32Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     5961                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Value);
    59625962                IEM_MC_ADVANCE_RIP();
    59635963                IEM_MC_END();
    … …  
    59695969                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    59705970                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    5971                 IEM_MC_FETCH_MEM_U8_ZX_U64(u64Value, pIemCpu->iEffSeg, GCPtrEffDst);
    5972                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     5971                IEM_MC_FETCH_MEM_U8_ZX_U64(u64Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     5972                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    59735973                IEM_MC_ADVANCE_RIP();
    59745974                IEM_MC_END();
    … …  
    59985998    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    59995999    {
    6000         if (pIemCpu->enmEffOpSize != IEMMODE_64BIT)
     6000        if (pVCpu->iem.s.enmEffOpSize != IEMMODE_64BIT)
    60016001        {
    60026002            IEM_MC_BEGIN(0, 1);
    60036003            IEM_MC_LOCAL(uint32_t, u32Value);
    6004             IEM_MC_FETCH_GREG_U16_ZX_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6005             IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     6004            IEM_MC_FETCH_GREG_U16_ZX_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6005            IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Value);
    60066006            IEM_MC_ADVANCE_RIP();
    60076007            IEM_MC_END();
    … …  
    60116011            IEM_MC_BEGIN(0, 1);
    60126012            IEM_MC_LOCAL(uint64_t, u64Value);
    6013             IEM_MC_FETCH_GREG_U16_ZX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6014             IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     6013            IEM_MC_FETCH_GREG_U16_ZX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6014            IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    60156015            IEM_MC_ADVANCE_RIP();
    60166016            IEM_MC_END();
    … …  
    60226022         * We're loading a register from memory.
    60236023         */
    6024         if (pIemCpu->enmEffOpSize != IEMMODE_64BIT)
     6024        if (pVCpu->iem.s.enmEffOpSize != IEMMODE_64BIT)
    60256025        {
    60266026            IEM_MC_BEGIN(0, 2);
    … …  
    60286028            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    60296029            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6030             IEM_MC_FETCH_MEM_U16_ZX_U32(u32Value, pIemCpu->iEffSeg, GCPtrEffDst);
    6031             IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     6030            IEM_MC_FETCH_MEM_U16_ZX_U32(u32Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     6031            IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Value);
    60326032            IEM_MC_ADVANCE_RIP();
    60336033            IEM_MC_END();
    … …  
    60396039            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    60406040            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6041             IEM_MC_FETCH_MEM_U16_ZX_U64(u64Value, pIemCpu->iEffSeg, GCPtrEffDst);
    6042             IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     6041            IEM_MC_FETCH_MEM_U16_ZX_U64(u64Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     6042            IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    60436043            IEM_MC_ADVANCE_RIP();
    60446044            IEM_MC_END();
    … …  
    60856085        IEMOP_HLP_NO_LOCK_PREFIX();
    60866086
    6087         switch (pIemCpu->enmEffOpSize)
     6087        switch (pVCpu->iem.s.enmEffOpSize)
    60886088        {
    60896089            case IEMMODE_16BIT:
    … …  
    60936093                IEM_MC_ARG(uint32_t *,      pEFlags,                    2);
    60946094
    6095                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     6095                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    60966096                IEM_MC_REF_EFLAGS(pEFlags);
    60976097                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    … …  
    61076107                IEM_MC_ARG(uint32_t *,      pEFlags,                    2);
    61086108
    6109                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     6109                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    61106110                IEM_MC_REF_EFLAGS(pEFlags);
    61116111                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    … …  
    61226122                IEM_MC_ARG(uint32_t *,      pEFlags,                    2);
    61236123
    6124                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     6124                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    61256125                IEM_MC_REF_EFLAGS(pEFlags);
    61266126                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    … …  
    61476147
    61486148        /** @todo test negative bit offsets! */
    6149         switch (pIemCpu->enmEffOpSize)
     6149        switch (pVCpu->iem.s.enmEffOpSize)
    61506150        {
    61516151            case IEMMODE_16BIT:
    … …  
    61606160                IEM_MC_ASSIGN(u16Src, u8Bit & 0x0f);
    61616161                IEM_MC_FETCH_EFLAGS(EFlags);
    6162                 IEM_MC_MEM_MAP(pu16Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0);
    6163                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     6162                IEM_MC_MEM_MAP(pu16Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
     6163                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    61646164                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    61656165                else
    … …  
    61836183                IEM_MC_ASSIGN(u32Src, u8Bit & 0x1f);
    61846184                IEM_MC_FETCH_EFLAGS(EFlags);
    6185                 IEM_MC_MEM_MAP(pu32Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0);
    6186                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     6185                IEM_MC_MEM_MAP(pu32Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
     6186                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    61876187                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    61886188                else
    … …  
    62066206                IEM_MC_ASSIGN(u64Src, u8Bit & 0x3f);
    62076207                IEM_MC_FETCH_EFLAGS(EFlags);
    6208                 IEM_MC_MEM_MAP(pu64Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0);
    6209                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     6208                IEM_MC_MEM_MAP(pu64Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0);
     6209                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    62106210                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    62116211                else
    … …  
    62686268    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    62696269    {
    6270         switch (pIemCpu->enmEffOpSize)
     6270        switch (pVCpu->iem.s.enmEffOpSize)
    62716271        {
    62726272            case IEMMODE_16BIT:
    62736273                IEM_MC_BEGIN(0, 1);
    62746274                IEM_MC_LOCAL(uint16_t, u16Value);
    6275                 IEM_MC_FETCH_GREG_U8_SX_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6276                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Value);
     6275                IEM_MC_FETCH_GREG_U8_SX_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6276                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Value);
    62776277                IEM_MC_ADVANCE_RIP();
    62786278                IEM_MC_END();
    … …  
    62826282                IEM_MC_BEGIN(0, 1);
    62836283                IEM_MC_LOCAL(uint32_t, u32Value);
    6284                 IEM_MC_FETCH_GREG_U8_SX_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6285                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     6284                IEM_MC_FETCH_GREG_U8_SX_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6285                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Value);
    62866286                IEM_MC_ADVANCE_RIP();
    62876287                IEM_MC_END();
    … …  
    62916291                IEM_MC_BEGIN(0, 1);
    62926292                IEM_MC_LOCAL(uint64_t, u64Value);
    6293                 IEM_MC_FETCH_GREG_U8_SX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6294                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     6293                IEM_MC_FETCH_GREG_U8_SX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6294                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    62956295                IEM_MC_ADVANCE_RIP();
    62966296                IEM_MC_END();
    … …  
    63056305         * We're loading a register from memory.
    63066306         */
    6307         switch (pIemCpu->enmEffOpSize)
     6307        switch (pVCpu->iem.s.enmEffOpSize)
    63086308        {
    63096309            case IEMMODE_16BIT:
    … …  
    63126312                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    63136313                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6314                 IEM_MC_FETCH_MEM_U8_SX_U16(u16Value, pIemCpu->iEffSeg, GCPtrEffDst);
    6315                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Value);
     6314                IEM_MC_FETCH_MEM_U8_SX_U16(u16Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     6315                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Value);
    63166316                IEM_MC_ADVANCE_RIP();
    63176317                IEM_MC_END();
    … …  
    63236323                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    63246324                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6325                 IEM_MC_FETCH_MEM_U8_SX_U32(u32Value, pIemCpu->iEffSeg, GCPtrEffDst);
    6326                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     6325                IEM_MC_FETCH_MEM_U8_SX_U32(u32Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     6326                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Value);
    63276327                IEM_MC_ADVANCE_RIP();
    63286328                IEM_MC_END();
    … …  
    63346334                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    63356335                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6336                 IEM_MC_FETCH_MEM_U8_SX_U64(u64Value, pIemCpu->iEffSeg, GCPtrEffDst);
    6337                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     6336                IEM_MC_FETCH_MEM_U8_SX_U64(u64Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     6337                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    63386338                IEM_MC_ADVANCE_RIP();
    63396339                IEM_MC_END();
    … …  
    63636363    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    63646364    {
    6365         if (pIemCpu->enmEffOpSize != IEMMODE_64BIT)
     6365        if (pVCpu->iem.s.enmEffOpSize != IEMMODE_64BIT)
    63666366        {
    63676367            IEM_MC_BEGIN(0, 1);
    63686368            IEM_MC_LOCAL(uint32_t, u32Value);
    6369             IEM_MC_FETCH_GREG_U16_SX_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6370             IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     6369            IEM_MC_FETCH_GREG_U16_SX_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6370            IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Value);
    63716371            IEM_MC_ADVANCE_RIP();
    63726372            IEM_MC_END();
    … …  
    63766376            IEM_MC_BEGIN(0, 1);
    63776377            IEM_MC_LOCAL(uint64_t, u64Value);
    6378             IEM_MC_FETCH_GREG_U16_SX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6379             IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     6378            IEM_MC_FETCH_GREG_U16_SX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6379            IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    63806380            IEM_MC_ADVANCE_RIP();
    63816381            IEM_MC_END();
    … …  
    63876387         * We're loading a register from memory.
    63886388         */
    6389         if (pIemCpu->enmEffOpSize != IEMMODE_64BIT)
     6389        if (pVCpu->iem.s.enmEffOpSize != IEMMODE_64BIT)
    63906390        {
    63916391            IEM_MC_BEGIN(0, 2);
    … …  
    63936393            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    63946394            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6395             IEM_MC_FETCH_MEM_U16_SX_U32(u32Value, pIemCpu->iEffSeg, GCPtrEffDst);
    6396             IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     6395            IEM_MC_FETCH_MEM_U16_SX_U32(u32Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     6396            IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Value);
    63976397            IEM_MC_ADVANCE_RIP();
    63986398            IEM_MC_END();
    … …  
    64046404            IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    64056405            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6406             IEM_MC_FETCH_MEM_U16_SX_U64(u64Value, pIemCpu->iEffSeg, GCPtrEffDst);
    6407             IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     6406            IEM_MC_FETCH_MEM_U16_SX_U64(u64Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     6407            IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    64086408            IEM_MC_ADVANCE_RIP();
    64096409            IEM_MC_END();
    … …  
    64336433        IEM_MC_ARG(uint32_t *, pEFlags, 2);
    64346434
    6435         IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6436         IEM_MC_REF_GREG_U8(pu8Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     6435        IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6436        IEM_MC_REF_GREG_U8(pu8Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    64376437        IEM_MC_REF_EFLAGS(pEFlags);
    64386438        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_xadd_u8, pu8Dst, pu8Reg, pEFlags);
    … …  
    64546454
    64556455        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6456         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    6457         IEM_MC_FETCH_GREG_U8(u8RegCopy, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     6456        IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     6457        IEM_MC_FETCH_GREG_U8(u8RegCopy, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    64586458        IEM_MC_REF_LOCAL(pu8Reg, u8RegCopy);
    64596459        IEM_MC_FETCH_EFLAGS(EFlags);
    6460         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     6460        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    64616461            IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_xadd_u8, pu8Dst, pu8Reg, pEFlags);
    64626462        else
    … …  
    64656465        IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Dst, IEM_ACCESS_DATA_RW);
    64666466        IEM_MC_COMMIT_EFLAGS(EFlags);
    6467         IEM_MC_STORE_GREG_U8(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u8RegCopy);
     6467        IEM_MC_STORE_GREG_U8(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u8RegCopy);
    64686468        IEM_MC_ADVANCE_RIP();
    64696469        IEM_MC_END();
    … …  
    64886488        IEMOP_HLP_NO_LOCK_PREFIX();
    64896489
    6490         switch (pIemCpu->enmEffOpSize)
     6490        switch (pVCpu->iem.s.enmEffOpSize)
    64916491        {
    64926492            case IEMMODE_16BIT:
    … …  
    64966496                IEM_MC_ARG(uint32_t *, pEFlags, 2);
    64976497
    6498                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6499                 IEM_MC_REF_GREG_U16(pu16Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     6498                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6499                IEM_MC_REF_GREG_U16(pu16Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    65006500                IEM_MC_REF_EFLAGS(pEFlags);
    65016501                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_xadd_u16, pu16Dst, pu16Reg, pEFlags);
    … …  
    65116511                IEM_MC_ARG(uint32_t *, pEFlags, 2);
    65126512
    6513                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6514                 IEM_MC_REF_GREG_U32(pu32Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     6513                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6514                IEM_MC_REF_GREG_U32(pu32Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    65156515                IEM_MC_REF_EFLAGS(pEFlags);
    65166516                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_xadd_u32, pu32Dst, pu32Reg, pEFlags);
    … …  
    65286528                IEM_MC_ARG(uint32_t *, pEFlags, 2);
    65296529
    6530                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    6531                 IEM_MC_REF_GREG_U64(pu64Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     6530                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     6531                IEM_MC_REF_GREG_U64(pu64Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    65326532                IEM_MC_REF_EFLAGS(pEFlags);
    65336533                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_xadd_u64, pu64Dst, pu64Reg, pEFlags);
    … …  
    65456545         * We're accessing memory.
    65466546         */
    6547         switch (pIemCpu->enmEffOpSize)
     6547        switch (pVCpu->iem.s.enmEffOpSize)
    65486548        {
    65496549            case IEMMODE_16BIT:
    … …  
    65566556
    65576557                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6558                 IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    6559                 IEM_MC_FETCH_GREG_U16(u16RegCopy, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     6558                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     6559                IEM_MC_FETCH_GREG_U16(u16RegCopy, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    65606560                IEM_MC_REF_LOCAL(pu16Reg, u16RegCopy);
    65616561                IEM_MC_FETCH_EFLAGS(EFlags);
    6562                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     6562                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    65636563                    IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_xadd_u16, pu16Dst, pu16Reg, pEFlags);
    65646564                else
    … …  
    65676567                IEM_MC_MEM_COMMIT_AND_UNMAP(pu16Dst, IEM_ACCESS_DATA_RW);
    65686568                IEM_MC_COMMIT_EFLAGS(EFlags);
    6569                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16RegCopy);
     6569                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16RegCopy);
    65706570                IEM_MC_ADVANCE_RIP();
    65716571                IEM_MC_END();
    … …  
    65816581
    65826582                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6583                 IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    6584                 IEM_MC_FETCH_GREG_U32(u32RegCopy, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     6583                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     6584                IEM_MC_FETCH_GREG_U32(u32RegCopy, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    65856585                IEM_MC_REF_LOCAL(pu32Reg, u32RegCopy);
    65866586                IEM_MC_FETCH_EFLAGS(EFlags);
    6587                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     6587                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    65886588                    IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_xadd_u32, pu32Dst, pu32Reg, pEFlags);
    65896589                else
    … …  
    65926592                IEM_MC_MEM_COMMIT_AND_UNMAP(pu32Dst, IEM_ACCESS_DATA_RW);
    65936593                IEM_MC_COMMIT_EFLAGS(EFlags);
    6594                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32RegCopy);
     6594                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32RegCopy);
    65956595                IEM_MC_ADVANCE_RIP();
    65966596                IEM_MC_END();
    … …  
    66066606
    66076607                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    6608                 IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    6609                 IEM_MC_FETCH_GREG_U64(u64RegCopy, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     6608                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     6609                IEM_MC_FETCH_GREG_U64(u64RegCopy, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    66106610                IEM_MC_REF_LOCAL(pu64Reg, u64RegCopy);
    66116611                IEM_MC_FETCH_EFLAGS(EFlags);
    6612                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     6612                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    66136613                    IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_xadd_u64, pu64Dst, pu64Reg, pEFlags);
    66146614                else
    … …  
    66176617                IEM_MC_MEM_COMMIT_AND_UNMAP(pu64Dst, IEM_ACCESS_DATA_RW);
    66186618                IEM_MC_COMMIT_EFLAGS(EFlags);
    6619                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64RegCopy);
     6619                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64RegCopy);
    66206620                IEM_MC_ADVANCE_RIP();
    66216621                IEM_MC_END();
    … …  
    66416641    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    66426642    {
    6643         switch (pIemCpu->enmEffOpSize)
     6643        switch (pVCpu->iem.s.enmEffOpSize)
    66446644        {
    66456645            case IEMMODE_32BIT:
    … …  
    66506650                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    66516651                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    6652                 if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fSse2)
     6652                if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSse2)
    66536653                    return IEMOP_RAISE_INVALID_OPCODE();
    66546654
    6655                 IEM_MC_FETCH_GREG_U32(u32Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    6656                 IEM_MC_STORE_MEM_U32(pIemCpu->iEffSeg, GCPtrEffDst, u32Value);
     6655                IEM_MC_FETCH_GREG_U32(u32Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     6656                IEM_MC_STORE_MEM_U32(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u32Value);
    66576657                IEM_MC_ADVANCE_RIP();
    66586658                IEM_MC_END();
    … …  
    66666666                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    66676667                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    6668                 if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fSse2)
     6668                if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSse2)
    66696669                    return IEMOP_RAISE_INVALID_OPCODE();
    66706670
    6671                 IEM_MC_FETCH_GREG_U64(u64Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    6672                 IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffDst, u64Value);
     6671                IEM_MC_FETCH_GREG_U64(u64Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     6672                IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u64Value);
    66736673                IEM_MC_ADVANCE_RIP();
    66746674                IEM_MC_END();
    … …  
    67126712    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    67136713    IEMOP_HLP_DONE_DECODING();
    6714     IEM_MC_MEM_MAP(pu64MemDst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     6714    IEM_MC_MEM_MAP(pu64MemDst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    67156715
    67166716    IEM_MC_FETCH_GREG_U32(u64EaxEdx.s.Lo, X86_GREG_xAX);
    … …  
    67236723
    67246724    IEM_MC_FETCH_EFLAGS(EFlags);
    6725     if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     6725    if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    67266726        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpxchg8b, pu64MemDst, pu64EaxEdx, pu64EbxEcx, pEFlags);
    67276727    else
    … …  
    67736773            /** @todo Testcase: Check prefix effects on cmpxchg8b/16b. */
    67746774            if (   (bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)
    6775                 || (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ))) /** @todo Testcase: AMD seems to express a different idea here wrt prefixes. */
     6775                || (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ))) /** @todo Testcase: AMD seems to express a different idea here wrt prefixes. */
    67766776                return IEMOP_RAISE_INVALID_OPCODE();
    67776777            if (bRm & IEM_OP_PRF_SIZE_REX_W)
    … …  
    67816781            if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    67826782                return FNIEMOP_CALL_1(iemOp_Grp9_rdrand_Rv, bRm);
    6783             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ))
     6783            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ))
    67846784            {
    67856785                case 0:
    … …  
    67936793            }
    67946794        case 7:
    6795             switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ))
     6795            switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPZ))
    67966796            {
    67976797                case 0:
    … …  
    68126812{
    68136813    IEMOP_HLP_NO_LOCK_PREFIX();
    6814     switch (pIemCpu->enmEffOpSize)
     6814    switch (pVCpu->iem.s.enmEffOpSize)
    68156815    {
    68166816        case IEMMODE_16BIT:
    … …  
    68556855             case, see iemOp_mov_AL_Ib and iemOp_mov_eAX_Iv. */
    68566856    IEMOP_HLP_MIN_486();
    6857     return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xAX | pIemCpu->uRexB);
     6857    return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xAX | pVCpu->iem.s.uRexB);
    68586858}
    68596859
    … …  
    68646864    IEMOP_MNEMONIC("bswap rCX/r9");
    68656865    IEMOP_HLP_MIN_486();
    6866     return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xCX | pIemCpu->uRexB);
     6866    return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xCX | pVCpu->iem.s.uRexB);
    68676867}
    68686868
    … …  
    68736873    IEMOP_MNEMONIC("bswap rDX/r9");
    68746874    IEMOP_HLP_MIN_486();
    6875     return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xDX | pIemCpu->uRexB);
     6875    return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xDX | pVCpu->iem.s.uRexB);
    68766876}
    68776877
    … …  
    68826882    IEMOP_MNEMONIC("bswap rBX/r9");
    68836883    IEMOP_HLP_MIN_486();
    6884     return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xBX | pIemCpu->uRexB);
     6884    return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xBX | pVCpu->iem.s.uRexB);
    68856885}
    68866886
    … …  
    68916891    IEMOP_MNEMONIC("bswap rSP/r12");
    68926892    IEMOP_HLP_MIN_486();
    6893     return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xSP | pIemCpu->uRexB);
     6893    return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xSP | pVCpu->iem.s.uRexB);
    68946894}
    68956895
    … …  
    69006900    IEMOP_MNEMONIC("bswap rBP/r13");
    69016901    IEMOP_HLP_MIN_486();
    6902     return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xBP | pIemCpu->uRexB);
     6902    return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xBP | pVCpu->iem.s.uRexB);
    69036903}
    69046904
    … …  
    69096909    IEMOP_MNEMONIC("bswap rSI/r14");
    69106910    IEMOP_HLP_MIN_486();
    6911     return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xSI | pIemCpu->uRexB);
     6911    return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xSI | pVCpu->iem.s.uRexB);
    69126912}
    69136913
    … …  
    69186918    IEMOP_MNEMONIC("bswap rDI/r15");
    69196919    IEMOP_HLP_MIN_486();
    6920     return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xDI | pIemCpu->uRexB);
     6920    return FNIEMOP_CALL_1(iemOpCommonBswapGReg, X86_GREG_xDI | pVCpu->iem.s.uRexB);
    69216921}
    69226922
    … …  
    69526952     *        and opcode modifications are made to work with the whole width (not
    69536953     *        just 128). */
    6954     switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     6954    switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    69556955    {
    69566956        case IEM_OP_PRF_SIZE_OP: /* SSE */
    … …  
    69626962            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    69636963            IEM_MC_PREPARE_SSE_USAGE();
    6964             IEM_MC_REF_GREG_U64(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    6965             IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     6964            IEM_MC_REF_GREG_U64(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     6965            IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    69666966            IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_pmovmskb_u128, pDst, pSrc);
    69676967            IEM_MC_ADVANCE_RIP();
    … …  
    70257025FNIEMOP_DEF(iemOp_movntq_Mq_Pq__movntdq_Mdq_Vdq)
    70267026{
    7027     IEMOP_MNEMONIC(!(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP) ? "movntq mr,r" : "movntdq mr,r");
     7027    IEMOP_MNEMONIC(!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP) ? "movntq mr,r" : "movntdq mr,r");
    70287028    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    70297029    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    … …  
    70337033         */
    70347034/** @todo check when the REPNZ/Z bits kick in. Same as lock, probably... */
    7035         switch (pIemCpu->fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     7035        switch (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    70367036        {
    70377037
    … …  
    70467046                IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
    70477047
    7048                 IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    7049                 IEM_MC_STORE_MEM_U128_ALIGN_SSE(pIemCpu->iEffSeg, GCPtrEffSrc, uSrc);
     7048                IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     7049                IEM_MC_STORE_MEM_U128_ALIGN_SSE(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
    70507050
    70517051                IEM_MC_ADVANCE_RIP();
    … …  
    70647064
    70657065                IEM_MC_FETCH_MREG_U64(uSrc, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    7066                 IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffSrc, uSrc);
     7066                IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
    70677067
    70687068                IEM_MC_ADVANCE_RIP();
    … …  
    74677467    IEMOP_HLP_NO_64BIT();
    74687468    IEMOP_HLP_NO_LOCK_PREFIX();
    7469     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_pop_Sreg, X86_SREG_ES, pIemCpu->enmEffOpSize);
     7469    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_pop_Sreg, X86_SREG_ES, pVCpu->iem.s.enmEffOpSize);
    74707470}
    74717471
    … …  
    76047604    IEMOP_HLP_NO_LOCK_PREFIX();
    76057605    IEMOP_HLP_NO_64BIT();
    7606     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_pop_Sreg, X86_SREG_SS, pIemCpu->enmEffOpSize);
     7606    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_pop_Sreg, X86_SREG_SS, pVCpu->iem.s.enmEffOpSize);
    76077607}
    76087608
    … …  
    76707670    IEMOP_HLP_NO_LOCK_PREFIX();
    76717671    IEMOP_HLP_NO_64BIT();
    7672     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_pop_Sreg, X86_SREG_DS, pIemCpu->enmEffOpSize);
     7672    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_pop_Sreg, X86_SREG_DS, pVCpu->iem.s.enmEffOpSize);
    76737673}
    76747674
    … …  
    77327732{
    77337733    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("seg es");
    7734     pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_ES;
    7735     pIemCpu->iEffSeg    = X86_SREG_ES;
     7734    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_SEG_ES;
     7735    pVCpu->iem.s.iEffSeg    = X86_SREG_ES;
    77367736
    77377737    uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    78037803{
    78047804    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("seg cs");
    7805     pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_CS;
    7806     pIemCpu->iEffSeg    = X86_SREG_CS;
     7805    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_SEG_CS;
     7806    pVCpu->iem.s.iEffSeg    = X86_SREG_CS;
    78077807
    78087808    uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    78807880{
    78817881    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("seg ss");
    7882     pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_SS;
    7883     pIemCpu->iEffSeg    = X86_SREG_SS;
     7882    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_SEG_SS;
     7883    pVCpu->iem.s.iEffSeg    = X86_SREG_SS;
    78847884
    78857885    uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    79467946{
    79477947    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("seg ds");
    7948     pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_DS;
    7949     pIemCpu->iEffSeg    = X86_SREG_DS;
     7948    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_SEG_DS;
     7949    pVCpu->iem.s.iEffSeg    = X86_SREG_DS;
    79507950
    79517951    uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    79637963{
    79647964    IEMOP_HLP_NO_LOCK_PREFIX();
    7965     switch (pIemCpu->enmEffOpSize)
     7965    switch (pVCpu->iem.s.enmEffOpSize)
    79667966    {
    79677967        case IEMMODE_16BIT:
    … …  
    80098009     * This is a REX prefix in 64-bit mode.
    80108010     */
    8011     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8011    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    80128012    {
    80138013        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex");
    8014         pIemCpu->fPrefixes |= IEM_OP_PRF_REX;
     8014        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX;
    80158015
    80168016        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    80298029     * This is a REX prefix in 64-bit mode.
    80308030     */
    8031     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8031    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    80328032    {
    80338033        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.b");
    8034         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B;
    8035         pIemCpu->uRexB     = 1 << 3;
     8034        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B;
     8035        pVCpu->iem.s.uRexB     = 1 << 3;
    80368036
    80378037        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    80508050     * This is a REX prefix in 64-bit mode.
    80518051     */
    8052     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8052    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    80538053    {
    80548054        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.x");
    8055         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_X;
    8056         pIemCpu->uRexIndex = 1 << 3;
     8055        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_X;
     8056        pVCpu->iem.s.uRexIndex = 1 << 3;
    80578057
    80588058        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    80728072     * This is a REX prefix in 64-bit mode.
    80738073     */
    8074     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8074    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    80758075    {
    80768076        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.bx");
    8077         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X;
    8078         pIemCpu->uRexB     = 1 << 3;
    8079         pIemCpu->uRexIndex = 1 << 3;
     8077        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X;
     8078        pVCpu->iem.s.uRexB     = 1 << 3;
     8079        pVCpu->iem.s.uRexIndex = 1 << 3;
    80808080
    80818081        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    80948094     * This is a REX prefix in 64-bit mode.
    80958095     */
    8096     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8096    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    80978097    {
    80988098        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.r");
    8099         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R;
    8100         pIemCpu->uRexReg   = 1 << 3;
     8099        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R;
     8100        pVCpu->iem.s.uRexReg   = 1 << 3;
    81018101
    81028102        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    81158115     * This is a REX prefix in 64-bit mode.
    81168116     */
    8117     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8117    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    81188118    {
    81198119        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rb");
    8120         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B;
    8121         pIemCpu->uRexReg   = 1 << 3;
    8122         pIemCpu->uRexB     = 1 << 3;
     8120        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B;
     8121        pVCpu->iem.s.uRexReg   = 1 << 3;
     8122        pVCpu->iem.s.uRexB     = 1 << 3;
    81238123
    81248124        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    81378137     * This is a REX prefix in 64-bit mode.
    81388138     */
    8139     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8139    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    81408140    {
    81418141        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rx");
    8142         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_X;
    8143         pIemCpu->uRexReg   = 1 << 3;
    8144         pIemCpu->uRexIndex = 1 << 3;
     8142        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_X;
     8143        pVCpu->iem.s.uRexReg   = 1 << 3;
     8144        pVCpu->iem.s.uRexIndex = 1 << 3;
    81458145
    81468146        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    81598159     * This is a REX prefix in 64-bit mode.
    81608160     */
    8161     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8161    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    81628162    {
    81638163        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rbx");
    8164         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X;
    8165         pIemCpu->uRexReg   = 1 << 3;
    8166         pIemCpu->uRexB     = 1 << 3;
    8167         pIemCpu->uRexIndex = 1 << 3;
     8164        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X;
     8165        pVCpu->iem.s.uRexReg   = 1 << 3;
     8166        pVCpu->iem.s.uRexB     = 1 << 3;
     8167        pVCpu->iem.s.uRexIndex = 1 << 3;
    81688168
    81698169        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    81828182     * This is a REX prefix in 64-bit mode.
    81838183     */
    8184     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8184    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    81858185    {
    81868186        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.w");
    8187         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_SIZE_REX_W;
    8188         iemRecalEffOpSize(pIemCpu);
     8187        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_SIZE_REX_W;
     8188        iemRecalEffOpSize(pVCpu);
    81898189
    81908190        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    82038203     * This is a REX prefix in 64-bit mode.
    82048204     */
    8205     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8205    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    82068206    {
    82078207        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.bw");
    8208         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B | IEM_OP_PRF_SIZE_REX_W;
    8209         pIemCpu->uRexB     = 1 << 3;
    8210         iemRecalEffOpSize(pIemCpu);
     8208        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B | IEM_OP_PRF_SIZE_REX_W;
     8209        pVCpu->iem.s.uRexB     = 1 << 3;
     8210        iemRecalEffOpSize(pVCpu);
    82118211
    82128212        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    82258225     * This is a REX prefix in 64-bit mode.
    82268226     */
    8227     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8227    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    82288228    {
    82298229        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.xw");
    8230         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
    8231         pIemCpu->uRexIndex = 1 << 3;
    8232         iemRecalEffOpSize(pIemCpu);
     8230        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
     8231        pVCpu->iem.s.uRexIndex = 1 << 3;
     8232        iemRecalEffOpSize(pVCpu);
    82338233
    82348234        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    82478247     * This is a REX prefix in 64-bit mode.
    82488248     */
    8249     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8249    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    82508250    {
    82518251        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.bxw");
    8252         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
    8253         pIemCpu->uRexB     = 1 << 3;
    8254         pIemCpu->uRexIndex = 1 << 3;
    8255         iemRecalEffOpSize(pIemCpu);
     8252        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
     8253        pVCpu->iem.s.uRexB     = 1 << 3;
     8254        pVCpu->iem.s.uRexIndex = 1 << 3;
     8255        iemRecalEffOpSize(pVCpu);
    82568256
    82578257        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    82708270     * This is a REX prefix in 64-bit mode.
    82718271     */
    8272     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8272    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    82738273    {
    82748274        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rw");
    8275         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_SIZE_REX_W;
    8276         pIemCpu->uRexReg   = 1 << 3;
    8277         iemRecalEffOpSize(pIemCpu);
     8275        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_SIZE_REX_W;
     8276        pVCpu->iem.s.uRexReg   = 1 << 3;
     8277        iemRecalEffOpSize(pVCpu);
    82788278
    82798279        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    82928292     * This is a REX prefix in 64-bit mode.
    82938293     */
    8294     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8294    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    82958295    {
    82968296        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rbw");
    8297         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B | IEM_OP_PRF_SIZE_REX_W;
    8298         pIemCpu->uRexReg   = 1 << 3;
    8299         pIemCpu->uRexB     = 1 << 3;
    8300         iemRecalEffOpSize(pIemCpu);
     8297        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B | IEM_OP_PRF_SIZE_REX_W;
     8298        pVCpu->iem.s.uRexReg   = 1 << 3;
     8299        pVCpu->iem.s.uRexB     = 1 << 3;
     8300        iemRecalEffOpSize(pVCpu);
    83018301
    83028302        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    83158315     * This is a REX prefix in 64-bit mode.
    83168316     */
    8317     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8317    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    83188318    {
    83198319        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rxw");
    8320         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
    8321         pIemCpu->uRexReg   = 1 << 3;
    8322         pIemCpu->uRexIndex = 1 << 3;
    8323         iemRecalEffOpSize(pIemCpu);
     8320        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
     8321        pVCpu->iem.s.uRexReg   = 1 << 3;
     8322        pVCpu->iem.s.uRexIndex = 1 << 3;
     8323        iemRecalEffOpSize(pVCpu);
    83248324
    83258325        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    83388338     * This is a REX prefix in 64-bit mode.
    83398339     */
    8340     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
     8340    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    83418341    {
    83428342        IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("rex.rbxw");
    8343         pIemCpu->fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
    8344         pIemCpu->uRexReg   = 1 << 3;
    8345         pIemCpu->uRexB     = 1 << 3;
    8346         pIemCpu->uRexIndex = 1 << 3;
    8347         iemRecalEffOpSize(pIemCpu);
     8343        pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REX | IEM_OP_PRF_REX_R | IEM_OP_PRF_REX_B | IEM_OP_PRF_REX_X | IEM_OP_PRF_SIZE_REX_W;
     8344        pVCpu->iem.s.uRexReg   = 1 << 3;
     8345        pVCpu->iem.s.uRexB     = 1 << 3;
     8346        pVCpu->iem.s.uRexIndex = 1 << 3;
     8347        iemRecalEffOpSize(pVCpu);
    83488348
    83498349        uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    83628362{
    83638363    IEMOP_HLP_NO_LOCK_PREFIX();
    8364     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    8365     {
    8366         iReg |= pIemCpu->uRexB;
    8367         pIemCpu->enmDefOpSize = IEMMODE_64BIT;
    8368         pIemCpu->enmEffOpSize = !(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP) ? IEMMODE_64BIT : IEMMODE_16BIT;
    8369     }
    8370 
    8371     switch (pIemCpu->enmEffOpSize)
     8364    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
     8365    {
     8366        iReg |= pVCpu->iem.s.uRexB;
     8367        pVCpu->iem.s.enmDefOpSize = IEMMODE_64BIT;
     8368        pVCpu->iem.s.enmEffOpSize = !(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP) ? IEMMODE_64BIT : IEMMODE_16BIT;
     8369    }
     8370
     8371    switch (pVCpu->iem.s.enmEffOpSize)
    83728372    {
    83738373        case IEMMODE_16BIT:
    … …  
    84398439{
    84408440    IEMOP_MNEMONIC("push rSP");
    8441     if (IEM_GET_TARGET_CPU(pIemCpu) == IEMTARGETCPU_8086)
     8441    if (IEM_GET_TARGET_CPU(pVCpu) == IEMTARGETCPU_8086)
    84428442    {
    84438443        IEM_MC_BEGIN(0, 1);
    … …  
    84838483{
    84848484    IEMOP_HLP_NO_LOCK_PREFIX();
    8485     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    8486     {
    8487         iReg |= pIemCpu->uRexB;
    8488         pIemCpu->enmDefOpSize = IEMMODE_64BIT;
    8489         pIemCpu->enmEffOpSize = !(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP) ? IEMMODE_64BIT : IEMMODE_16BIT;
    8490     }
    8491 
    8492     switch (pIemCpu->enmEffOpSize)
     8485    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
     8486    {
     8487        iReg |= pVCpu->iem.s.uRexB;
     8488        pVCpu->iem.s.enmDefOpSize = IEMMODE_64BIT;
     8489        pVCpu->iem.s.enmEffOpSize = !(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP) ? IEMMODE_64BIT : IEMMODE_16BIT;
     8490    }
     8491
     8492    switch (pVCpu->iem.s.enmEffOpSize)
    84938493    {
    84948494        case IEMMODE_16BIT:
    … …  
    85618561{
    85628562    IEMOP_MNEMONIC("pop rSP");
    8563     if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
    8564     {
    8565         if (pIemCpu->uRexB)
     8563    if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
     8564    {
     8565        if (pVCpu->iem.s.uRexB)
    85668566            return FNIEMOP_CALL_1(iemOpCommonPopGReg, X86_GREG_xSP);
    8567         pIemCpu->enmDefOpSize = IEMMODE_64BIT;
    8568         pIemCpu->enmEffOpSize = !(pIemCpu->fPrefixes & IEM_OP_PRF_SIZE_OP) ? IEMMODE_64BIT : IEMMODE_16BIT;
     8567        pVCpu->iem.s.enmDefOpSize = IEMMODE_64BIT;
     8568        pVCpu->iem.s.enmEffOpSize = !(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_OP) ? IEMMODE_64BIT : IEMMODE_16BIT;
    85698569    }
    85708570
    … …  
    85728572                           DISOPTYPE_HARMLESS | DISOPTYPE_DEFAULT_64_OP_SIZE | DISOPTYPE_REXB_EXTENDS_OPREG);
    85738573    /** @todo add testcase for this instruction. */
    8574     switch (pIemCpu->enmEffOpSize)
     8574    switch (pVCpu->iem.s.enmEffOpSize)
    85758575    {
    85768576        case IEMMODE_16BIT:
    … …  
    86368636    IEMOP_HLP_MIN_186();
    86378637    IEMOP_HLP_NO_64BIT();
    8638     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     8638    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    86398639        return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_pusha_16);
    8640     Assert(pIemCpu->enmEffOpSize == IEMMODE_32BIT);
     8640    Assert(pVCpu->iem.s.enmEffOpSize == IEMMODE_32BIT);
    86418641    return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_pusha_32);
    86428642}
    … …  
    86498649    IEMOP_HLP_MIN_186();
    86508650    IEMOP_HLP_NO_64BIT();
    8651     if (pIemCpu->enmEffOpSize == IEMMODE_16BIT)
     8651    if (pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT)
    86528652        return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_popa_16);
    8653     Assert(pIemCpu->enmEffOpSize == IEMMODE_32BIT);
     8653    Assert(pVCpu->iem.s.enmEffOpSize == IEMMODE_32BIT);
    86548654    return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_popa_32);
    86558655}
    … …  
    86978697        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    86988698        IEMOP_HLP_DECODED_NL_2(OP_ARPL, IEMOPFORM_MR_REG, OP_PARM_Ew, OP_PARM_Gw, DISOPTYPE_HARMLESS);
    8699         IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     8699        IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    87008700        IEM_MC_FETCH_GREG_U16(u16Src, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
    87018701        IEM_MC_FETCH_EFLAGS(EFlags);
    … …  
    87188718FNIEMOP_DEF(iemOp_movsxd_Gv_Ev)
    87198719{
    8720     Assert(pIemCpu->enmEffOpSize == IEMMODE_64BIT); /* Caller branched already . */
     8720    Assert(pVCpu->iem.s.enmEffOpSize == IEMMODE_64BIT); /* Caller branched already . */
    87218721
    87228722    IEMOP_MNEMONIC("movsxd Gv,Ev");
    … …  
    87318731        IEM_MC_BEGIN(0, 1);
    87328732        IEM_MC_LOCAL(uint64_t, u64Value);
    8733         IEM_MC_FETCH_GREG_U32_SX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    8734         IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     8733        IEM_MC_FETCH_GREG_U32_SX_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     8734        IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    87358735        IEM_MC_ADVANCE_RIP();
    87368736        IEM_MC_END();
    … …  
    87468746        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    87478747        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    8748         IEM_MC_FETCH_MEM_U32_SX_U64(u64Value, pIemCpu->iEffSeg, GCPtrEffDst);
    8749         IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     8748        IEM_MC_FETCH_MEM_U32_SX_U64(u64Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     8749        IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    87508750        IEM_MC_ADVANCE_RIP();
    87518751        IEM_MC_END();
    … …  
    87618761    IEMOP_HLP_MIN_386();
    87628762
    8763     pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_FS;
    8764     pIemCpu->iEffSeg    = X86_SREG_FS;
     8763    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_SEG_FS;
     8764    pVCpu->iem.s.iEffSeg    = X86_SREG_FS;
    87658765
    87668766    uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    87758775    IEMOP_HLP_MIN_386();
    87768776
    8777     pIemCpu->fPrefixes |= IEM_OP_PRF_SEG_GS;
    8778     pIemCpu->iEffSeg    = X86_SREG_GS;
     8777    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_SEG_GS;
     8778    pVCpu->iem.s.iEffSeg    = X86_SREG_GS;
    87798779
    87808780    uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    87898789    IEMOP_HLP_MIN_386();
    87908790
    8791     pIemCpu->fPrefixes |= IEM_OP_PRF_SIZE_OP;
    8792     iemRecalEffOpSize(pIemCpu);
     8791    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_SIZE_OP;
     8792    iemRecalEffOpSize(pVCpu);
    87938793
    87948794    uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    88038803    IEMOP_HLP_MIN_386();
    88048804
    8805     pIemCpu->fPrefixes |= IEM_OP_PRF_SIZE_ADDR;
    8806     switch (pIemCpu->enmDefAddrMode)
    8807     {
    8808         case IEMMODE_16BIT: pIemCpu->enmEffAddrMode = IEMMODE_32BIT; break;
    8809         case IEMMODE_32BIT: pIemCpu->enmEffAddrMode = IEMMODE_16BIT; break;
    8810         case IEMMODE_64BIT: pIemCpu->enmEffAddrMode = IEMMODE_32BIT; break;
     8805    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_SIZE_ADDR;
     8806    switch (pVCpu->iem.s.enmDefAddrMode)
     8807    {
     8808        case IEMMODE_16BIT: pVCpu->iem.s.enmEffAddrMode = IEMMODE_32BIT; break;
     8809        case IEMMODE_32BIT: pVCpu->iem.s.enmEffAddrMode = IEMMODE_16BIT; break;
     8810        case IEMMODE_64BIT: pVCpu->iem.s.enmEffAddrMode = IEMMODE_32BIT; break;
    88118811        default: AssertFailed();
    88128812    }
    … …  
    88238823    IEMOP_HLP_MIN_186();
    88248824    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    8825     switch (pIemCpu->enmEffOpSize)
     8825    switch (pVCpu->iem.s.enmEffOpSize)
    88268826    {
    88278827        case IEMMODE_16BIT:
    … …  
    88718871    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF);
    88728872
    8873     switch (pIemCpu->enmEffOpSize)
     8873    switch (pVCpu->iem.s.enmEffOpSize)
    88748874    {
    88758875        case IEMMODE_16BIT:
    … …  
    88878887                IEM_MC_LOCAL(uint16_t,      u16Tmp);
    88888888
    8889                 IEM_MC_FETCH_GREG_U16(u16Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     8889                IEM_MC_FETCH_GREG_U16(u16Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    88908890                IEM_MC_REF_LOCAL(pu16Dst, u16Tmp);
    88918891                IEM_MC_REF_EFLAGS(pEFlags);
    88928892                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u16, pu16Dst, u16Src, pEFlags);
    8893                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Tmp);
     8893                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Tmp);
    88948894
    88958895                IEM_MC_ADVANCE_RIP();
    … …  
    89108910                IEM_MC_ASSIGN(u16Src, u16Imm);
    89118911                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    8912                 IEM_MC_FETCH_MEM_U16(u16Tmp, pIemCpu->iEffSeg, GCPtrEffDst);
     8912                IEM_MC_FETCH_MEM_U16(u16Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    89138913                IEM_MC_REF_LOCAL(pu16Dst, u16Tmp);
    89148914                IEM_MC_REF_EFLAGS(pEFlags);
    89158915                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u16, pu16Dst, u16Src, pEFlags);
    8916                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Tmp);
     8916                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Tmp);
    89178917
    89188918                IEM_MC_ADVANCE_RIP();
    … …  
    89368936                IEM_MC_LOCAL(uint32_t,      u32Tmp);
    89378937
    8938                 IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     8938                IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    89398939                IEM_MC_REF_LOCAL(pu32Dst, u32Tmp);
    89408940                IEM_MC_REF_EFLAGS(pEFlags);
    89418941                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u32, pu32Dst, u32Src, pEFlags);
    8942                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp);
     8942                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp);
    89438943
    89448944                IEM_MC_ADVANCE_RIP();
    … …  
    89598959                IEM_MC_ASSIGN(u32Src, u32Imm);
    89608960                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    8961                 IEM_MC_FETCH_MEM_U32(u32Tmp, pIemCpu->iEffSeg, GCPtrEffDst);
     8961                IEM_MC_FETCH_MEM_U32(u32Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    89628962                IEM_MC_REF_LOCAL(pu32Dst, u32Tmp);
    89638963                IEM_MC_REF_EFLAGS(pEFlags);
    89648964                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u32, pu32Dst, u32Src, pEFlags);
    8965                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp);
     8965                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp);
    89668966
    89678967                IEM_MC_ADVANCE_RIP();
    … …  
    89858985                IEM_MC_LOCAL(uint64_t,      u64Tmp);
    89868986
    8987                 IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     8987                IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    89888988                IEM_MC_REF_LOCAL(pu64Dst, u64Tmp);
    89898989                IEM_MC_REF_EFLAGS(pEFlags);
    89908990                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u64, pu64Dst, u64Src, pEFlags);
    8991                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp);
     8991                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp);
    89928992
    89938993                IEM_MC_ADVANCE_RIP();
    … …  
    90089008                IEM_MC_ASSIGN(u64Src, u64Imm);
    90099009                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    9010                 IEM_MC_FETCH_MEM_U64(u64Tmp, pIemCpu->iEffSeg, GCPtrEffDst);
     9010                IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    90119011                IEM_MC_REF_LOCAL(pu64Dst, u64Tmp);
    90129012                IEM_MC_REF_EFLAGS(pEFlags);
    90139013                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u64, pu64Dst, u64Src, pEFlags);
    9014                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp);
     9014                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp);
    90159015
    90169016                IEM_MC_ADVANCE_RIP();
    … …  
    90349034
    90359035    IEM_MC_BEGIN(0,0);
    9036     switch (pIemCpu->enmEffOpSize)
     9036    switch (pVCpu->iem.s.enmEffOpSize)
    90379037    {
    90389038        case IEMMODE_16BIT:
    … …  
    90609060    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_SF | X86_EFL_ZF | X86_EFL_AF | X86_EFL_PF);
    90619061
    9062     switch (pIemCpu->enmEffOpSize)
     9062    switch (pVCpu->iem.s.enmEffOpSize)
    90639063    {
    90649064        case IEMMODE_16BIT:
    … …  
    90759075                IEM_MC_LOCAL(uint16_t,      u16Tmp);
    90769076
    9077                 IEM_MC_FETCH_GREG_U16(u16Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     9077                IEM_MC_FETCH_GREG_U16(u16Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    90789078                IEM_MC_REF_LOCAL(pu16Dst, u16Tmp);
    90799079                IEM_MC_REF_EFLAGS(pEFlags);
    90809080                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u16, pu16Dst, u16Src, pEFlags);
    9081                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Tmp);
     9081                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Tmp);
    90829082
    90839083                IEM_MC_ADVANCE_RIP();
    … …  
    90989098                IEM_MC_ASSIGN(u16Src, u16Imm);
    90999099                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    9100                 IEM_MC_FETCH_MEM_U16(u16Tmp, pIemCpu->iEffSeg, GCPtrEffDst);
     9100                IEM_MC_FETCH_MEM_U16(u16Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    91019101                IEM_MC_REF_LOCAL(pu16Dst, u16Tmp);
    91029102                IEM_MC_REF_EFLAGS(pEFlags);
    91039103                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u16, pu16Dst, u16Src, pEFlags);
    9104                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Tmp);
     9104                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Tmp);
    91059105
    91069106                IEM_MC_ADVANCE_RIP();
    … …  
    91229122                IEM_MC_LOCAL(uint32_t,      u32Tmp);
    91239123
    9124                 IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     9124                IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    91259125                IEM_MC_REF_LOCAL(pu32Dst, u32Tmp);
    91269126                IEM_MC_REF_EFLAGS(pEFlags);
    91279127                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u32, pu32Dst, u32Src, pEFlags);
    9128                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp);
     9128                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp);
    91299129
    91309130                IEM_MC_ADVANCE_RIP();
    … …  
    91459145                IEM_MC_ASSIGN(u32Src, u32Imm);
    91469146                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    9147                 IEM_MC_FETCH_MEM_U32(u32Tmp, pIemCpu->iEffSeg, GCPtrEffDst);
     9147                IEM_MC_FETCH_MEM_U32(u32Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    91489148                IEM_MC_REF_LOCAL(pu32Dst, u32Tmp);
    91499149                IEM_MC_REF_EFLAGS(pEFlags);
    91509150                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u32, pu32Dst, u32Src, pEFlags);
    9151                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Tmp);
     9151                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp);
    91529152
    91539153                IEM_MC_ADVANCE_RIP();
    … …  
    91699169                IEM_MC_LOCAL(uint64_t,      u64Tmp);
    91709170
    9171                 IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     9171                IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    91729172                IEM_MC_REF_LOCAL(pu64Dst, u64Tmp);
    91739173                IEM_MC_REF_EFLAGS(pEFlags);
    91749174                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u64, pu64Dst, u64Src, pEFlags);
    9175                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp);
     9175                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp);
    91769176
    91779177                IEM_MC_ADVANCE_RIP();
    … …  
    91929192                IEM_MC_ASSIGN(u64Src, u64Imm);
    91939193                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    9194                 IEM_MC_FETCH_MEM_U64(u64Tmp, pIemCpu->iEffSeg, GCPtrEffDst);
     9194                IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    91959195                IEM_MC_REF_LOCAL(pu64Dst, u64Tmp);
    91969196                IEM_MC_REF_EFLAGS(pEFlags);
    91979197                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_imul_two_u64, pu64Dst, u64Src, pEFlags);
    9198                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Tmp);
     9198                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp);
    91999199
    92009200                IEM_MC_ADVANCE_RIP();
    … …  
    92129212    IEMOP_HLP_MIN_186();
    92139213    IEMOP_HLP_NO_LOCK_PREFIX();
    9214     if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     9214    if (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    92159215    {
    92169216        IEMOP_MNEMONIC("rep ins Yb,DX");
    9217         switch (pIemCpu->enmEffAddrMode)
     9217        switch (pVCpu->iem.s.enmEffAddrMode)
    92189218        {
    92199219            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_ins_op8_addr16, false);
    … …  
    92269226    {
    92279227        IEMOP_MNEMONIC("ins Yb,DX");
    9228         switch (pIemCpu->enmEffAddrMode)
     9228        switch (pVCpu->iem.s.enmEffAddrMode)
    92299229        {
    92309230            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_ins_op8_addr16, false);
    … …  
    92429242    IEMOP_HLP_MIN_186();
    92439243    IEMOP_HLP_NO_LOCK_PREFIX();
    9244     if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     9244    if (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    92459245    {
    92469246        IEMOP_MNEMONIC("rep ins Yv,DX");
    9247         switch (pIemCpu->enmEffOpSize)
     9247        switch (pVCpu->iem.s.enmEffOpSize)
    92489248        {
    92499249            case IEMMODE_16BIT:
    9250                 switch (pIemCpu->enmEffAddrMode)
     9250                switch (pVCpu->iem.s.enmEffAddrMode)
    92519251                {
    92529252                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_ins_op16_addr16, false);
    … …  
    92589258            case IEMMODE_64BIT:
    92599259            case IEMMODE_32BIT:
    9260                 switch (pIemCpu->enmEffAddrMode)
     9260                switch (pVCpu->iem.s.enmEffAddrMode)
    92619261                {
    92629262                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_ins_op32_addr16, false);
    … …  
    92729272    {
    92739273        IEMOP_MNEMONIC("ins Yv,DX");
    9274         switch (pIemCpu->enmEffOpSize)
     9274        switch (pVCpu->iem.s.enmEffOpSize)
    92759275        {
    92769276            case IEMMODE_16BIT:
    9277                 switch (pIemCpu->enmEffAddrMode)
     9277                switch (pVCpu->iem.s.enmEffAddrMode)
    92789278                {
    92799279                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_ins_op16_addr16, false);
    … …  
    92859285            case IEMMODE_64BIT:
    92869286            case IEMMODE_32BIT:
    9287                 switch (pIemCpu->enmEffAddrMode)
     9287                switch (pVCpu->iem.s.enmEffAddrMode)
    92889288                {
    92899289                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_ins_op32_addr16, false);
    … …  
    93049304    IEMOP_HLP_MIN_186();
    93059305    IEMOP_HLP_NO_LOCK_PREFIX();
    9306     if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     9306    if (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    93079307    {
    93089308        IEMOP_MNEMONIC("rep outs DX,Yb");
    9309         switch (pIemCpu->enmEffAddrMode)
     9309        switch (pVCpu->iem.s.enmEffAddrMode)
    93109310        {
    9311             case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op8_addr16, pIemCpu->iEffSeg, false);
    9312             case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op8_addr32, pIemCpu->iEffSeg, false);
    9313             case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op8_addr64, pIemCpu->iEffSeg, false);
     9311            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op8_addr16, pVCpu->iem.s.iEffSeg, false);
     9312            case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op8_addr32, pVCpu->iem.s.iEffSeg, false);
     9313            case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op8_addr64, pVCpu->iem.s.iEffSeg, false);
    93149314            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    93159315        }
    … …  
    93189318    {
    93199319        IEMOP_MNEMONIC("outs DX,Yb");
    9320         switch (pIemCpu->enmEffAddrMode)
     9320        switch (pVCpu->iem.s.enmEffAddrMode)
    93219321        {
    9322             case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op8_addr16, pIemCpu->iEffSeg, false);
    9323             case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op8_addr32, pIemCpu->iEffSeg, false);
    9324             case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op8_addr64, pIemCpu->iEffSeg, false);
     9322            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op8_addr16, pVCpu->iem.s.iEffSeg, false);
     9323            case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op8_addr32, pVCpu->iem.s.iEffSeg, false);
     9324            case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op8_addr64, pVCpu->iem.s.iEffSeg, false);
    93259325            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    93269326        }
    … …  
    93349334    IEMOP_HLP_MIN_186();
    93359335    IEMOP_HLP_NO_LOCK_PREFIX();
    9336     if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
     9336    if (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPZ | IEM_OP_PRF_REPNZ))
    93379337    {
    93389338        IEMOP_MNEMONIC("rep outs DX,Yv");
    9339         switch (pIemCpu->enmEffOpSize)
     9339        switch (pVCpu->iem.s.enmEffOpSize)
    93409340        {
    93419341            case IEMMODE_16BIT:
    9342                 switch (pIemCpu->enmEffAddrMode)
     9342                switch (pVCpu->iem.s.enmEffAddrMode)
    93439343                {
    9344                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op16_addr16, pIemCpu->iEffSeg, false);
    9345                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op16_addr32, pIemCpu->iEffSeg, false);
    9346                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op16_addr64, pIemCpu->iEffSeg, false);
     9344                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op16_addr16, pVCpu->iem.s.iEffSeg, false);
     9345                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op16_addr32, pVCpu->iem.s.iEffSeg, false);
     9346                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op16_addr64, pVCpu->iem.s.iEffSeg, false);
    93479347                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    93489348                }
    … …  
    93509350            case IEMMODE_64BIT:
    93519351            case IEMMODE_32BIT:
    9352                 switch (pIemCpu->enmEffAddrMode)
     9352                switch (pVCpu->iem.s.enmEffAddrMode)
    93539353                {
    9354                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op32_addr16, pIemCpu->iEffSeg, false);
    9355                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op32_addr32, pIemCpu->iEffSeg, false);
    9356                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op32_addr64, pIemCpu->iEffSeg, false);
     9354                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op32_addr16, pVCpu->iem.s.iEffSeg, false);
     9355                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op32_addr32, pVCpu->iem.s.iEffSeg, false);
     9356                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_rep_outs_op32_addr64, pVCpu->iem.s.iEffSeg, false);
    93579357                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    93589358                }
    … …  
    93649364    {
    93659365        IEMOP_MNEMONIC("outs DX,Yv");
    9366         switch (pIemCpu->enmEffOpSize)
     9366        switch (pVCpu->iem.s.enmEffOpSize)
    93679367        {
    93689368            case IEMMODE_16BIT:
    9369                 switch (pIemCpu->enmEffAddrMode)
     9369                switch (pVCpu->iem.s.enmEffAddrMode)
    93709370                {
    9371                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op16_addr16, pIemCpu->iEffSeg, false);
    9372                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op16_addr32, pIemCpu->iEffSeg, false);
    9373                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op16_addr64, pIemCpu->iEffSeg, false);
     9371                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op16_addr16, pVCpu->iem.s.iEffSeg, false);
     9372                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op16_addr32, pVCpu->iem.s.iEffSeg, false);
     9373                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op16_addr64, pVCpu->iem.s.iEffSeg, false);
    93749374                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    93759375                }
    … …  
    93779377            case IEMMODE_64BIT:
    93789378            case IEMMODE_32BIT:
    9379                 switch (pIemCpu->enmEffAddrMode)
     9379                switch (pVCpu->iem.s.enmEffAddrMode)
    93809380                {
    9381                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op32_addr16, pIemCpu->iEffSeg, false);
    9382                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op32_addr32, pIemCpu->iEffSeg, false);
    9383                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op32_addr64, pIemCpu->iEffSeg, false);
     9381                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op32_addr16, pVCpu->iem.s.iEffSeg, false);
     9382                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op32_addr32, pVCpu->iem.s.iEffSeg, false);
     9383                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_outs_op32_addr64, pVCpu->iem.s.iEffSeg, false);
    93849384                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    93859385                }
    … …  
    97119711        IEM_MC_ARG(uint32_t *,      pEFlags,                2);
    97129712
    9713         IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     9713        IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    97149714        IEM_MC_REF_EFLAGS(pEFlags);
    97159715        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, u8Src, pEFlags);
    … …  
    97389738        IEM_MC_ARG_CONST(uint8_t,   u8Src, /*=*/ u8Imm,     1);
    97399739
    9740         IEM_MC_MEM_MAP(pu8Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     9740        IEM_MC_MEM_MAP(pu8Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    97419741        IEM_MC_FETCH_EFLAGS(EFlags);
    9742         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     9742        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    97439743            IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, u8Src, pEFlags);
    97449744        else
    … …  
    97619761    PCIEMOPBINSIZES pImpl = g_apIemImplGrp1[(bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK];
    97629762
    9763     switch (pIemCpu->enmEffOpSize)
     9763    switch (pVCpu->iem.s.enmEffOpSize)
    97649764    {
    97659765        case IEMMODE_16BIT:
    … …  
    97759775                IEM_MC_ARG(uint32_t *,      pEFlags,                2);
    97769776
    9777                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     9777                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    97789778                IEM_MC_REF_EFLAGS(pEFlags);
    97799779                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    … …  
    98029802                uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm);
    98039803                IEM_MC_ASSIGN(u16Src, u16Imm);
    9804                 IEM_MC_MEM_MAP(pu16Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     9804                IEM_MC_MEM_MAP(pu16Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    98059805                IEM_MC_FETCH_EFLAGS(EFlags);
    9806                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     9806                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    98079807                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    98089808                else
    … …  
    98299829                IEM_MC_ARG(uint32_t *,      pEFlags,                2);
    98309830
    9831                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     9831                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    98329832                IEM_MC_REF_EFLAGS(pEFlags);
    98339833                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    … …  
    98579857                uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm);
    98589858                IEM_MC_ASSIGN(u32Src, u32Imm);
    9859                 IEM_MC_MEM_MAP(pu32Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     9859                IEM_MC_MEM_MAP(pu32Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    98609860                IEM_MC_FETCH_EFLAGS(EFlags);
    9861                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     9861                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    98629862                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    98639863                else
    … …  
    98849884                IEM_MC_ARG(uint32_t *,      pEFlags,                2);
    98859885
    9886                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     9886                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    98879887                IEM_MC_REF_EFLAGS(pEFlags);
    98889888                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    … …  
    99119911                uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm);
    99129912                IEM_MC_ASSIGN(u64Src, u64Imm);
    9913                 IEM_MC_MEM_MAP(pu64Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     9913                IEM_MC_MEM_MAP(pu64Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    99149914                IEM_MC_FETCH_EFLAGS(EFlags);
    9915                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     9915                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    99169916                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    99179917                else
    … …  
    99559955        IEMOP_HLP_NO_LOCK_PREFIX();
    99569956        uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    9957         switch (pIemCpu->enmEffOpSize)
     9957        switch (pVCpu->iem.s.enmEffOpSize)
    99589958        {
    99599959            case IEMMODE_16BIT:
    … …  
    99649964                IEM_MC_ARG(uint32_t *,      pEFlags,                    2);
    99659965
    9966                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     9966                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    99679967                IEM_MC_REF_EFLAGS(pEFlags);
    99689968                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    … …  
    99809980                IEM_MC_ARG(uint32_t *,      pEFlags,                    2);
    99819981
    9982                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     9982                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    99839983                IEM_MC_REF_EFLAGS(pEFlags);
    99849984                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    … …  
    99979997                IEM_MC_ARG(uint32_t *,      pEFlags,                    2);
    99989998
    9999                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     9999                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1000010000                IEM_MC_REF_EFLAGS(pEFlags);
    1000110001                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    … …  
    1002110021        }
    1002210022
    10023         switch (pIemCpu->enmEffOpSize)
     10023        switch (pVCpu->iem.s.enmEffOpSize)
    1002410024        {
    1002510025            case IEMMODE_16BIT:
    … …  
    1003410034                uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1003510035                IEM_MC_ASSIGN(u16Src, (int8_t)u8Imm);
    10036                 IEM_MC_MEM_MAP(pu16Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     10036                IEM_MC_MEM_MAP(pu16Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1003710037                IEM_MC_FETCH_EFLAGS(EFlags);
    10038                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     10038                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    1003910039                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, u16Src, pEFlags);
    1004010040                else
    … …  
    1005910059                uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1006010060                IEM_MC_ASSIGN(u32Src, (int8_t)u8Imm);
    10061                 IEM_MC_MEM_MAP(pu32Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     10061                IEM_MC_MEM_MAP(pu32Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1006210062                IEM_MC_FETCH_EFLAGS(EFlags);
    10063                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     10063                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    1006410064                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    1006510065                else
    … …  
    1008410084                uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1008510085                IEM_MC_ASSIGN(u64Src, (int8_t)u8Imm);
    10086                 IEM_MC_MEM_MAP(pu64Dst, fAccess, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     10086                IEM_MC_MEM_MAP(pu64Dst, fAccess, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1008710087                IEM_MC_FETCH_EFLAGS(EFlags);
    10088                 if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     10088                if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    1008910089                    IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, u64Src, pEFlags);
    1009010090                else
    … …  
    1014010140        IEM_MC_LOCAL(uint8_t, uTmp2);
    1014110141
    10142         IEM_MC_FETCH_GREG_U8(uTmp1, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10143         IEM_MC_FETCH_GREG_U8(uTmp2, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    10144         IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB,                              uTmp1);
    10145         IEM_MC_STORE_GREG_U8(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, uTmp2);
     10142        IEM_MC_FETCH_GREG_U8(uTmp1, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10143        IEM_MC_FETCH_GREG_U8(uTmp2, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     10144        IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,                              uTmp1);
     10145        IEM_MC_STORE_GREG_U8(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uTmp2);
    1014610146
    1014710147        IEM_MC_ADVANCE_RIP();
    … …  
    1016010160
    1016110161        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10162         IEM_MC_MEM_MAP(pu8Mem, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    10163         IEM_MC_REF_GREG_U8(pu8Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     10162        IEM_MC_MEM_MAP(pu8Mem, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     10163        IEM_MC_REF_GREG_U8(pu8Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    1016410164        IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_xchg_u8, pu8Mem, pu8Reg);
    1016510165        IEM_MC_MEM_COMMIT_AND_UNMAP(pu8Mem, IEM_ACCESS_DATA_RW);
    … …  
    1018510185        IEMOP_HLP_NO_LOCK_PREFIX();
    1018610186
    10187         switch (pIemCpu->enmEffOpSize)
     10187        switch (pVCpu->iem.s.enmEffOpSize)
    1018810188        {
    1018910189            case IEMMODE_16BIT:
    … …  
    1019210192                IEM_MC_LOCAL(uint16_t, uTmp2);
    1019310193
    10194                 IEM_MC_FETCH_GREG_U16(uTmp1, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10195                 IEM_MC_FETCH_GREG_U16(uTmp2, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    10196                 IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB,                              uTmp1);
    10197                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, uTmp2);
     10194                IEM_MC_FETCH_GREG_U16(uTmp1, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10195                IEM_MC_FETCH_GREG_U16(uTmp2, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     10196                IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,                              uTmp1);
     10197                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uTmp2);
    1019810198
    1019910199                IEM_MC_ADVANCE_RIP();
    … …  
    1020610206                IEM_MC_LOCAL(uint32_t, uTmp2);
    1020710207
    10208                 IEM_MC_FETCH_GREG_U32(uTmp1, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10209                 IEM_MC_FETCH_GREG_U32(uTmp2, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    10210                 IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB,                              uTmp1);
    10211                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, uTmp2);
     10208                IEM_MC_FETCH_GREG_U32(uTmp1, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10209                IEM_MC_FETCH_GREG_U32(uTmp2, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     10210                IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,                              uTmp1);
     10211                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uTmp2);
    1021210212
    1021310213                IEM_MC_ADVANCE_RIP();
    … …  
    1022010220                IEM_MC_LOCAL(uint64_t, uTmp2);
    1022110221
    10222                 IEM_MC_FETCH_GREG_U64(uTmp1, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10223                 IEM_MC_FETCH_GREG_U64(uTmp2, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    10224                 IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB,                              uTmp1);
    10225                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, uTmp2);
     10222                IEM_MC_FETCH_GREG_U64(uTmp1, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10223                IEM_MC_FETCH_GREG_U64(uTmp2, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     10224                IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,                              uTmp1);
     10225                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uTmp2);
    1022610226
    1022710227                IEM_MC_ADVANCE_RIP();
    … …  
    1023710237         * We're accessing memory.
    1023810238         */
    10239         switch (pIemCpu->enmEffOpSize)
     10239        switch (pVCpu->iem.s.enmEffOpSize)
    1024010240        {
    1024110241/** @todo the register must be committed separately! */
    … …  
    1024710247
    1024810248                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10249                 IEM_MC_MEM_MAP(pu16Mem, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    10250                 IEM_MC_REF_GREG_U16(pu16Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     10249                IEM_MC_MEM_MAP(pu16Mem, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     10250                IEM_MC_REF_GREG_U16(pu16Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    1025110251                IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_xchg_u16, pu16Mem, pu16Reg);
    1025210252                IEM_MC_MEM_COMMIT_AND_UNMAP(pu16Mem, IEM_ACCESS_DATA_RW);
    … …  
    1026310263
    1026410264                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10265                 IEM_MC_MEM_MAP(pu32Mem, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    10266                 IEM_MC_REF_GREG_U32(pu32Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     10265                IEM_MC_MEM_MAP(pu32Mem, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     10266                IEM_MC_REF_GREG_U32(pu32Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    1026710267                IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_xchg_u32, pu32Mem, pu32Reg);
    1026810268                IEM_MC_MEM_COMMIT_AND_UNMAP(pu32Mem, IEM_ACCESS_DATA_RW);
    … …  
    1028010280
    1028110281                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10282                 IEM_MC_MEM_MAP(pu64Mem, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
    10283                 IEM_MC_REF_GREG_U64(pu64Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
     10282                IEM_MC_MEM_MAP(pu64Mem, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
     10283                IEM_MC_REF_GREG_U64(pu64Reg, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    1028410284                IEM_MC_CALL_VOID_AIMPL_2(iemAImpl_xchg_u64, pu64Mem, pu64Reg);
    1028510285                IEM_MC_MEM_COMMIT_AND_UNMAP(pu64Mem, IEM_ACCESS_DATA_RW);
    … …  
    1031110311        IEM_MC_BEGIN(0, 1);
    1031210312        IEM_MC_LOCAL(uint8_t, u8Value);
    10313         IEM_MC_FETCH_GREG_U8(u8Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10314         IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u8Value);
     10313        IEM_MC_FETCH_GREG_U8(u8Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10314        IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u8Value);
    1031510315        IEM_MC_ADVANCE_RIP();
    1031610316        IEM_MC_END();
    … …  
    1032510325        IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    1032610326        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10327         IEM_MC_FETCH_GREG_U8(u8Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10328         IEM_MC_STORE_MEM_U8(pIemCpu->iEffSeg, GCPtrEffDst, u8Value);
     10327        IEM_MC_FETCH_GREG_U8(u8Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10328        IEM_MC_STORE_MEM_U8(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u8Value);
    1032910329        IEM_MC_ADVANCE_RIP();
    1033010330        IEM_MC_END();
    … …  
    1034810348    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    1034910349    {
    10350         switch (pIemCpu->enmEffOpSize)
     10350        switch (pVCpu->iem.s.enmEffOpSize)
    1035110351        {
    1035210352            case IEMMODE_16BIT:
    1035310353                IEM_MC_BEGIN(0, 1);
    1035410354                IEM_MC_LOCAL(uint16_t, u16Value);
    10355                 IEM_MC_FETCH_GREG_U16(u16Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10356                 IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u16Value);
     10355                IEM_MC_FETCH_GREG_U16(u16Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10356                IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u16Value);
    1035710357                IEM_MC_ADVANCE_RIP();
    1035810358                IEM_MC_END();
    … …  
    1036210362                IEM_MC_BEGIN(0, 1);
    1036310363                IEM_MC_LOCAL(uint32_t, u32Value);
    10364                 IEM_MC_FETCH_GREG_U32(u32Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10365                 IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u32Value);
     10364                IEM_MC_FETCH_GREG_U32(u32Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10365                IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u32Value);
    1036610366                IEM_MC_ADVANCE_RIP();
    1036710367                IEM_MC_END();
    … …  
    1037110371                IEM_MC_BEGIN(0, 1);
    1037210372                IEM_MC_LOCAL(uint64_t, u64Value);
    10373                 IEM_MC_FETCH_GREG_U64(u64Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10374                 IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u64Value);
     10373                IEM_MC_FETCH_GREG_U64(u64Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10374                IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u64Value);
    1037510375                IEM_MC_ADVANCE_RIP();
    1037610376                IEM_MC_END();
    … …  
    1038310383         * We're writing a register to memory.
    1038410384         */
    10385         switch (pIemCpu->enmEffOpSize)
     10385        switch (pVCpu->iem.s.enmEffOpSize)
    1038610386        {
    1038710387            case IEMMODE_16BIT:
    … …  
    1039010390                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    1039110391                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10392                 IEM_MC_FETCH_GREG_U16(u16Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10393                 IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Value);
     10392                IEM_MC_FETCH_GREG_U16(u16Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10393                IEM_MC_STORE_MEM_U16(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u16Value);
    1039410394                IEM_MC_ADVANCE_RIP();
    1039510395                IEM_MC_END();
    … …  
    1040110401                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    1040210402                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10403                 IEM_MC_FETCH_GREG_U32(u32Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10404                 IEM_MC_STORE_MEM_U32(pIemCpu->iEffSeg, GCPtrEffDst, u32Value);
     10403                IEM_MC_FETCH_GREG_U32(u32Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10404                IEM_MC_STORE_MEM_U32(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u32Value);
    1040510405                IEM_MC_ADVANCE_RIP();
    1040610406                IEM_MC_END();
    … …  
    1041210412                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    1041310413                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10414                 IEM_MC_FETCH_GREG_U64(u64Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg);
    10415                 IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffDst, u64Value);
     10414                IEM_MC_FETCH_GREG_U64(u64Value, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     10415                IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u64Value);
    1041610416                IEM_MC_ADVANCE_RIP();
    1041710417                IEM_MC_END();
    … …  
    1043810438        IEM_MC_BEGIN(0, 1);
    1043910439        IEM_MC_LOCAL(uint8_t, u8Value);
    10440         IEM_MC_FETCH_GREG_U8(u8Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    10441         IEM_MC_STORE_GREG_U8(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u8Value);
     10440        IEM_MC_FETCH_GREG_U8(u8Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     10441        IEM_MC_STORE_GREG_U8(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u8Value);
    1044210442        IEM_MC_ADVANCE_RIP();
    1044310443        IEM_MC_END();
    … …  
    1045210452        IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    1045310453        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10454         IEM_MC_FETCH_MEM_U8(u8Value, pIemCpu->iEffSeg, GCPtrEffDst);
    10455         IEM_MC_STORE_GREG_U8(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u8Value);
     10454        IEM_MC_FETCH_MEM_U8(u8Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     10455        IEM_MC_STORE_GREG_U8(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u8Value);
    1045610456        IEM_MC_ADVANCE_RIP();
    1045710457        IEM_MC_END();
    … …  
    1047410474    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    1047510475    {
    10476         switch (pIemCpu->enmEffOpSize)
     10476        switch (pVCpu->iem.s.enmEffOpSize)
    1047710477        {
    1047810478            case IEMMODE_16BIT:
    1047910479                IEM_MC_BEGIN(0, 1);
    1048010480                IEM_MC_LOCAL(uint16_t, u16Value);
    10481                 IEM_MC_FETCH_GREG_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    10482                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Value);
     10481                IEM_MC_FETCH_GREG_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     10482                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Value);
    1048310483                IEM_MC_ADVANCE_RIP();
    1048410484                IEM_MC_END();
    … …  
    1048810488                IEM_MC_BEGIN(0, 1);
    1048910489                IEM_MC_LOCAL(uint32_t, u32Value);
    10490                 IEM_MC_FETCH_GREG_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    10491                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     10490                IEM_MC_FETCH_GREG_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     10491                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Value);
    1049210492                IEM_MC_ADVANCE_RIP();
    1049310493                IEM_MC_END();
    … …  
    1049710497                IEM_MC_BEGIN(0, 1);
    1049810498                IEM_MC_LOCAL(uint64_t, u64Value);
    10499                 IEM_MC_FETCH_GREG_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    10500                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     10499                IEM_MC_FETCH_GREG_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     10500                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    1050110501                IEM_MC_ADVANCE_RIP();
    1050210502                IEM_MC_END();
    … …  
    1050910509         * We're loading a register from memory.
    1051010510         */
    10511         switch (pIemCpu->enmEffOpSize)
     10511        switch (pVCpu->iem.s.enmEffOpSize)
    1051210512        {
    1051310513            case IEMMODE_16BIT:
    … …  
    1051610516                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    1051710517                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10518                 IEM_MC_FETCH_MEM_U16(u16Value, pIemCpu->iEffSeg, GCPtrEffDst);
    10519                 IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Value);
     10518                IEM_MC_FETCH_MEM_U16(u16Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     10519                IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Value);
    1052010520                IEM_MC_ADVANCE_RIP();
    1052110521                IEM_MC_END();
    … …  
    1052710527                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    1052810528                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10529                 IEM_MC_FETCH_MEM_U32(u32Value, pIemCpu->iEffSeg, GCPtrEffDst);
    10530                 IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Value);
     10529                IEM_MC_FETCH_MEM_U32(u32Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     10530                IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Value);
    1053110531                IEM_MC_ADVANCE_RIP();
    1053210532                IEM_MC_END();
    … …  
    1053810538                IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    1053910539                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10540                 IEM_MC_FETCH_MEM_U64(u64Value, pIemCpu->iEffSeg, GCPtrEffDst);
    10541                 IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u64Value);
     10540                IEM_MC_FETCH_MEM_U64(u64Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
     10541                IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Value);
    1054210542                IEM_MC_ADVANCE_RIP();
    1054310543                IEM_MC_END();
    … …  
    1055210552FNIEMOP_DEF(iemOp_arpl_Ew_Gw_movsx_Gv_Ev)
    1055310553{
    10554     if (pIemCpu->enmCpuMode != IEMMODE_64BIT)
     10554    if (pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT)
    1055510555        return FNIEMOP_CALL(iemOp_arpl_Ew_Gw);
    10556     if (pIemCpu->enmEffOpSize != IEMMODE_64BIT)
     10556    if (pVCpu->iem.s.enmEffOpSize != IEMMODE_64BIT)
    1055710557        return FNIEMOP_CALL(iemOp_mov_Gv_Ev);
    1055810558    return FNIEMOP_CALL(iemOp_movsxd_Gv_Ev);
    … …  
    1058210582    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    1058310583    {
    10584         switch (pIemCpu->enmEffOpSize)
     10584        switch (pVCpu->iem.s.enmEffOpSize)
    1058510585        {
    1058610586            case IEMMODE_16BIT:
    … …  
    1058810588                IEM_MC_LOCAL(uint16_t, u16Value);
    1058910589                IEM_MC_FETCH_SREG_U16(u16Value, iSegReg);
    10590                 IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u16Value);
     10590                IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u16Value);
    1059110591                IEM_MC_ADVANCE_RIP();
    1059210592                IEM_MC_END();
    … …  
    1059710597                IEM_MC_LOCAL(uint32_t, u32Value);
    1059810598                IEM_MC_FETCH_SREG_ZX_U32(u32Value, iSegReg);
    10599                 IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u32Value);
     10599                IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u32Value);
    1060010600                IEM_MC_ADVANCE_RIP();
    1060110601                IEM_MC_END();
    … …  
    1060610606                IEM_MC_LOCAL(uint64_t, u64Value);
    1060710607                IEM_MC_FETCH_SREG_ZX_U64(u64Value, iSegReg);
    10608                 IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u64Value);
     10608                IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u64Value);
    1060910609                IEM_MC_ADVANCE_RIP();
    1061010610                IEM_MC_END();
    … …  
    1061910619         */
    1062010620#if 0 /* not necessary */
    10621         pIemCpu->enmEffOpSize = pIemCpu->enmDefOpSize = IEMMODE_16BIT;
     10621        pVCpu->iem.s.enmEffOpSize = pVCpu->iem.s.enmDefOpSize = IEMMODE_16BIT;
    1062210622#endif
    1062310623        IEM_MC_BEGIN(0, 2);
    … …  
    1062610626        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    1062710627        IEM_MC_FETCH_SREG_U16(u16Value, iSegReg);
    10628         IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Value);
     10628        IEM_MC_STORE_MEM_U16(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u16Value);
    1062910629        IEM_MC_ADVANCE_RIP();
    1063010630        IEM_MC_END();
    … …  
    1064510645        return IEMOP_RAISE_INVALID_OPCODE(); /* no register form */
    1064610646
    10647     switch (pIemCpu->enmEffOpSize)
     10647    switch (pVCpu->iem.s.enmEffOpSize)
    1064810648    {
    1064910649        case IEMMODE_16BIT:
    … …  
    1065310653            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    1065410654            IEM_MC_ASSIGN_TO_SMALLER(u16Cast, GCPtrEffSrc);
    10655             IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u16Cast);
     10655            IEM_MC_STORE_GREG_U16(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u16Cast);
    1065610656            IEM_MC_ADVANCE_RIP();
    1065710657            IEM_MC_END();
    … …  
    1066410664            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    1066510665            IEM_MC_ASSIGN_TO_SMALLER(u32Cast, GCPtrEffSrc);
    10666             IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, u32Cast);
     10666            IEM_MC_STORE_GREG_U32(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Cast);
    1066710667            IEM_MC_ADVANCE_RIP();
    1066810668            IEM_MC_END();
    … …  
    1067310673            IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    1067410674            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    10675             IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pIemCpu->uRexReg, GCPtrEffSrc);
     10675            IEM_MC_STORE_GREG_U64(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, GCPtrEffSrc);
    1067610676            IEM_MC_ADVANCE_RIP();
    1067710677            IEM_MC_END();
    … …  
    1069410694     */
    1069510695#if 0 /* not necessary */
    10696     pIemCpu->enmEffOpSize = pIemCpu->enmDefOpSize = IEMMODE_16BIT;
     10696    pVCpu->iem.s.enmEffOpSize = pVCpu->iem.s.enmDefOpSize = IEMMODE_16BIT;
    1069710697#endif
    1069810698
    … …  
    1071410714        IEM_MC_ARG_CONST(uint8_t, iSRegArg, iSegReg, 0);
    1071510715        IEM_MC_ARG(uint16_t,      u16Value,          1);
    10716         IEM_MC_FETCH_GREG_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     10716        IEM_MC_FETCH_GREG_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1071710717        IEM_MC_CALL_CIMPL_2(iemCImpl_load_SReg, iSRegArg, u16Value);
    1071810718        IEM_MC_END();
    … …  
    1072910729        IEM_MC_LOCAL(RTGCPTR, GCPtrEffDst);
    1073010730        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    10731         IEM_MC_FETCH_MEM_U16(u16Value, pIemCpu->iEffSeg, GCPtrEffDst);
     10731        IEM_MC_FETCH_MEM_U16(u16Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1073210732        IEM_MC_CALL_CIMPL_2(iemCImpl_load_SReg, iSRegArg, u16Value);
    1073310733        IEM_MC_END();
    … …  
    1075510755    /* Register access is relatively easy and can share code. */
    1075610756    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    10757         return FNIEMOP_CALL_1(iemOpCommonPopGReg, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     10757        return FNIEMOP_CALL_1(iemOpCommonPopGReg, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1075810758
    1075910759    /*
    … …  
    1077210772#ifndef TST_IEM_CHECK_MC
    1077310773    /* Calc effective address with modified ESP. */
    10774     uint8_t const   offOpcodeSaved = pIemCpu->offOpcode;
     10774    uint8_t const   offOpcodeSaved = pVCpu->iem.s.offOpcode;
    1077510775    RTGCPTR         GCPtrEff;
    1077610776    VBOXSTRICTRC    rcStrict;
    10777     rcStrict = iemOpHlpCalcRmEffAddr(pIemCpu, bRm, 0, &GCPtrEff);
     10777    rcStrict = iemOpHlpCalcRmEffAddr(pVCpu, bRm, 0, &GCPtrEff);
    1077810778    if (rcStrict != VINF_SUCCESS)
    1077910779        return rcStrict;
    10780     pIemCpu->offOpcode = offOpcodeSaved;
    10781 
    10782     PCPUMCTX        pCtx     = pIemCpu->CTX_SUFF(pCtx);
     10780    pVCpu->iem.s.offOpcode = offOpcodeSaved;
     10781
     10782    PCPUMCTX        pCtx     = pVCpu->iem.s.CTX_SUFF(pCtx);
    1078310783    uint64_t const  RspSaved = pCtx->rsp;
    10784     switch (pIemCpu->enmEffOpSize)
    10785     {
    10786         case IEMMODE_16BIT: iemRegAddToRsp(pIemCpu, pCtx, 2); break;
    10787         case IEMMODE_32BIT: iemRegAddToRsp(pIemCpu, pCtx, 4); break;
    10788         case IEMMODE_64BIT: iemRegAddToRsp(pIemCpu, pCtx, 8); break;
     10784    switch (pVCpu->iem.s.enmEffOpSize)
     10785    {
     10786        case IEMMODE_16BIT: iemRegAddToRsp(pVCpu, pCtx, 2); break;
     10787        case IEMMODE_32BIT: iemRegAddToRsp(pVCpu, pCtx, 4); break;
     10788        case IEMMODE_64BIT: iemRegAddToRsp(pVCpu, pCtx, 8); break;
    1078910789        IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1079010790    }
    10791     rcStrict = iemOpHlpCalcRmEffAddr(pIemCpu, bRm, 0, &GCPtrEff);
     10791    rcStrict = iemOpHlpCalcRmEffAddr(pVCpu, bRm, 0, &GCPtrEff);
    1079210792    Assert(rcStrict == VINF_SUCCESS);
    1079310793    pCtx->rsp = RspSaved;
    … …  
    1079610796    RTUINT64U TmpRsp;
    1079710797    TmpRsp.u = pCtx->rsp;
    10798     switch (pIemCpu->enmEffOpSize)
     10798    switch (pVCpu->iem.s.enmEffOpSize)
    1079910799    {
    1080010800        case IEMMODE_16BIT:
    1080110801        {
    1080210802            uint16_t u16Value;
    10803             rcStrict = iemMemStackPopU16Ex(pIemCpu, &u16Value, &TmpRsp);
     10803            rcStrict = iemMemStackPopU16Ex(pVCpu, &u16Value, &TmpRsp);
    1080410804            if (rcStrict == VINF_SUCCESS)
    10805                 rcStrict = iemMemStoreDataU16(pIemCpu, pIemCpu->iEffSeg, GCPtrEff, u16Value);
     10805                rcStrict = iemMemStoreDataU16(pVCpu, pVCpu->iem.s.iEffSeg, GCPtrEff, u16Value);
    1080610806            break;
    1080710807        }
    … …  
    1081010810        {
    1081110811            uint32_t u32Value;
    10812             rcStrict = iemMemStackPopU32Ex(pIemCpu, &u32Value, &TmpRsp);
     10812            rcStrict = iemMemStackPopU32Ex(pVCpu, &u32Value, &TmpRsp);
    1081310813            if (rcStrict == VINF_SUCCESS)
    10814                 rcStrict = iemMemStoreDataU32(pIemCpu, pIemCpu->iEffSeg, GCPtrEff, u32Value);
     10814                rcStrict = iemMemStoreDataU32(pVCpu, pVCpu->iem.s.iEffSeg, GCPtrEff, u32Value);
    1081510815            break;
    1081610816        }
    … …  
    1081910819        {
    1082010820            uint64_t u64Value;
    10821             rcStrict = iemMemStackPopU64Ex(pIemCpu, &u64Value, &TmpRsp);
     10821            rcStrict = iemMemStackPopU64Ex(pVCpu, &u64Value, &TmpRsp);
    1082210822            if (rcStrict == VINF_SUCCESS)
    10823                 rcStrict = iemMemStoreDataU64(pIemCpu, pIemCpu->iEffSeg, GCPtrEff, u64Value);
     10823                rcStrict = iemMemStoreDataU64(pVCpu, pVCpu->iem.s.iEffSeg, GCPtrEff, u64Value);
    1082410824            break;
    1082510825        }
    … …  
    1083010830    {
    1083110831        pCtx->rsp = TmpRsp.u;
    10832         iemRegUpdateRipAndClearRF(pIemCpu);
     10832        iemRegUpdateRipAndClearRF(pVCpu);
    1083310833    }
    1083410834    return rcStrict;
    … …  
    1086110861    IEMOP_HLP_NO_LOCK_PREFIX();
    1086210862
    10863     iReg |= pIemCpu->uRexB;
    10864     switch (pIemCpu->enmEffOpSize)
     10863    iReg |= pVCpu->iem.s.uRexB;
     10864    switch (pVCpu->iem.s.enmEffOpSize)
    1086510865    {
    1086610866        case IEMMODE_16BIT:
    … …  
    1090910909{
    1091010910    /* R8/R8D and RAX/EAX can be exchanged. */
    10911     if (pIemCpu->fPrefixes & IEM_OP_PRF_REX_B)
     10911    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REX_B)
    1091210912    {
    1091310913        IEMOP_MNEMONIC("xchg r8,rAX");
    … …  
    1091510915    }
    1091610916
    10917     if (pIemCpu->fPrefixes & IEM_OP_PRF_LOCK)
     10917    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK)
    1091810918        IEMOP_MNEMONIC("pause");
    1091910919    else
    … …  
    1098610986{
    1098710987    IEMOP_HLP_NO_LOCK_PREFIX();
    10988     switch (pIemCpu->enmEffOpSize)
     10988    switch (pVCpu->iem.s.enmEffOpSize)
    1098910989    {
    1099010990        case IEMMODE_16BIT:
    … …  
    1103311033{
    1103411034    IEMOP_HLP_NO_LOCK_PREFIX();
    11035     switch (pIemCpu->enmEffOpSize)
     11035    switch (pVCpu->iem.s.enmEffOpSize)
    1103611036    {
    1103711037        case IEMMODE_16BIT:
    … …  
    1108411084    /* Decode the far pointer address and pass it on to the far call C implementation. */
    1108511085    uint32_t offSeg;
    11086     if (pIemCpu->enmEffOpSize != IEMMODE_16BIT)
     11086    if (pVCpu->iem.s.enmEffOpSize != IEMMODE_16BIT)
    1108711087        IEM_OPCODE_GET_NEXT_U32(&offSeg);
    1108811088    else
    … …  
    1109011090    uint16_t uSel;  IEM_OPCODE_GET_NEXT_U16(&uSel);
    1109111091    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    11092     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_callf, uSel, offSeg, pIemCpu->enmEffOpSize);
     11092    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_callf, uSel, offSeg, pVCpu->iem.s.enmEffOpSize);
    1109311093}
    1109411094
    … …  
    1111411114    IEMOP_HLP_NO_LOCK_PREFIX();
    1111511115    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    11116     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_pushf, pIemCpu->enmEffOpSize);
     11116    return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_pushf, pVCpu->iem.s.enmEffOpSize);
    1111711117}
    1111811118
    … …  
    1112311123    IEMOP_HLP_NO_LOCK_PREFIX();
    1112411124    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    11125     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_popf, pIemCpu->enmEffOpSize);
     11125    return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_popf, pVCpu->iem.s.enmEffOpSize);
    1112611126}
    1112711127
    … …  
    1113211132    IEMOP_MNEMONIC("sahf");
    1113311133    IEMOP_HLP_NO_LOCK_PREFIX();
    11134     if (   pIemCpu->enmCpuMode == IEMMODE_64BIT
    11135         && !IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fLahfSahf)
     11134    if (   pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT
     11135        && !IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fLahfSahf)
    1113611136        return IEMOP_RAISE_INVALID_OPCODE();
    1113711137    IEM_MC_BEGIN(0, 2);
    … …  
    1115611156    IEMOP_MNEMONIC("lahf");
    1115711157    IEMOP_HLP_NO_LOCK_PREFIX();
    11158     if (   pIemCpu->enmCpuMode == IEMMODE_64BIT
    11159         && !IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fLahfSahf)
     11158    if (   pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT
     11159        && !IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fLahfSahf)
    1116011160        return IEMOP_RAISE_INVALID_OPCODE();
    1116111161    IEM_MC_BEGIN(0, 1);
    … …  
    1117811178    do \
    1117911179    { \
    11180         switch (pIemCpu->enmEffAddrMode) \
     11180        switch (pVCpu->iem.s.enmEffAddrMode) \
    1118111181        { \
    1118211182            case IEMMODE_16BIT: \
    … …  
    1120811208    IEM_MC_BEGIN(0,1);
    1120911209    IEM_MC_LOCAL(uint8_t, u8Tmp);
    11210     IEM_MC_FETCH_MEM_U8(u8Tmp, pIemCpu->iEffSeg, GCPtrMemOff);
     11210    IEM_MC_FETCH_MEM_U8(u8Tmp, pVCpu->iem.s.iEffSeg, GCPtrMemOff);
    1121111211    IEM_MC_STORE_GREG_U8(X86_GREG_xAX, u8Tmp);
    1121211212    IEM_MC_ADVANCE_RIP();
    … …  
    1122911229     * Fetch rAX.
    1123011230     */
    11231     switch (pIemCpu->enmEffOpSize)
     11231    switch (pVCpu->iem.s.enmEffOpSize)
    1123211232    {
    1123311233        case IEMMODE_16BIT:
    1123411234            IEM_MC_BEGIN(0,1);
    1123511235            IEM_MC_LOCAL(uint16_t, u16Tmp);
    11236             IEM_MC_FETCH_MEM_U16(u16Tmp, pIemCpu->iEffSeg, GCPtrMemOff);
     11236            IEM_MC_FETCH_MEM_U16(u16Tmp, pVCpu->iem.s.iEffSeg, GCPtrMemOff);
    1123711237            IEM_MC_STORE_GREG_U16(X86_GREG_xAX, u16Tmp);
    1123811238            IEM_MC_ADVANCE_RIP();
    … …  
    1124311243            IEM_MC_BEGIN(0,1);
    1124411244            IEM_MC_LOCAL(uint32_t, u32Tmp);
    11245             IEM_MC_FETCH_MEM_U32(u32Tmp, pIemCpu->iEffSeg, GCPtrMemOff);
     11245            IEM_MC_FETCH_MEM_U32(u32Tmp, pVCpu->iem.s.iEffSeg, GCPtrMemOff);
    1124611246            IEM_MC_STORE_GREG_U32(X86_GREG_xAX, u32Tmp);
    1124711247            IEM_MC_ADVANCE_RIP();
    … …  
    1125211252            IEM_MC_BEGIN(0,1);
    1125311253            IEM_MC_LOCAL(uint64_t, u64Tmp);
    11254             IEM_MC_FETCH_MEM_U64(u64Tmp, pIemCpu->iEffSeg, GCPtrMemOff);
     11254            IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrMemOff);
    1125511255            IEM_MC_STORE_GREG_U64(X86_GREG_xAX, u64Tmp);
    1125611256            IEM_MC_ADVANCE_RIP();
    … …  
    1127811278    IEM_MC_LOCAL(uint8_t, u8Tmp);
    1127911279    IEM_MC_FETCH_GREG_U8(u8Tmp, X86_GREG_xAX);
    11280     IEM_MC_STORE_MEM_U8(pIemCpu->iEffSeg, GCPtrMemOff, u8Tmp);
     11280    IEM_MC_STORE_MEM_U8(pVCpu->iem.s.iEffSeg, GCPtrMemOff, u8Tmp);
    1128111281    IEM_MC_ADVANCE_RIP();
    1128211282    IEM_MC_END();
    … …  
    1129711297     * Store rAX.
    1129811298     */
    11299     switch (pIemCpu->enmEffOpSize)
     11299    switch (pVCpu->iem.s.enmEffOpSize)
    1130011300    {
    1130111301        case IEMMODE_16BIT:
    … …  
    1130311303            IEM_MC_LOCAL(uint16_t, u16Tmp);
    1130411304            IEM_MC_FETCH_GREG_U16(u16Tmp, X86_GREG_xAX);
    11305             IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrMemOff, u16Tmp);
     11305            IEM_MC_STORE_MEM_U16(pVCpu->iem.s.iEffSeg, GCPtrMemOff, u16Tmp);
    1130611306            IEM_MC_ADVANCE_RIP();
    1130711307            IEM_MC_END();
    … …  
    1131211312            IEM_MC_LOCAL(uint32_t, u32Tmp);
    1131311313            IEM_MC_FETCH_GREG_U32(u32Tmp, X86_GREG_xAX);
    11314             IEM_MC_STORE_MEM_U32(pIemCpu->iEffSeg, GCPtrMemOff, u32Tmp);
     11314            IEM_MC_STORE_MEM_U32(pVCpu->iem.s.iEffSeg, GCPtrMemOff, u32Tmp);
    1131511315            IEM_MC_ADVANCE_RIP();
    1131611316            IEM_MC_END();
    … …  
    1132111321            IEM_MC_LOCAL(uint64_t, u64Tmp);
    1132211322            IEM_MC_FETCH_GREG_U64(u64Tmp, X86_GREG_xAX);
    11323             IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrMemOff, u64Tmp);
     11323            IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrMemOff, u64Tmp);
    1132411324            IEM_MC_ADVANCE_RIP();
    1132511325            IEM_MC_END();
    … …  
    1133611336        IEM_MC_LOCAL(RTGCPTR,           uAddr); \
    1133711337        IEM_MC_FETCH_GREG_U##AddrBits##_ZX_U64(uAddr, X86_GREG_xSI); \
    11338         IEM_MC_FETCH_MEM_U##ValBits(uValue, pIemCpu->iEffSeg, uAddr); \
     11338        IEM_MC_FETCH_MEM_U##ValBits(uValue, pVCpu->iem.s.iEffSeg, uAddr); \
    1133911339        IEM_MC_FETCH_GREG_U##AddrBits##_ZX_U64(uAddr, X86_GREG_xDI); \
    1134011340        IEM_MC_STORE_MEM_U##ValBits(X86_SREG_ES, uAddr, uValue); \
    … …  
    1135711357     * Use the C implementation if a repeat prefix is encountered.
    1135811358     */
    11359     if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     11359    if (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    1136011360    {
    1136111361        IEMOP_MNEMONIC("rep movsb Xb,Yb");
    11362         switch (pIemCpu->enmEffAddrMode)
     11362        switch (pVCpu->iem.s.enmEffAddrMode)
    1136311363        {
    11364             case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op8_addr16, pIemCpu->iEffSeg);
    11365             case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op8_addr32, pIemCpu->iEffSeg);
    11366             case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op8_addr64, pIemCpu->iEffSeg);
     11364            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op8_addr16, pVCpu->iem.s.iEffSeg);
     11365            case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op8_addr32, pVCpu->iem.s.iEffSeg);
     11366            case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op8_addr64, pVCpu->iem.s.iEffSeg);
    1136711367            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1136811368        }
    … …  
    1137311373     * Sharing case implementation with movs[wdq] below.
    1137411374     */
    11375     switch (pIemCpu->enmEffAddrMode)
     11375    switch (pVCpu->iem.s.enmEffAddrMode)
    1137611376    {
    1137711377        case IEMMODE_16BIT: IEM_MOVS_CASE(8, 16); break;
    … …  
    1139211392     * Use the C implementation if a repeat prefix is encountered.
    1139311393     */
    11394     if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     11394    if (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    1139511395    {
    1139611396        IEMOP_MNEMONIC("rep movs Xv,Yv");
    11397         switch (pIemCpu->enmEffOpSize)
     11397        switch (pVCpu->iem.s.enmEffOpSize)
    1139811398        {
    1139911399            case IEMMODE_16BIT:
    11400                 switch (pIemCpu->enmEffAddrMode)
     11400                switch (pVCpu->iem.s.enmEffAddrMode)
    1140111401                {
    11402                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op16_addr16, pIemCpu->iEffSeg);
    11403                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op16_addr32, pIemCpu->iEffSeg);
    11404                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op16_addr64, pIemCpu->iEffSeg);
     11402                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op16_addr16, pVCpu->iem.s.iEffSeg);
     11403                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op16_addr32, pVCpu->iem.s.iEffSeg);
     11404                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op16_addr64, pVCpu->iem.s.iEffSeg);
    1140511405                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1140611406                }
    1140711407                break;
    1140811408            case IEMMODE_32BIT:
    11409                 switch (pIemCpu->enmEffAddrMode)
     11409                switch (pVCpu->iem.s.enmEffAddrMode)
    1141011410                {
    11411                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op32_addr16, pIemCpu->iEffSeg);
    11412                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op32_addr32, pIemCpu->iEffSeg);
    11413                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op32_addr64, pIemCpu->iEffSeg);
     11411                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op32_addr16, pVCpu->iem.s.iEffSeg);
     11412                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op32_addr32, pVCpu->iem.s.iEffSeg);
     11413                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op32_addr64, pVCpu->iem.s.iEffSeg);
    1141411414                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1141511415                }
    1141611416            case IEMMODE_64BIT:
    11417                 switch (pIemCpu->enmEffAddrMode)
     11417                switch (pVCpu->iem.s.enmEffAddrMode)
    1141811418                {
    1141911419                    case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_6);
    11420                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op64_addr32, pIemCpu->iEffSeg);
    11421                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op64_addr64, pIemCpu->iEffSeg);
     11420                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op64_addr32, pVCpu->iem.s.iEffSeg);
     11421                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_rep_movs_op64_addr64, pVCpu->iem.s.iEffSeg);
    1142211422                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1142311423                }
    … …  
    1143111431     * Using ugly macro for implementing the cases, sharing it with movsb.
    1143211432     */
    11433     switch (pIemCpu->enmEffOpSize)
     11433    switch (pVCpu->iem.s.enmEffOpSize)
    1143411434    {
    1143511435        case IEMMODE_16BIT:
    11436             switch (pIemCpu->enmEffAddrMode)
     11436            switch (pVCpu->iem.s.enmEffAddrMode)
    1143711437            {
    1143811438                case IEMMODE_16BIT: IEM_MOVS_CASE(16, 16); break;
    … …  
    1144411444
    1144511445        case IEMMODE_32BIT:
    11446             switch (pIemCpu->enmEffAddrMode)
     11446            switch (pVCpu->iem.s.enmEffAddrMode)
    1144711447            {
    1144811448                case IEMMODE_16BIT: IEM_MOVS_CASE(32, 16); break;
    … …  
    1145411454
    1145511455        case IEMMODE_64BIT:
    11456             switch (pIemCpu->enmEffAddrMode)
     11456            switch (pVCpu->iem.s.enmEffAddrMode)
    1145711457            {
    1145811458                case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_1); /* cannot be encoded */ break;
    … …  
    1147911479        \
    1148011480        IEM_MC_FETCH_GREG_U##AddrBits##_ZX_U64(uAddr, X86_GREG_xSI); \
    11481         IEM_MC_FETCH_MEM_U##ValBits(uValue1, pIemCpu->iEffSeg, uAddr); \
     11481        IEM_MC_FETCH_MEM_U##ValBits(uValue1, pVCpu->iem.s.iEffSeg, uAddr); \
    1148211482        IEM_MC_FETCH_GREG_U##AddrBits##_ZX_U64(uAddr, X86_GREG_xDI); \
    1148311483        IEM_MC_FETCH_MEM_U##ValBits(uValue2, X86_SREG_ES, uAddr); \
    … …  
    1150411504     * Use the C implementation if a repeat prefix is encountered.
    1150511505     */
    11506     if (pIemCpu->fPrefixes & IEM_OP_PRF_REPZ)
     11506    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REPZ)
    1150711507    {
    1150811508        IEMOP_MNEMONIC("repe cmps Xb,Yb");
    11509         switch (pIemCpu->enmEffAddrMode)
     11509        switch (pVCpu->iem.s.enmEffAddrMode)
    1151011510        {
    11511             case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op8_addr16, pIemCpu->iEffSeg);
    11512             case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op8_addr32, pIemCpu->iEffSeg);
    11513             case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op8_addr64, pIemCpu->iEffSeg);
     11511            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op8_addr16, pVCpu->iem.s.iEffSeg);
     11512            case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op8_addr32, pVCpu->iem.s.iEffSeg);
     11513            case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op8_addr64, pVCpu->iem.s.iEffSeg);
    1151411514            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1151511515        }
    1151611516    }
    11517     if (pIemCpu->fPrefixes & IEM_OP_PRF_REPNZ)
     11517    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REPNZ)
    1151811518    {
    1151911519        IEMOP_MNEMONIC("repe cmps Xb,Yb");
    11520         switch (pIemCpu->enmEffAddrMode)
     11520        switch (pVCpu->iem.s.enmEffAddrMode)
    1152111521        {
    11522             case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op8_addr16, pIemCpu->iEffSeg);
    11523             case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op8_addr32, pIemCpu->iEffSeg);
    11524             case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op8_addr64, pIemCpu->iEffSeg);
     11522            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op8_addr16, pVCpu->iem.s.iEffSeg);
     11523            case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op8_addr32, pVCpu->iem.s.iEffSeg);
     11524            case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op8_addr64, pVCpu->iem.s.iEffSeg);
    1152511525            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1152611526        }
    … …  
    1153111531     * Sharing case implementation with cmps[wdq] below.
    1153211532     */
    11533     switch (pIemCpu->enmEffAddrMode)
     11533    switch (pVCpu->iem.s.enmEffAddrMode)
    1153411534    {
    1153511535        case IEMMODE_16BIT: IEM_CMPS_CASE(8, 16); break;
    … …  
    1155111551     * Use the C implementation if a repeat prefix is encountered.
    1155211552     */
    11553     if (pIemCpu->fPrefixes & IEM_OP_PRF_REPZ)
     11553    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REPZ)
    1155411554    {
    1155511555        IEMOP_MNEMONIC("repe cmps Xv,Yv");
    11556         switch (pIemCpu->enmEffOpSize)
     11556        switch (pVCpu->iem.s.enmEffOpSize)
    1155711557        {
    1155811558            case IEMMODE_16BIT:
    11559                 switch (pIemCpu->enmEffAddrMode)
     11559                switch (pVCpu->iem.s.enmEffAddrMode)
    1156011560                {
    11561                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op16_addr16, pIemCpu->iEffSeg);
    11562                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op16_addr32, pIemCpu->iEffSeg);
    11563                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op16_addr64, pIemCpu->iEffSeg);
     11561                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op16_addr16, pVCpu->iem.s.iEffSeg);
     11562                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op16_addr32, pVCpu->iem.s.iEffSeg);
     11563                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op16_addr64, pVCpu->iem.s.iEffSeg);
    1156411564                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1156511565                }
    1156611566                break;
    1156711567            case IEMMODE_32BIT:
    11568                 switch (pIemCpu->enmEffAddrMode)
     11568                switch (pVCpu->iem.s.enmEffAddrMode)
    1156911569                {
    11570                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op32_addr16, pIemCpu->iEffSeg);
    11571                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op32_addr32, pIemCpu->iEffSeg);
    11572                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op32_addr64, pIemCpu->iEffSeg);
     11570                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op32_addr16, pVCpu->iem.s.iEffSeg);
     11571                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op32_addr32, pVCpu->iem.s.iEffSeg);
     11572                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op32_addr64, pVCpu->iem.s.iEffSeg);
    1157311573                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1157411574                }
    1157511575            case IEMMODE_64BIT:
    11576                 switch (pIemCpu->enmEffAddrMode)
     11576                switch (pVCpu->iem.s.enmEffAddrMode)
    1157711577                {
    1157811578                    case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_4);
    11579                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op64_addr32, pIemCpu->iEffSeg);
    11580                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op64_addr64, pIemCpu->iEffSeg);
     11579                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op64_addr32, pVCpu->iem.s.iEffSeg);
     11580                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repe_cmps_op64_addr64, pVCpu->iem.s.iEffSeg);
    1158111581                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1158211582                }
    … …  
    1158511585    }
    1158611586
    11587     if (pIemCpu->fPrefixes & IEM_OP_PRF_REPNZ)
     11587    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REPNZ)
    1158811588    {
    1158911589        IEMOP_MNEMONIC("repne cmps Xv,Yv");
    11590         switch (pIemCpu->enmEffOpSize)
     11590        switch (pVCpu->iem.s.enmEffOpSize)
    1159111591        {
    1159211592            case IEMMODE_16BIT:
    11593                 switch (pIemCpu->enmEffAddrMode)
     11593                switch (pVCpu->iem.s.enmEffAddrMode)
    1159411594                {
    11595                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op16_addr16, pIemCpu->iEffSeg);
    11596                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op16_addr32, pIemCpu->iEffSeg);
    11597                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op16_addr64, pIemCpu->iEffSeg);
     11595                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op16_addr16, pVCpu->iem.s.iEffSeg);
     11596                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op16_addr32, pVCpu->iem.s.iEffSeg);
     11597                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op16_addr64, pVCpu->iem.s.iEffSeg);
    1159811598                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1159911599                }
    1160011600                break;
    1160111601            case IEMMODE_32BIT:
    11602                 switch (pIemCpu->enmEffAddrMode)
     11602                switch (pVCpu->iem.s.enmEffAddrMode)
    1160311603                {
    11604                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op32_addr16, pIemCpu->iEffSeg);
    11605                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op32_addr32, pIemCpu->iEffSeg);
    11606                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op32_addr64, pIemCpu->iEffSeg);
     11604                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op32_addr16, pVCpu->iem.s.iEffSeg);
     11605                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op32_addr32, pVCpu->iem.s.iEffSeg);
     11606                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op32_addr64, pVCpu->iem.s.iEffSeg);
    1160711607                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1160811608                }
    1160911609            case IEMMODE_64BIT:
    11610                 switch (pIemCpu->enmEffAddrMode)
     11610                switch (pVCpu->iem.s.enmEffAddrMode)
    1161111611                {
    1161211612                    case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_2);
    11613                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op64_addr32, pIemCpu->iEffSeg);
    11614                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op64_addr64, pIemCpu->iEffSeg);
     11613                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op64_addr32, pVCpu->iem.s.iEffSeg);
     11614                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_repne_cmps_op64_addr64, pVCpu->iem.s.iEffSeg);
    1161511615                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1161611616                }
    … …  
    1162511625     * Using ugly macro for implementing the cases, sharing it with cmpsb.
    1162611626     */
    11627     switch (pIemCpu->enmEffOpSize)
     11627    switch (pVCpu->iem.s.enmEffOpSize)
    1162811628    {
    1162911629        case IEMMODE_16BIT:
    11630             switch (pIemCpu->enmEffAddrMode)
     11630            switch (pVCpu->iem.s.enmEffAddrMode)
    1163111631            {
    1163211632                case IEMMODE_16BIT: IEM_CMPS_CASE(16, 16); break;
    … …  
    1163811638
    1163911639        case IEMMODE_32BIT:
    11640             switch (pIemCpu->enmEffAddrMode)
     11640            switch (pVCpu->iem.s.enmEffAddrMode)
    1164111641            {
    1164211642                case IEMMODE_16BIT: IEM_CMPS_CASE(32, 16); break;
    … …  
    1164811648
    1164911649        case IEMMODE_64BIT:
    11650             switch (pIemCpu->enmEffAddrMode)
     11650            switch (pVCpu->iem.s.enmEffAddrMode)
    1165111651            {
    1165211652                case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_1); /* cannot be encoded */ break;
    … …  
    1170611706     * Use the C implementation if a repeat prefix is encountered.
    1170711707     */
    11708     if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     11708    if (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    1170911709    {
    1171011710        IEMOP_MNEMONIC("rep stos Yb,al");
    11711         switch (pIemCpu->enmEffAddrMode)
     11711        switch (pVCpu->iem.s.enmEffAddrMode)
    1171211712        {
    1171311713            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_stos_al_m16);
    … …  
    1172211722     * Sharing case implementation with stos[wdq] below.
    1172311723     */
    11724     switch (pIemCpu->enmEffAddrMode)
     11724    switch (pVCpu->iem.s.enmEffAddrMode)
    1172511725    {
    1172611726        case IEMMODE_16BIT: IEM_STOS_CASE(8, 16); break;
    … …  
    1174111741     * Use the C implementation if a repeat prefix is encountered.
    1174211742     */
    11743     if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     11743    if (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    1174411744    {
    1174511745        IEMOP_MNEMONIC("rep stos Yv,rAX");
    11746         switch (pIemCpu->enmEffOpSize)
     11746        switch (pVCpu->iem.s.enmEffOpSize)
    1174711747        {
    1174811748            case IEMMODE_16BIT:
    11749                 switch (pIemCpu->enmEffAddrMode)
     11749                switch (pVCpu->iem.s.enmEffAddrMode)
    1175011750                {
    1175111751                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_stos_ax_m16);
    … …  
    1175611756                break;
    1175711757            case IEMMODE_32BIT:
    11758                 switch (pIemCpu->enmEffAddrMode)
     11758                switch (pVCpu->iem.s.enmEffAddrMode)
    1175911759                {
    1176011760                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_stos_eax_m16);
    … …  
    1176411764                }
    1176511765            case IEMMODE_64BIT:
    11766                 switch (pIemCpu->enmEffAddrMode)
     11766                switch (pVCpu->iem.s.enmEffAddrMode)
    1176711767                {
    1176811768                    case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_9);
    … …  
    1178011780     * Using ugly macro for implementing the cases, sharing it with stosb.
    1178111781     */
    11782     switch (pIemCpu->enmEffOpSize)
     11782    switch (pVCpu->iem.s.enmEffOpSize)
    1178311783    {
    1178411784        case IEMMODE_16BIT:
    11785             switch (pIemCpu->enmEffAddrMode)
     11785            switch (pVCpu->iem.s.enmEffAddrMode)
    1178611786            {
    1178711787                case IEMMODE_16BIT: IEM_STOS_CASE(16, 16); break;
    … …  
    1179311793
    1179411794        case IEMMODE_32BIT:
    11795             switch (pIemCpu->enmEffAddrMode)
     11795            switch (pVCpu->iem.s.enmEffAddrMode)
    1179611796            {
    1179711797                case IEMMODE_16BIT: IEM_STOS_CASE(32, 16); break;
    … …  
    1180311803
    1180411804        case IEMMODE_64BIT:
    11805             switch (pIemCpu->enmEffAddrMode)
     11805            switch (pVCpu->iem.s.enmEffAddrMode)
    1180611806            {
    1180711807                case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_1); /* cannot be encoded */ break;
    … …  
    1182411824        IEM_MC_LOCAL(RTGCPTR, uAddr); \
    1182511825        IEM_MC_FETCH_GREG_U##AddrBits##_ZX_U64(uAddr, X86_GREG_xSI); \
    11826         IEM_MC_FETCH_MEM_U##ValBits(uValue, pIemCpu->iEffSeg, uAddr); \
     11826        IEM_MC_FETCH_MEM_U##ValBits(uValue, pVCpu->iem.s.iEffSeg, uAddr); \
    1182711827        IEM_MC_STORE_GREG_U##ValBits(X86_GREG_xAX, uValue); \
    1182811828        IEM_MC_IF_EFL_BIT_SET(X86_EFL_DF) { \
    … …  
    1184211842     * Use the C implementation if a repeat prefix is encountered.
    1184311843     */
    11844     if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     11844    if (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    1184511845    {
    1184611846        IEMOP_MNEMONIC("rep lodsb al,Xb");
    11847         switch (pIemCpu->enmEffAddrMode)
     11847        switch (pVCpu->iem.s.enmEffAddrMode)
    1184811848        {
    11849             case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_al_m16, pIemCpu->iEffSeg);
    11850             case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_al_m32, pIemCpu->iEffSeg);
    11851             case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_al_m64, pIemCpu->iEffSeg);
     11849            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_al_m16, pVCpu->iem.s.iEffSeg);
     11850            case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_al_m32, pVCpu->iem.s.iEffSeg);
     11851            case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_al_m64, pVCpu->iem.s.iEffSeg);
    1185211852            IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1185311853        }
    … …  
    1185811858     * Sharing case implementation with stos[wdq] below.
    1185911859     */
    11860     switch (pIemCpu->enmEffAddrMode)
     11860    switch (pVCpu->iem.s.enmEffAddrMode)
    1186111861    {
    1186211862        case IEMMODE_16BIT: IEM_LODS_CASE(8, 16); break;
    … …  
    1187711877     * Use the C implementation if a repeat prefix is encountered.
    1187811878     */
    11879     if (pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
     11879    if (pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ))
    1188011880    {
    1188111881        IEMOP_MNEMONIC("rep lods rAX,Xv");
    11882         switch (pIemCpu->enmEffOpSize)
     11882        switch (pVCpu->iem.s.enmEffOpSize)
    1188311883        {
    1188411884            case IEMMODE_16BIT:
    11885                 switch (pIemCpu->enmEffAddrMode)
     11885                switch (pVCpu->iem.s.enmEffAddrMode)
    1188611886                {
    11887                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_ax_m16, pIemCpu->iEffSeg);
    11888                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_ax_m32, pIemCpu->iEffSeg);
    11889                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_ax_m64, pIemCpu->iEffSeg);
     11887                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_ax_m16, pVCpu->iem.s.iEffSeg);
     11888                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_ax_m32, pVCpu->iem.s.iEffSeg);
     11889                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_ax_m64, pVCpu->iem.s.iEffSeg);
    1189011890                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1189111891                }
    1189211892                break;
    1189311893            case IEMMODE_32BIT:
    11894                 switch (pIemCpu->enmEffAddrMode)
     11894                switch (pVCpu->iem.s.enmEffAddrMode)
    1189511895                {
    11896                     case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_eax_m16, pIemCpu->iEffSeg);
    11897                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_eax_m32, pIemCpu->iEffSeg);
    11898                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_eax_m64, pIemCpu->iEffSeg);
     11896                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_eax_m16, pVCpu->iem.s.iEffSeg);
     11897                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_eax_m32, pVCpu->iem.s.iEffSeg);
     11898                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_eax_m64, pVCpu->iem.s.iEffSeg);
    1189911899                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1190011900                }
    1190111901            case IEMMODE_64BIT:
    11902                 switch (pIemCpu->enmEffAddrMode)
     11902                switch (pVCpu->iem.s.enmEffAddrMode)
    1190311903                {
    1190411904                    case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_7);
    11905                     case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_rax_m32, pIemCpu->iEffSeg);
    11906                     case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_rax_m64, pIemCpu->iEffSeg);
     11905                    case IEMMODE_32BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_rax_m32, pVCpu->iem.s.iEffSeg);
     11906                    case IEMMODE_64BIT: return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_lods_rax_m64, pVCpu->iem.s.iEffSeg);
    1190711907                    IEM_NOT_REACHED_DEFAULT_CASE_RET();
    1190811908                }
    … …  
    1191611916     * Using ugly macro for implementing the cases, sharing it with lodsb.
    1191711917     */
    11918     switch (pIemCpu->enmEffOpSize)
     11918    switch (pVCpu->iem.s.enmEffOpSize)
    1191911919    {
    1192011920        case IEMMODE_16BIT:
    11921             switch (pIemCpu->enmEffAddrMode)
     11921            switch (pVCpu->iem.s.enmEffAddrMode)
    1192211922            {
    1192311923                case IEMMODE_16BIT: IEM_LODS_CASE(16, 16); break;
    … …  
    1192911929
    1193011930        case IEMMODE_32BIT:
    11931             switch (pIemCpu->enmEffAddrMode)
     11931            switch (pVCpu->iem.s.enmEffAddrMode)
    1193211932            {
    1193311933                case IEMMODE_16BIT: IEM_LODS_CASE(32, 16); break;
    … …  
    1193911939
    1194011940        case IEMMODE_64BIT:
    11941             switch (pIemCpu->enmEffAddrMode)
     11941            switch (pVCpu->iem.s.enmEffAddrMode)
    1194211942            {
    1194311943                case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_1); /* cannot be encoded */ break;
    … …  
    1198411984     * Use the C implementation if a repeat prefix is encountered.
    1198511985     */
    11986     if (pIemCpu->fPrefixes & IEM_OP_PRF_REPZ)
     11986    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REPZ)
    1198711987    {
    1198811988        IEMOP_MNEMONIC("repe scasb al,Xb");
    11989         switch (pIemCpu->enmEffAddrMode)
     11989        switch (pVCpu->iem.s.enmEffAddrMode)
    1199011990        {
    1199111991            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_repe_scas_al_m16);
    … …  
    1199511995        }
    1199611996    }
    11997     if (pIemCpu->fPrefixes & IEM_OP_PRF_REPNZ)
     11997    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REPNZ)
    1199811998    {
    1199911999        IEMOP_MNEMONIC("repne scasb al,Xb");
    12000         switch (pIemCpu->enmEffAddrMode)
     12000        switch (pVCpu->iem.s.enmEffAddrMode)
    1200112001        {
    1200212002            case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_repne_scas_al_m16);
    … …  
    1201112011     * Sharing case implementation with stos[wdq] below.
    1201212012     */
    12013     switch (pIemCpu->enmEffAddrMode)
     12013    switch (pVCpu->iem.s.enmEffAddrMode)
    1201412014    {
    1201512015        case IEMMODE_16BIT: IEM_SCAS_CASE(8, 16); break;
    … …  
    1203012030     * Use the C implementation if a repeat prefix is encountered.
    1203112031     */
    12032     if (pIemCpu->fPrefixes & IEM_OP_PRF_REPZ)
     12032    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REPZ)
    1203312033    {
    1203412034        IEMOP_MNEMONIC("repe scas rAX,Xv");
    12035         switch (pIemCpu->enmEffOpSize)
     12035        switch (pVCpu->iem.s.enmEffOpSize)
    1203612036        {
    1203712037            case IEMMODE_16BIT:
    12038                 switch (pIemCpu->enmEffAddrMode)
     12038                switch (pVCpu->iem.s.enmEffAddrMode)
    1203912039                {
    1204012040                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_repe_scas_ax_m16);
    … …  
    1204512045                break;
    1204612046            case IEMMODE_32BIT:
    12047                 switch (pIemCpu->enmEffAddrMode)
     12047                switch (pVCpu->iem.s.enmEffAddrMode)
    1204812048                {
    1204912049                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_repe_scas_eax_m16);
    … …  
    1205312053                }
    1205412054            case IEMMODE_64BIT:
    12055                 switch (pIemCpu->enmEffAddrMode)
     12055                switch (pVCpu->iem.s.enmEffAddrMode)
    1205612056                {
    1205712057                    case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_6); /** @todo It's this wrong, we can do 16-bit addressing in 64-bit mode, but not 32-bit. right? */
    … …  
    1206312063        }
    1206412064    }
    12065     if (pIemCpu->fPrefixes & IEM_OP_PRF_REPNZ)
     12065    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_REPNZ)
    1206612066    {
    1206712067        IEMOP_MNEMONIC("repne scas rAX,Xv");
    12068         switch (pIemCpu->enmEffOpSize)
     12068        switch (pVCpu->iem.s.enmEffOpSize)
    1206912069        {
    1207012070            case IEMMODE_16BIT:
    12071                 switch (pIemCpu->enmEffAddrMode)
     12071                switch (pVCpu->iem.s.enmEffAddrMode)
    1207212072                {
    1207312073                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_repne_scas_ax_m16);
    … …  
    1207812078                break;
    1207912079            case IEMMODE_32BIT:
    12080                 switch (pIemCpu->enmEffAddrMode)
     12080                switch (pVCpu->iem.s.enmEffAddrMode)
    1208112081                {
    1208212082                    case IEMMODE_16BIT: return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_repne_scas_eax_m16);
    … …  
    1208612086                }
    1208712087            case IEMMODE_64BIT:
    12088                 switch (pIemCpu->enmEffAddrMode)
     12088                switch (pVCpu->iem.s.enmEffAddrMode)
    1208912089                {
    1209012090                    case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_5);
    … …  
    1210212102     * Using ugly macro for implementing the cases, sharing it with scasb.
    1210312103     */
    12104     switch (pIemCpu->enmEffOpSize)
     12104    switch (pVCpu->iem.s.enmEffOpSize)
    1210512105    {
    1210612106        case IEMMODE_16BIT:
    12107             switch (pIemCpu->enmEffAddrMode)
     12107            switch (pVCpu->iem.s.enmEffAddrMode)
    1210812108            {
    1210912109                case IEMMODE_16BIT: IEM_SCAS_CASE(16, 16); break;
    … …  
    1211512115
    1211612116        case IEMMODE_32BIT:
    12117             switch (pIemCpu->enmEffAddrMode)
     12117            switch (pVCpu->iem.s.enmEffAddrMode)
    1211812118            {
    1211912119                case IEMMODE_16BIT: IEM_SCAS_CASE(32, 16); break;
    … …  
    1212512125
    1212612126        case IEMMODE_64BIT:
    12127             switch (pIemCpu->enmEffAddrMode)
     12127            switch (pVCpu->iem.s.enmEffAddrMode)
    1212812128            {
    1212912129                case IEMMODE_16BIT: AssertFailedReturn(VERR_IEM_IPE_1); /* cannot be encoded */ break;
    … …  
    1216212162{
    1216312163    IEMOP_MNEMONIC("mov AL,Ib");
    12164     return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xAX | pIemCpu->uRexB);
     12164    return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xAX | pVCpu->iem.s.uRexB);
    1216512165}
    1216612166
    … …  
    1217012170{
    1217112171    IEMOP_MNEMONIC("mov CL,Ib");
    12172     return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xCX | pIemCpu->uRexB);
     12172    return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xCX | pVCpu->iem.s.uRexB);
    1217312173}
    1217412174
    … …  
    1217812178{
    1217912179    IEMOP_MNEMONIC("mov DL,Ib");
    12180     return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xDX | pIemCpu->uRexB);
     12180    return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xDX | pVCpu->iem.s.uRexB);
    1218112181}
    1218212182
    … …  
    1218612186{
    1218712187    IEMOP_MNEMONIC("mov BL,Ib");
    12188     return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xBX | pIemCpu->uRexB);
     12188    return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xBX | pVCpu->iem.s.uRexB);
    1218912189}
    1219012190
    … …  
    1219412194{
    1219512195    IEMOP_MNEMONIC("mov AH,Ib");
    12196     return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xSP | pIemCpu->uRexB);
     12196    return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xSP | pVCpu->iem.s.uRexB);
    1219712197}
    1219812198
    … …  
    1220212202{
    1220312203    IEMOP_MNEMONIC("mov CH,Ib");
    12204     return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xBP | pIemCpu->uRexB);
     12204    return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xBP | pVCpu->iem.s.uRexB);
    1220512205}
    1220612206
    … …  
    1221012210{
    1221112211    IEMOP_MNEMONIC("mov DH,Ib");
    12212     return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xSI | pIemCpu->uRexB);
     12212    return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xSI | pVCpu->iem.s.uRexB);
    1221312213}
    1221412214
    … …  
    1221812218{
    1221912219    IEMOP_MNEMONIC("mov BH,Ib");
    12220     return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xDI | pIemCpu->uRexB);
     12220    return FNIEMOP_CALL_1(iemOpCommonMov_r8_Ib, X86_GREG_xDI | pVCpu->iem.s.uRexB);
    1222112221}
    1222212222
    … …  
    1222712227FNIEMOP_DEF_1(iemOpCommonMov_Rv_Iv, uint8_t, iReg)
    1222812228{
    12229     switch (pIemCpu->enmEffOpSize)
     12229    switch (pVCpu->iem.s.enmEffOpSize)
    1223012230    {
    1223112231        case IEMMODE_16BIT:
    … …  
    1227612276{
    1227712277    IEMOP_MNEMONIC("mov rAX,IV");
    12278     return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xAX | pIemCpu->uRexB);
     12278    return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xAX | pVCpu->iem.s.uRexB);
    1227912279}
    1228012280
    … …  
    1228412284{
    1228512285    IEMOP_MNEMONIC("mov rCX,IV");
    12286     return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xCX | pIemCpu->uRexB);
     12286    return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xCX | pVCpu->iem.s.uRexB);
    1228712287}
    1228812288
    … …  
    1229212292{
    1229312293    IEMOP_MNEMONIC("mov rDX,IV");
    12294     return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xDX | pIemCpu->uRexB);
     12294    return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xDX | pVCpu->iem.s.uRexB);
    1229512295}
    1229612296
    … …  
    1230012300{
    1230112301    IEMOP_MNEMONIC("mov rBX,IV");
    12302     return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xBX | pIemCpu->uRexB);
     12302    return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xBX | pVCpu->iem.s.uRexB);
    1230312303}
    1230412304
    … …  
    1230812308{
    1230912309    IEMOP_MNEMONIC("mov rSP,IV");
    12310     return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xSP | pIemCpu->uRexB);
     12310    return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xSP | pVCpu->iem.s.uRexB);
    1231112311}
    1231212312
    … …  
    1231612316{
    1231712317    IEMOP_MNEMONIC("mov rBP,IV");
    12318     return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xBP | pIemCpu->uRexB);
     12318    return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xBP | pVCpu->iem.s.uRexB);
    1231912319}
    1232012320
    … …  
    1232412324{
    1232512325    IEMOP_MNEMONIC("mov rSI,IV");
    12326     return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xSI | pIemCpu->uRexB);
     12326    return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xSI | pVCpu->iem.s.uRexB);
    1232712327}
    1232812328
    … …  
    1233212332{
    1233312333    IEMOP_MNEMONIC("mov rDI,IV");
    12334     return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xDI | pIemCpu->uRexB);
     12334    return FNIEMOP_CALL_1(iemOpCommonMov_Rv_Iv, X86_GREG_xDI | pVCpu->iem.s.uRexB);
    1233512335}
    1233612336
    … …  
    1236512365        IEM_MC_ARG_CONST(uint8_t,   cShiftArg, cShift, 1);
    1236612366        IEM_MC_ARG(uint32_t *,      pEFlags,           2);
    12367         IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     12367        IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1236812368        IEM_MC_REF_EFLAGS(pEFlags);
    1236912369        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    … …  
    1238412384        uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift);
    1238512385        IEM_MC_ASSIGN(cShiftArg, cShift);
    12386         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     12386        IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1238712387        IEM_MC_FETCH_EFLAGS(EFlags);
    1238812388        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    … …  
    1242212422        uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift);
    1242312423        IEMOP_HLP_NO_LOCK_PREFIX();
    12424         switch (pIemCpu->enmEffOpSize)
     12424        switch (pVCpu->iem.s.enmEffOpSize)
    1242512425        {
    1242612426            case IEMMODE_16BIT:
    … …  
    1242912429                IEM_MC_ARG_CONST(uint8_t,   cShiftArg, cShift, 1);
    1243012430                IEM_MC_ARG(uint32_t *,      pEFlags,           2);
    12431                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     12431                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1243212432                IEM_MC_REF_EFLAGS(pEFlags);
    1243312433                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, cShiftArg, pEFlags);
    … …  
    1244112441                IEM_MC_ARG_CONST(uint8_t,   cShiftArg, cShift, 1);
    1244212442                IEM_MC_ARG(uint32_t *,      pEFlags,           2);
    12443                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     12443                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1244412444                IEM_MC_REF_EFLAGS(pEFlags);
    1244512445                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, cShiftArg, pEFlags);
    … …  
    1245412454                IEM_MC_ARG_CONST(uint8_t,   cShiftArg, cShift, 1);
    1245512455                IEM_MC_ARG(uint32_t *,      pEFlags,           2);
    12456                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     12456                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1245712457                IEM_MC_REF_EFLAGS(pEFlags);
    1245812458                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, cShiftArg, pEFlags);
    … …  
    1246812468        /* memory */
    1246912469        IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */
    12470         switch (pIemCpu->enmEffOpSize)
     12470        switch (pVCpu->iem.s.enmEffOpSize)
    1247112471        {
    1247212472            case IEMMODE_16BIT:
    … …  
    1248012480                uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift);
    1248112481                IEM_MC_ASSIGN(cShiftArg, cShift);
    12482                 IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     12482                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1248312483                IEM_MC_FETCH_EFLAGS(EFlags);
    1248412484                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, cShiftArg, pEFlags);
    … …  
    1250012500                uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift);
    1250112501                IEM_MC_ASSIGN(cShiftArg, cShift);
    12502                 IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     12502                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1250312503                IEM_MC_FETCH_EFLAGS(EFlags);
    1250412504                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, cShiftArg, pEFlags);
    … …  
    1252012520                uint8_t cShift; IEM_OPCODE_GET_NEXT_U8(&cShift);
    1252112521                IEM_MC_ASSIGN(cShiftArg, cShift);
    12522                 IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     12522                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1252312523                IEM_MC_FETCH_EFLAGS(EFlags);
    1252412524                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, cShiftArg, pEFlags);
    … …  
    1254312543    IEMOP_HLP_NO_LOCK_PREFIX();
    1254412544    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    12545     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retn, pIemCpu->enmEffOpSize, u16Imm);
     12545    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retn, pVCpu->iem.s.enmEffOpSize, u16Imm);
    1254612546}
    1254712547
    … …  
    1255312553    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    1255412554    IEMOP_HLP_NO_LOCK_PREFIX();
    12555     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retn, pIemCpu->enmEffOpSize, 0);
     12555    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retn, pVCpu->iem.s.enmEffOpSize, 0);
    1255612556}
    1255712557
    … …  
    1256112561{
    1256212562    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    12563     if (   pIemCpu->enmCpuMode == IEMMODE_64BIT
     12563    if (   pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT
    1256412564        || (bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    1256512565    {
    … …  
    1258812588       outside of 64-bit mode.  VEX is not available in real or v86 mode. */
    1258912589    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    12590     if (pIemCpu->enmCpuMode != IEMMODE_64BIT)
     12590    if (pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT)
    1259112591    {
    1259212592        if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    … …  
    1260512605    uint8_t bOpcode; IEM_OPCODE_GET_NEXT_U8(&bOpcode);
    1260612606#if 0 /* will make sense of this next week... */
    12607     if (   !(pIemCpu->fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPZ | IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REX))
     12607    if (   !(pVCpu->iem.s.fPrefixes & (IEM_OP_PRF_REPNZ | IEM_OP_PRF_REPZ | IEM_OP_PRF_REPZ | IEM_OP_PRF_SIZE_OP | IEM_OP_PRF_REX))
    1260812608        &&
    1260912609        )
    … …  
    1263212632        uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1263312633        IEM_MC_BEGIN(0, 0);
    12634         IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u8Imm);
     12634        IEM_MC_STORE_GREG_U8((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u8Imm);
    1263512635        IEM_MC_ADVANCE_RIP();
    1263612636        IEM_MC_END();
    … …  
    1264312643        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 1);
    1264412644        uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    12645         IEM_MC_STORE_MEM_U8(pIemCpu->iEffSeg, GCPtrEffDst, u8Imm);
     12645        IEM_MC_STORE_MEM_U8(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u8Imm);
    1264612646        IEM_MC_ADVANCE_RIP();
    1264712647        IEM_MC_END();
    … …  
    1266312663    {
    1266412664        /* register access */
    12665         switch (pIemCpu->enmEffOpSize)
     12665        switch (pVCpu->iem.s.enmEffOpSize)
    1266612666        {
    1266712667            case IEMMODE_16BIT:
    1266812668                IEM_MC_BEGIN(0, 0);
    1266912669                uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm);
    12670                 IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u16Imm);
     12670                IEM_MC_STORE_GREG_U16((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u16Imm);
    1267112671                IEM_MC_ADVANCE_RIP();
    1267212672                IEM_MC_END();
    … …  
    1267612676                IEM_MC_BEGIN(0, 0);
    1267712677                uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm);
    12678                 IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u32Imm);
     12678                IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u32Imm);
    1267912679                IEM_MC_ADVANCE_RIP();
    1268012680                IEM_MC_END();
    … …  
    1268412684                IEM_MC_BEGIN(0, 0);
    1268512685                uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm);
    12686                 IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB, u64Imm);
     12686                IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u64Imm);
    1268712687                IEM_MC_ADVANCE_RIP();
    1268812688                IEM_MC_END();
    … …  
    1269512695    {
    1269612696        /* memory access. */
    12697         switch (pIemCpu->enmEffOpSize)
     12697        switch (pVCpu->iem.s.enmEffOpSize)
    1269812698        {
    1269912699            case IEMMODE_16BIT:
    … …  
    1270212702                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 2);
    1270312703                uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm);
    12704                 IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Imm);
     12704                IEM_MC_STORE_MEM_U16(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u16Imm);
    1270512705                IEM_MC_ADVANCE_RIP();
    1270612706                IEM_MC_END();
    … …  
    1271212712                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 4);
    1271312713                uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm);
    12714                 IEM_MC_STORE_MEM_U32(pIemCpu->iEffSeg, GCPtrEffDst, u32Imm);
     12714                IEM_MC_STORE_MEM_U32(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u32Imm);
    1271512715                IEM_MC_ADVANCE_RIP();
    1271612716                IEM_MC_END();
    … …  
    1272212722                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 4);
    1272312723                uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm);
    12724                 IEM_MC_STORE_MEM_U64(pIemCpu->iEffSeg, GCPtrEffDst, u64Imm);
     12724                IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u64Imm);
    1272512725                IEM_MC_ADVANCE_RIP();
    1272612726                IEM_MC_END();
    … …  
    1274412744    uint16_t cbFrame;        IEM_OPCODE_GET_NEXT_U16(&cbFrame);
    1274512745    uint8_t  u8NestingLevel; IEM_OPCODE_GET_NEXT_U8(&u8NestingLevel);
    12746     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_enter, pIemCpu->enmEffOpSize, cbFrame, u8NestingLevel);
     12746    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_enter, pVCpu->iem.s.enmEffOpSize, cbFrame, u8NestingLevel);
    1274712747}
    1274812748
    … …  
    1275512755    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    1275612756    IEMOP_HLP_NO_LOCK_PREFIX();
    12757     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_leave, pIemCpu->enmEffOpSize);
     12757    return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_leave, pVCpu->iem.s.enmEffOpSize);
    1275812758}
    1275912759
    … …  
    1276612766    IEMOP_HLP_NO_LOCK_PREFIX();
    1276712767    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    12768     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retf, pIemCpu->enmEffOpSize, u16Imm);
     12768    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retf, pVCpu->iem.s.enmEffOpSize, u16Imm);
    1276912769}
    1277012770
    … …  
    1277612776    IEMOP_HLP_NO_LOCK_PREFIX();
    1277712777    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    12778     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retf, pIemCpu->enmEffOpSize, 0);
     12778    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_retf, pVCpu->iem.s.enmEffOpSize, 0);
    1277912779}
    1278012780
    … …  
    1281712817    IEMOP_MNEMONIC("iret");
    1281812818    IEMOP_HLP_NO_LOCK_PREFIX();
    12819     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_iret, pIemCpu->enmEffOpSize);
     12819    return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_iret, pVCpu->iem.s.enmEffOpSize);
    1282012820}
    1282112821
    … …  
    1284812848        IEM_MC_ARG_CONST(uint8_t,   cShiftArg,/*=*/1,   1);
    1284912849        IEM_MC_ARG(uint32_t *,      pEFlags,            2);
    12850         IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     12850        IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1285112851        IEM_MC_REF_EFLAGS(pEFlags);
    1285212852        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    … …  
    1286512865
    1286612866        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    12867         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     12867        IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1286812868        IEM_MC_FETCH_EFLAGS(EFlags);
    1286912869        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    … …  
    1290212902        /* register */
    1290312903        IEMOP_HLP_NO_LOCK_PREFIX();
    12904         switch (pIemCpu->enmEffOpSize)
     12904        switch (pVCpu->iem.s.enmEffOpSize)
    1290512905        {
    1290612906            case IEMMODE_16BIT:
    … …  
    1290912909                IEM_MC_ARG_CONST(uint8_t,   cShiftArg,/*=1*/1, 1);
    1291012910                IEM_MC_ARG(uint32_t *,      pEFlags,           2);
    12911                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     12911                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1291212912                IEM_MC_REF_EFLAGS(pEFlags);
    1291312913                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, cShiftArg, pEFlags);
    … …  
    1292112921                IEM_MC_ARG_CONST(uint8_t,   cShiftArg,/*=1*/1, 1);
    1292212922                IEM_MC_ARG(uint32_t *,      pEFlags,           2);
    12923                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     12923                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1292412924                IEM_MC_REF_EFLAGS(pEFlags);
    1292512925                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, cShiftArg, pEFlags);
    … …  
    1293412934                IEM_MC_ARG_CONST(uint8_t,   cShiftArg,/*=1*/1, 1);
    1293512935                IEM_MC_ARG(uint32_t *,      pEFlags,           2);
    12936                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     12936                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1293712937                IEM_MC_REF_EFLAGS(pEFlags);
    1293812938                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, cShiftArg, pEFlags);
    … …  
    1294812948        /* memory */
    1294912949        IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */
    12950         switch (pIemCpu->enmEffOpSize)
     12950        switch (pVCpu->iem.s.enmEffOpSize)
    1295112951        {
    1295212952            case IEMMODE_16BIT:
    … …  
    1295812958
    1295912959                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    12960                 IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     12960                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1296112961                IEM_MC_FETCH_EFLAGS(EFlags);
    1296212962                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, cShiftArg, pEFlags);
    … …  
    1297612976
    1297712977                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    12978                 IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     12978                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1297912979                IEM_MC_FETCH_EFLAGS(EFlags);
    1298012980                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, cShiftArg, pEFlags);
    … …  
    1299412994
    1299512995                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    12996                 IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     12996                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1299712997                IEM_MC_FETCH_EFLAGS(EFlags);
    1299812998                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, cShiftArg, pEFlags);
    … …  
    1303713037        IEM_MC_ARG(uint8_t,     cShiftArg,  1);
    1303813038        IEM_MC_ARG(uint32_t *,  pEFlags,    2);
    13039         IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     13039        IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1304013040        IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    1304113041        IEM_MC_REF_EFLAGS(pEFlags);
    … …  
    1305613056        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    1305713057        IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    13058         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     13058        IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1305913059        IEM_MC_FETCH_EFLAGS(EFlags);
    1306013060        IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU8, pu8Dst, cShiftArg, pEFlags);
    … …  
    1309213092        /* register */
    1309313093        IEMOP_HLP_NO_LOCK_PREFIX();
    13094         switch (pIemCpu->enmEffOpSize)
     13094        switch (pVCpu->iem.s.enmEffOpSize)
    1309513095        {
    1309613096            case IEMMODE_16BIT:
    … …  
    1309913099                IEM_MC_ARG(uint8_t,         cShiftArg,  1);
    1310013100                IEM_MC_ARG(uint32_t *,      pEFlags,    2);
    13101                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     13101                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1310213102                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    1310313103                IEM_MC_REF_EFLAGS(pEFlags);
    … …  
    1311213112                IEM_MC_ARG(uint8_t,         cShiftArg,  1);
    1311313113                IEM_MC_ARG(uint32_t *,      pEFlags,    2);
    13114                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     13114                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1311513115                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    1311613116                IEM_MC_REF_EFLAGS(pEFlags);
    … …  
    1312613126                IEM_MC_ARG(uint8_t,         cShiftArg,  1);
    1312713127                IEM_MC_ARG(uint32_t *,      pEFlags,    2);
    13128                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     13128                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1312913129                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    1313013130                IEM_MC_REF_EFLAGS(pEFlags);
    … …  
    1314113141        /* memory */
    1314213142        IEMOP_HLP_NO_LOCK_PREFIX(); /** @todo should probably not be raised until we've fetched all the opcode bytes? */
    13143         switch (pIemCpu->enmEffOpSize)
     13143        switch (pVCpu->iem.s.enmEffOpSize)
    1314413144        {
    1314513145            case IEMMODE_16BIT:
    … …  
    1315213152                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    1315313153                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    13154                 IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     13154                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1315513155                IEM_MC_FETCH_EFLAGS(EFlags);
    1315613156                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU16, pu16Dst, cShiftArg, pEFlags);
    … …  
    1317113171                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    1317213172                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    13173                 IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     13173                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1317413174                IEM_MC_FETCH_EFLAGS(EFlags);
    1317513175                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, cShiftArg, pEFlags);
    … …  
    1319013190                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    1319113191                IEM_MC_FETCH_GREG_U8(cShiftArg, X86_GREG_xCX);
    13192                 IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     13192                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1319313193                IEM_MC_FETCH_EFLAGS(EFlags);
    1319413194                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU64, pu64Dst, cShiftArg, pEFlags);
    … …  
    1325513255    IEMOP_MNEMONIC("xlat");
    1325613256    IEMOP_HLP_NO_LOCK_PREFIX();
    13257     switch (pIemCpu->enmEffAddrMode)
     13257    switch (pVCpu->iem.s.enmEffAddrMode)
    1325813258    {
    1325913259        case IEMMODE_16BIT:
    … …  
    1326313263            IEM_MC_FETCH_GREG_U8_ZX_U16(u16Addr, X86_GREG_xAX);
    1326413264            IEM_MC_ADD_GREG_U16_TO_LOCAL(u16Addr, X86_GREG_xBX);
    13265             IEM_MC_FETCH_MEM16_U8(u8Tmp, pIemCpu->iEffSeg, u16Addr);
     13265            IEM_MC_FETCH_MEM16_U8(u8Tmp, pVCpu->iem.s.iEffSeg, u16Addr);
    1326613266            IEM_MC_STORE_GREG_U8(X86_GREG_xAX, u8Tmp);
    1326713267            IEM_MC_ADVANCE_RIP();
    … …  
    1327513275            IEM_MC_FETCH_GREG_U8_ZX_U32(u32Addr, X86_GREG_xAX);
    1327613276            IEM_MC_ADD_GREG_U32_TO_LOCAL(u32Addr, X86_GREG_xBX);
    13277             IEM_MC_FETCH_MEM32_U8(u8Tmp, pIemCpu->iEffSeg, u32Addr);
     13277            IEM_MC_FETCH_MEM32_U8(u8Tmp, pVCpu->iem.s.iEffSeg, u32Addr);
    1327813278            IEM_MC_STORE_GREG_U8(X86_GREG_xAX, u8Tmp);
    1327913279            IEM_MC_ADVANCE_RIP();
    … …  
    1328713287            IEM_MC_FETCH_GREG_U8_ZX_U64(u64Addr, X86_GREG_xAX);
    1328813288            IEM_MC_ADD_GREG_U64_TO_LOCAL(u64Addr, X86_GREG_xBX);
    13289             IEM_MC_FETCH_MEM_U8(u8Tmp, pIemCpu->iEffSeg, u64Addr);
     13289            IEM_MC_FETCH_MEM_U8(u8Tmp, pVCpu->iem.s.iEffSeg, u64Addr);
    1329013290            IEM_MC_STORE_GREG_U8(X86_GREG_xAX, u8Tmp);
    1329113291            IEM_MC_ADVANCE_RIP();
    … …  
    1347913479    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1348013480    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    13481     IEM_MC_FETCH_MEM_R32(r32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     13481    IEM_MC_FETCH_MEM_R32(r32Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1348213482
    1348313483    IEM_MC_PREPARE_FPU_USAGE();
    … …  
    1352913529    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1353013530    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    13531     IEM_MC_FETCH_MEM_R32(r32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     13531    IEM_MC_FETCH_MEM_R32(r32Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1353213532
    1353313533    IEM_MC_PREPARE_FPU_USAGE();
    1353413534    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1353513535        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r32, pu16Fsw, pr80Value1, pr32Val2);
    13536         IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffSrc);
     13536        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1353713537    IEM_MC_ELSE()
    13538         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
     13538        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1353913539    IEM_MC_ENDIF();
    1354013540    IEM_MC_ADVANCE_RIP();
    … …  
    1356313563    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1356413564    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    13565     IEM_MC_FETCH_MEM_R32(r32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     13565    IEM_MC_FETCH_MEM_R32(r32Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1356613566
    1356713567    IEM_MC_PREPARE_FPU_USAGE();
    1356813568    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1356913569        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r32, pu16Fsw, pr80Value1, pr32Val2);
    13570         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffSrc);
     13570        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1357113571    IEM_MC_ELSE()
    13572         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
     13572        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1357313573    IEM_MC_ENDIF();
    1357413574    IEM_MC_ADVANCE_RIP();
    … …  
    1361413614FNIEMOP_DEF(iemOp_EscF0)
    1361513615{
    13616     pIemCpu->offFpuOpcode = pIemCpu->offOpcode - 1;
     13616    pVCpu->iem.s.offFpuOpcode = pVCpu->iem.s.offOpcode - 1;
    1361713617    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    1361813618
    … …  
    1366813668    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1366913669    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    13670     IEM_MC_FETCH_MEM_R32(r32Val, pIemCpu->iEffSeg, GCPtrEffSrc);
     13670    IEM_MC_FETCH_MEM_R32(r32Val, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1367113671
    1367213672    IEM_MC_PREPARE_FPU_USAGE();
    1367313673    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1367413674        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r32_to_r80, pFpuRes, pr32Val);
    13675         IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pIemCpu->iEffSeg, GCPtrEffSrc);
     13675        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1367613676    IEM_MC_ELSE()
    13677         IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
     13677        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1367813678    IEM_MC_ENDIF();
    1367913679    IEM_MC_ADVANCE_RIP();
    … …  
    1370013700    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1370113701
    13702     IEM_MC_MEM_MAP(pr32Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     13702    IEM_MC_MEM_MAP(pr32Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1370313703    IEM_MC_PREPARE_FPU_USAGE();
    1370413704    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1370513705        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r32, pu16Fsw, pr32Dst, pr80Value);
    1370613706        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pr32Dst, IEM_ACCESS_DATA_W, u16Fsw);
    13707         IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     13707        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1370813708    IEM_MC_ELSE()
    1370913709        IEM_MC_IF_FCW_IM()
    … …  
    1371113711            IEM_MC_MEM_COMMIT_AND_UNMAP(pr32Dst, IEM_ACCESS_DATA_W);
    1371213712        IEM_MC_ENDIF();
    13713         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     13713        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1371413714    IEM_MC_ENDIF();
    1371513715    IEM_MC_ADVANCE_RIP();
    … …  
    1373613736    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1373713737
    13738     IEM_MC_MEM_MAP(pr32Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     13738    IEM_MC_MEM_MAP(pr32Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1373913739    IEM_MC_PREPARE_FPU_USAGE();
    1374013740    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1374113741        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r32, pu16Fsw, pr32Dst, pr80Value);
    1374213742        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pr32Dst, IEM_ACCESS_DATA_W, u16Fsw);
    13743         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     13743        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1374413744    IEM_MC_ELSE()
    1374513745        IEM_MC_IF_FCW_IM()
    … …  
    1374713747            IEM_MC_MEM_COMMIT_AND_UNMAP(pr32Dst, IEM_ACCESS_DATA_W);
    1374813748        IEM_MC_ENDIF();
    13749         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     13749        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1375013750    IEM_MC_ENDIF();
    1375113751    IEM_MC_ADVANCE_RIP();
    … …  
    1376113761    IEMOP_MNEMONIC("fldenv m14/28byte");
    1376213762    IEM_MC_BEGIN(3, 0);
    13763     IEM_MC_ARG_CONST(IEMMODE,           enmEffOpSize, /*=*/ pIemCpu->enmEffOpSize,  0);
     13763    IEM_MC_ARG_CONST(IEMMODE,           enmEffOpSize, /*=*/ pVCpu->iem.s.enmEffOpSize,  0);
    1376413764    IEM_MC_ARG(uint8_t,                 iEffSeg,                                    1);
    1376513765    IEM_MC_ARG(RTGCPTR,                 GCPtrEffSrc,                                2);
    … …  
    1376813768    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1376913769    IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    13770     IEM_MC_ASSIGN(iEffSeg, pIemCpu->iEffSeg);
     13770    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
    1377113771    IEM_MC_CALL_CIMPL_3(iemCImpl_fldenv, enmEffOpSize, iEffSeg, GCPtrEffSrc);
    1377213772    IEM_MC_END();
    … …  
    1378613786    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1378713787    IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    13788     IEM_MC_FETCH_MEM_U16(u16Fsw, pIemCpu->iEffSeg, GCPtrEffSrc);
     13788    IEM_MC_FETCH_MEM_U16(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1378913789    IEM_MC_CALL_CIMPL_1(iemCImpl_fldcw, u16Fsw);
    1379013790    IEM_MC_END();
    … …  
    1379813798    IEMOP_MNEMONIC("fstenv m14/m28byte");
    1379913799    IEM_MC_BEGIN(3, 0);
    13800     IEM_MC_ARG_CONST(IEMMODE,           enmEffOpSize, /*=*/ pIemCpu->enmEffOpSize,  0);
     13800    IEM_MC_ARG_CONST(IEMMODE,           enmEffOpSize, /*=*/ pVCpu->iem.s.enmEffOpSize,  0);
    1380113801    IEM_MC_ARG(uint8_t,                 iEffSeg,                                    1);
    1380213802    IEM_MC_ARG(RTGCPTR,                 GCPtrEffDst,                                2);
    … …  
    1380513805    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1380613806    IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    13807     IEM_MC_ASSIGN(iEffSeg, pIemCpu->iEffSeg);
     13807    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
    1380813808    IEM_MC_CALL_CIMPL_3(iemCImpl_fnstenv, enmEffOpSize, iEffSeg, GCPtrEffDst);
    1380913809    IEM_MC_END();
    … …  
    1382413824    IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    1382513825    IEM_MC_FETCH_FCW(u16Fcw);
    13826     IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Fcw);
     13826    IEM_MC_STORE_MEM_U16(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u16Fcw);
    1382713827    IEM_MC_ADVANCE_RIP(); /* C0-C3 are documented as undefined, we leave them unmodified. */
    1382813828    IEM_MC_END();
    … …  
    1440014400FNIEMOP_DEF(iemOp_EscF1)
    1440114401{
    14402     pIemCpu->offFpuOpcode = pIemCpu->offOpcode - 1;
     14402    pVCpu->iem.s.offFpuOpcode = pVCpu->iem.s.offOpcode - 1;
    1440314403    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    1440414404    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    1461414614    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1461514615    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    14616     IEM_MC_FETCH_MEM_I32(i32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     14616    IEM_MC_FETCH_MEM_I32(i32Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1461714617
    1461814618    IEM_MC_PREPARE_FPU_USAGE();
    … …  
    1466414664    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1466514665    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    14666     IEM_MC_FETCH_MEM_I32(i32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     14666    IEM_MC_FETCH_MEM_I32(i32Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1466714667
    1466814668    IEM_MC_PREPARE_FPU_USAGE();
    1466914669    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1467014670        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i32, pu16Fsw, pr80Value1, pi32Val2);
    14671         IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffSrc);
     14671        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1467214672    IEM_MC_ELSE()
    14673         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
     14673        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1467414674    IEM_MC_ENDIF();
    1467514675    IEM_MC_ADVANCE_RIP();
    … …  
    1469814698    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1469914699    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    14700     IEM_MC_FETCH_MEM_I32(i32Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     14700    IEM_MC_FETCH_MEM_I32(i32Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1470114701
    1470214702    IEM_MC_PREPARE_FPU_USAGE();
    1470314703    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1470414704        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i32, pu16Fsw, pr80Value1, pi32Val2);
    14705         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffSrc);
     14705        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1470614706    IEM_MC_ELSE()
    14707         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
     14707        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1470814708    IEM_MC_ENDIF();
    1470914709    IEM_MC_ADVANCE_RIP();
    … …  
    1474914749FNIEMOP_DEF(iemOp_EscF2)
    1475014750{
    14751     pIemCpu->offFpuOpcode = pIemCpu->offOpcode - 1;
     14751    pVCpu->iem.s.offFpuOpcode = pVCpu->iem.s.offOpcode - 1;
    1475214752    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    1475314753    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    1480414804    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1480514805    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    14806     IEM_MC_FETCH_MEM_I32(i32Val, pIemCpu->iEffSeg, GCPtrEffSrc);
     14806    IEM_MC_FETCH_MEM_I32(i32Val, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1480714807
    1480814808    IEM_MC_PREPARE_FPU_USAGE();
    1480914809    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1481014810        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fild_i32_to_r80, pFpuRes, pi32Val);
    14811         IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pIemCpu->iEffSeg, GCPtrEffSrc);
     14811        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1481214812    IEM_MC_ELSE()
    14813         IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
     14813        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1481414814    IEM_MC_ENDIF();
    1481514815    IEM_MC_ADVANCE_RIP();
    … …  
    1483614836    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1483714837
    14838     IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     14838    IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1483914839    IEM_MC_PREPARE_FPU_USAGE();
    1484014840    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1484114841        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fistt_r80_to_i32, pu16Fsw, pi32Dst, pr80Value);
    1484214842        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi32Dst, IEM_ACCESS_DATA_W, u16Fsw);
    14843         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     14843        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1484414844    IEM_MC_ELSE()
    1484514845        IEM_MC_IF_FCW_IM()
    … …  
    1484714847            IEM_MC_MEM_COMMIT_AND_UNMAP(pi32Dst, IEM_ACCESS_DATA_W);
    1484814848        IEM_MC_ENDIF();
    14849         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     14849        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1485014850    IEM_MC_ENDIF();
    1485114851    IEM_MC_ADVANCE_RIP();
    … …  
    1487214872    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1487314873
    14874     IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     14874    IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1487514875    IEM_MC_PREPARE_FPU_USAGE();
    1487614876    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1487714877        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i32, pu16Fsw, pi32Dst, pr80Value);
    1487814878        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi32Dst, IEM_ACCESS_DATA_W, u16Fsw);
    14879         IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     14879        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1488014880    IEM_MC_ELSE()
    1488114881        IEM_MC_IF_FCW_IM()
    … …  
    1488314883            IEM_MC_MEM_COMMIT_AND_UNMAP(pi32Dst, IEM_ACCESS_DATA_W);
    1488414884        IEM_MC_ENDIF();
    14885         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     14885        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1488614886    IEM_MC_ENDIF();
    1488714887    IEM_MC_ADVANCE_RIP();
    … …  
    1490814908    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1490914909
    14910     IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     14910    IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1491114911    IEM_MC_PREPARE_FPU_USAGE();
    1491214912    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1491314913        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i32, pu16Fsw, pi32Dst, pr80Value);
    1491414914        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi32Dst, IEM_ACCESS_DATA_W, u16Fsw);
    14915         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     14915        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1491614916    IEM_MC_ELSE()
    1491714917        IEM_MC_IF_FCW_IM()
    … …  
    1491914919            IEM_MC_MEM_COMMIT_AND_UNMAP(pi32Dst, IEM_ACCESS_DATA_W);
    1492014920        IEM_MC_ENDIF();
    14921         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     14921        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1492214922    IEM_MC_ENDIF();
    1492314923    IEM_MC_ADVANCE_RIP();
    … …  
    1494514945    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1494614946    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    14947     IEM_MC_FETCH_MEM_R80(r80Val, pIemCpu->iEffSeg, GCPtrEffSrc);
     14947    IEM_MC_FETCH_MEM_R80(r80Val, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1494814948
    1494914949    IEM_MC_PREPARE_FPU_USAGE();
    1495014950    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1495114951        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r80_from_r80, pFpuRes, pr80Val);
    14952         IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pIemCpu->iEffSeg, GCPtrEffSrc);
     14952        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1495314953    IEM_MC_ELSE()
    14954         IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
     14954        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1495514955    IEM_MC_ENDIF();
    1495614956    IEM_MC_ADVANCE_RIP();
    … …  
    1497714977    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1497814978
    14979     IEM_MC_MEM_MAP(pr80Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     14979    IEM_MC_MEM_MAP(pr80Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1498014980    IEM_MC_PREPARE_FPU_USAGE();
    1498114981    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1498214982        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r80, pu16Fsw, pr80Dst, pr80Value);
    1498314983        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pr80Dst, IEM_ACCESS_DATA_W, u16Fsw);
    14984         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     14984        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1498514985    IEM_MC_ELSE()
    1498614986        IEM_MC_IF_FCW_IM()
    … …  
    1498814988            IEM_MC_MEM_COMMIT_AND_UNMAP(pr80Dst, IEM_ACCESS_DATA_W);
    1498914989        IEM_MC_ENDIF();
    14990         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     14990        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1499114991    IEM_MC_ENDIF();
    1499214992    IEM_MC_ADVANCE_RIP();
    … …  
    1520915209FNIEMOP_DEF(iemOp_EscF3)
    1521015210{
    15211     pIemCpu->offFpuOpcode = pIemCpu->offOpcode - 1;
     15211    pVCpu->iem.s.offFpuOpcode = pVCpu->iem.s.offOpcode - 1;
    1521215212    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    1521315213    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    1535915359    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1536015360
    15361     IEM_MC_FETCH_MEM_R64(r64Factor2, pIemCpu->iEffSeg, GCPtrEffSrc);
     15361    IEM_MC_FETCH_MEM_R64(r64Factor2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1536215362    IEM_MC_PREPARE_FPU_USAGE();
    1536315363    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Factor1, 0)
    1536415364        IEM_MC_CALL_FPU_AIMPL_3(pfnImpl, pFpuRes, pr80Factor1, pr64Factor2);
    15365         IEM_MC_STORE_FPU_RESULT_MEM_OP(FpuRes, 0, pIemCpu->iEffSeg, GCPtrEffSrc);
     15365        IEM_MC_STORE_FPU_RESULT_MEM_OP(FpuRes, 0, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1536615366    IEM_MC_ELSE()
    15367         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(0, pIemCpu->iEffSeg, GCPtrEffSrc);
     15367        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(0, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1536815368    IEM_MC_ENDIF();
    1536915369    IEM_MC_ADVANCE_RIP();
    … …  
    1540815408    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1540915409    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    15410     IEM_MC_FETCH_MEM_R64(r64Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     15410    IEM_MC_FETCH_MEM_R64(r64Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1541115411
    1541215412    IEM_MC_PREPARE_FPU_USAGE();
    1541315413    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1541415414        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r64, pu16Fsw, pr80Value1, pr64Val2);
    15415         IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffSrc);
     15415        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1541615416    IEM_MC_ELSE()
    15417         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
     15417        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1541815418    IEM_MC_ENDIF();
    1541915419    IEM_MC_ADVANCE_RIP();
    … …  
    1544215442    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1544315443    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    15444     IEM_MC_FETCH_MEM_R64(r64Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     15444    IEM_MC_FETCH_MEM_R64(r64Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1544515445
    1544615446    IEM_MC_PREPARE_FPU_USAGE();
    1544715447    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1544815448        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r64, pu16Fsw, pr80Value1, pr64Val2);
    15449         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffSrc);
     15449        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1545015450    IEM_MC_ELSE()
    15451         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
     15451        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1545215452    IEM_MC_ENDIF();
    1545315453    IEM_MC_ADVANCE_RIP();
    … …  
    1549315493FNIEMOP_DEF(iemOp_EscF4)
    1549415494{
    15495     pIemCpu->offFpuOpcode = pIemCpu->offOpcode - 1;
     15495    pVCpu->iem.s.offFpuOpcode = pVCpu->iem.s.offOpcode - 1;
    1549615496    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    1549715497    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    1554615546    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1554715547
    15548     IEM_MC_FETCH_MEM_R64(r64Val, pIemCpu->iEffSeg, GCPtrEffSrc);
     15548    IEM_MC_FETCH_MEM_R64(r64Val, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1554915549    IEM_MC_PREPARE_FPU_USAGE();
    1555015550    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1555115551        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r64_to_r80, pFpuRes, pr64Val);
    15552         IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pIemCpu->iEffSeg, GCPtrEffSrc);
     15552        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1555315553    IEM_MC_ELSE()
    15554         IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
     15554        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1555515555    IEM_MC_ENDIF();
    1555615556    IEM_MC_ADVANCE_RIP();
    … …  
    1557715577    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1557815578
    15579     IEM_MC_MEM_MAP(pi64Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     15579    IEM_MC_MEM_MAP(pi64Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1558015580    IEM_MC_PREPARE_FPU_USAGE();
    1558115581    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1558215582        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fistt_r80_to_i64, pu16Fsw, pi64Dst, pr80Value);
    1558315583        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi64Dst, IEM_ACCESS_DATA_W, u16Fsw);
    15584         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     15584        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1558515585    IEM_MC_ELSE()
    1558615586        IEM_MC_IF_FCW_IM()
    … …  
    1558815588            IEM_MC_MEM_COMMIT_AND_UNMAP(pi64Dst, IEM_ACCESS_DATA_W);
    1558915589        IEM_MC_ENDIF();
    15590         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     15590        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1559115591    IEM_MC_ENDIF();
    1559215592    IEM_MC_ADVANCE_RIP();
    … …  
    1561315613    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1561415614
    15615     IEM_MC_MEM_MAP(pr64Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     15615    IEM_MC_MEM_MAP(pr64Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1561615616    IEM_MC_PREPARE_FPU_USAGE();
    1561715617    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1561815618        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r64, pu16Fsw, pr64Dst, pr80Value);
    1561915619        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pr64Dst, IEM_ACCESS_DATA_W, u16Fsw);
    15620         IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     15620        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1562115621    IEM_MC_ELSE()
    1562215622        IEM_MC_IF_FCW_IM()
    … …  
    1562415624            IEM_MC_MEM_COMMIT_AND_UNMAP(pr64Dst, IEM_ACCESS_DATA_W);
    1562515625        IEM_MC_ENDIF();
    15626         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     15626        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1562715627    IEM_MC_ENDIF();
    1562815628    IEM_MC_ADVANCE_RIP();
    … …  
    1565115651    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1565215652
    15653     IEM_MC_MEM_MAP(pr64Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     15653    IEM_MC_MEM_MAP(pr64Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1565415654    IEM_MC_PREPARE_FPU_USAGE();
    1565515655    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1565615656        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r64, pu16Fsw, pr64Dst, pr80Value);
    1565715657        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pr64Dst, IEM_ACCESS_DATA_W, u16Fsw);
    15658         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     15658        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1565915659    IEM_MC_ELSE()
    1566015660        IEM_MC_IF_FCW_IM()
    … …  
    1566215662            IEM_MC_MEM_COMMIT_AND_UNMAP(pr64Dst, IEM_ACCESS_DATA_W);
    1566315663        IEM_MC_ENDIF();
    15664         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     15664        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1566515665    IEM_MC_ENDIF();
    1566615666    IEM_MC_ADVANCE_RIP();
    … …  
    1567615676    IEMOP_MNEMONIC("frstor m94/108byte");
    1567715677    IEM_MC_BEGIN(3, 0);
    15678     IEM_MC_ARG_CONST(IEMMODE,           enmEffOpSize, /*=*/ pIemCpu->enmEffOpSize,  0);
     15678    IEM_MC_ARG_CONST(IEMMODE,           enmEffOpSize, /*=*/ pVCpu->iem.s.enmEffOpSize,  0);
    1567915679    IEM_MC_ARG(uint8_t,                 iEffSeg,                                    1);
    1568015680    IEM_MC_ARG(RTGCPTR,                 GCPtrEffSrc,                                2);
    … …  
    1568315683    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1568415684    IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    15685     IEM_MC_ASSIGN(iEffSeg, pIemCpu->iEffSeg);
     15685    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
    1568615686    IEM_MC_CALL_CIMPL_3(iemCImpl_frstor, enmEffOpSize, iEffSeg, GCPtrEffSrc);
    1568715687    IEM_MC_END();
    … …  
    1569515695    IEMOP_MNEMONIC("fnsave m94/108byte");
    1569615696    IEM_MC_BEGIN(3, 0);
    15697     IEM_MC_ARG_CONST(IEMMODE,           enmEffOpSize, /*=*/ pIemCpu->enmEffOpSize,  0);
     15697    IEM_MC_ARG_CONST(IEMMODE,           enmEffOpSize, /*=*/ pVCpu->iem.s.enmEffOpSize,  0);
    1569815698    IEM_MC_ARG(uint8_t,                 iEffSeg,                                    1);
    1569915699    IEM_MC_ARG(RTGCPTR,                 GCPtrEffDst,                                2);
    … …  
    1570215702    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1570315703    IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    15704     IEM_MC_ASSIGN(iEffSeg, pIemCpu->iEffSeg);
     15704    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
    1570515705    IEM_MC_CALL_CIMPL_3(iemCImpl_fnsave, enmEffOpSize, iEffSeg, GCPtrEffDst);
    1570615706    IEM_MC_END();
    … …  
    1572415724    IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ();
    1572515725    IEM_MC_FETCH_FSW(u16Tmp);
    15726     IEM_MC_STORE_MEM_U16(pIemCpu->iEffSeg, GCPtrEffDst, u16Tmp);
     15726    IEM_MC_STORE_MEM_U16(pVCpu->iem.s.iEffSeg, GCPtrEffDst, u16Tmp);
    1572715727    IEM_MC_ADVANCE_RIP();
    1572815728
    … …  
    1580315803FNIEMOP_DEF(iemOp_EscF5)
    1580415804{
    15805     pIemCpu->offFpuOpcode = pIemCpu->offOpcode - 1;
     15805    pVCpu->iem.s.offFpuOpcode = pVCpu->iem.s.offOpcode - 1;
    1580615806    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    1580715807    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    1591515915    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1591615916    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    15917     IEM_MC_FETCH_MEM_I16(i16Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     15917    IEM_MC_FETCH_MEM_I16(i16Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1591815918
    1591915919    IEM_MC_PREPARE_FPU_USAGE();
    … …  
    1596515965    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1596615966    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    15967     IEM_MC_FETCH_MEM_I16(i16Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     15967    IEM_MC_FETCH_MEM_I16(i16Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1596815968
    1596915969    IEM_MC_PREPARE_FPU_USAGE();
    1597015970    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1597115971        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i16, pu16Fsw, pr80Value1, pi16Val2);
    15972         IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffSrc);
     15972        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1597315973    IEM_MC_ELSE()
    15974         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
     15974        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1597515975    IEM_MC_ENDIF();
    1597615976    IEM_MC_ADVANCE_RIP();
    … …  
    1599915999    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1600016000    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    16001     IEM_MC_FETCH_MEM_I16(i16Val2, pIemCpu->iEffSeg, GCPtrEffSrc);
     16001    IEM_MC_FETCH_MEM_I16(i16Val2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1600216002
    1600316003    IEM_MC_PREPARE_FPU_USAGE();
    1600416004    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
    1600516005        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i16, pu16Fsw, pr80Value1, pi16Val2);
    16006         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffSrc);
     16006        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1600716007    IEM_MC_ELSE()
    16008         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffSrc);
     16008        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1600916009    IEM_MC_ENDIF();
    1601016010    IEM_MC_ADVANCE_RIP();
    … …  
    1605016050FNIEMOP_DEF(iemOp_EscF6)
    1605116051{
    16052     pIemCpu->offFpuOpcode = pIemCpu->offOpcode - 1;
     16052    pVCpu->iem.s.offFpuOpcode = pVCpu->iem.s.offOpcode - 1;
    1605316053    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    1605416054    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    1616116161    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1616216162    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    16163     IEM_MC_FETCH_MEM_I16(i16Val, pIemCpu->iEffSeg, GCPtrEffSrc);
     16163    IEM_MC_FETCH_MEM_I16(i16Val, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1616416164
    1616516165    IEM_MC_PREPARE_FPU_USAGE();
    1616616166    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1616716167        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fild_i16_to_r80, pFpuRes, pi16Val);
    16168         IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pIemCpu->iEffSeg, GCPtrEffSrc);
     16168        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1616916169    IEM_MC_ELSE()
    16170         IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
     16170        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1617116171    IEM_MC_ENDIF();
    1617216172    IEM_MC_ADVANCE_RIP();
    … …  
    1619316193    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1619416194
    16195     IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     16195    IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1619616196    IEM_MC_PREPARE_FPU_USAGE();
    1619716197    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1619816198        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fistt_r80_to_i16, pu16Fsw, pi16Dst, pr80Value);
    1619916199        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi16Dst, IEM_ACCESS_DATA_W, u16Fsw);
    16200         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     16200        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1620116201    IEM_MC_ELSE()
    1620216202        IEM_MC_IF_FCW_IM()
    … …  
    1620416204            IEM_MC_MEM_COMMIT_AND_UNMAP(pi16Dst, IEM_ACCESS_DATA_W);
    1620516205        IEM_MC_ENDIF();
    16206         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     16206        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1620716207    IEM_MC_ENDIF();
    1620816208    IEM_MC_ADVANCE_RIP();
    … …  
    1622916229    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1623016230
    16231     IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     16231    IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1623216232    IEM_MC_PREPARE_FPU_USAGE();
    1623316233    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1623416234        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i16, pu16Fsw, pi16Dst, pr80Value);
    1623516235        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi16Dst, IEM_ACCESS_DATA_W, u16Fsw);
    16236         IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     16236        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1623716237    IEM_MC_ELSE()
    1623816238        IEM_MC_IF_FCW_IM()
    … …  
    1624016240            IEM_MC_MEM_COMMIT_AND_UNMAP(pi16Dst, IEM_ACCESS_DATA_W);
    1624116241        IEM_MC_ENDIF();
    16242         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     16242        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1624316243    IEM_MC_ENDIF();
    1624416244    IEM_MC_ADVANCE_RIP();
    … …  
    1626516265    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1626616266
    16267     IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     16267    IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1626816268    IEM_MC_PREPARE_FPU_USAGE();
    1626916269    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1627016270        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i16, pu16Fsw, pi16Dst, pr80Value);
    1627116271        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi16Dst, IEM_ACCESS_DATA_W, u16Fsw);
    16272         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     16272        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1627316273    IEM_MC_ELSE()
    1627416274        IEM_MC_IF_FCW_IM()
    … …  
    1627616276            IEM_MC_MEM_COMMIT_AND_UNMAP(pi16Dst, IEM_ACCESS_DATA_W);
    1627716277        IEM_MC_ENDIF();
    16278         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     16278        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1627916279    IEM_MC_ENDIF();
    1628016280    IEM_MC_ADVANCE_RIP();
    … …  
    1630616306    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    1630716307    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    16308     IEM_MC_FETCH_MEM_I64(i64Val, pIemCpu->iEffSeg, GCPtrEffSrc);
     16308    IEM_MC_FETCH_MEM_I64(i64Val, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1630916309
    1631016310    IEM_MC_PREPARE_FPU_USAGE();
    1631116311    IEM_MC_IF_FPUREG_IS_EMPTY(7)
    1631216312        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fild_i64_to_r80, pFpuRes, pi64Val);
    16313         IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pIemCpu->iEffSeg, GCPtrEffSrc);
     16313        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1631416314    IEM_MC_ELSE()
    16315         IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pIemCpu->iEffSeg, GCPtrEffSrc);
     16315        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1631616316    IEM_MC_ENDIF();
    1631716317    IEM_MC_ADVANCE_RIP();
    … …  
    1634216342    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    1634316343
    16344     IEM_MC_MEM_MAP(pi64Dst, IEM_ACCESS_DATA_W, pIemCpu->iEffSeg, GCPtrEffDst, 1 /*arg*/);
     16344    IEM_MC_MEM_MAP(pi64Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1634516345    IEM_MC_PREPARE_FPU_USAGE();
    1634616346    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
    1634716347        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i64, pu16Fsw, pi64Dst, pr80Value);
    1634816348        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi64Dst, IEM_ACCESS_DATA_W, u16Fsw);
    16349         IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pIemCpu->iEffSeg, GCPtrEffDst);
     16349        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1635016350    IEM_MC_ELSE()
    1635116351        IEM_MC_IF_FCW_IM()
    … …  
    1635316353            IEM_MC_MEM_COMMIT_AND_UNMAP(pi64Dst, IEM_ACCESS_DATA_W);
    1635416354        IEM_MC_ENDIF();
    16355         IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pIemCpu->iEffSeg, GCPtrEffDst);
     16355        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1635616356    IEM_MC_ENDIF();
    1635716357    IEM_MC_ADVANCE_RIP();
    … …  
    1640916409    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    1641016410
    16411     switch (pIemCpu->enmEffAddrMode)
     16411    switch (pVCpu->iem.s.enmEffAddrMode)
    1641216412    {
    1641316413        case IEMMODE_16BIT:
    … …  
    1645716457    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    1645816458
    16459     switch (pIemCpu->enmEffAddrMode)
     16459    switch (pVCpu->iem.s.enmEffAddrMode)
    1646016460    {
    1646116461        case IEMMODE_16BIT:
    … …  
    1650816508     * using the 32-bit operand size override.  How can that be restarted?  See
    1650916509     * weird pseudo code in intel manual. */
    16510     switch (pIemCpu->enmEffAddrMode)
     16510    switch (pVCpu->iem.s.enmEffAddrMode)
    1651116511    {
    1651216512        case IEMMODE_16BIT:
    1651316513            IEM_MC_BEGIN(0,0);
    16514             if (-(int8_t)pIemCpu->offOpcode != i8Imm)
     16514            if (-(int8_t)pVCpu->iem.s.offOpcode != i8Imm)
    1651516515            {
    1651616516                IEM_MC_SUB_GREG_U16(X86_GREG_xCX, 1);
    … …  
    1653116531        case IEMMODE_32BIT:
    1653216532            IEM_MC_BEGIN(0,0);
    16533             if (-(int8_t)pIemCpu->offOpcode != i8Imm)
     16533            if (-(int8_t)pVCpu->iem.s.offOpcode != i8Imm)
    1653416534            {
    1653516535                IEM_MC_SUB_GREG_U32(X86_GREG_xCX, 1);
    … …  
    1655016550        case IEMMODE_64BIT:
    1655116551            IEM_MC_BEGIN(0,0);
    16552             if (-(int8_t)pIemCpu->offOpcode != i8Imm)
     16552            if (-(int8_t)pVCpu->iem.s.offOpcode != i8Imm)
    1655316553            {
    1655416554                IEM_MC_SUB_GREG_U64(X86_GREG_xCX, 1);
    … …  
    1658016580    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    1658116581
    16582     switch (pIemCpu->enmEffAddrMode)
     16582    switch (pVCpu->iem.s.enmEffAddrMode)
    1658316583    {
    1658416584        case IEMMODE_16BIT:
    … …  
    1663316633    uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1663416634    IEMOP_HLP_NO_LOCK_PREFIX();
    16635     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_in, u8Imm, pIemCpu->enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
     16635    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_in, u8Imm, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
    1663616636}
    1663716637
    … …  
    1665316653    uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1665416654    IEMOP_HLP_NO_LOCK_PREFIX();
    16655     return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_out, u8Imm, pIemCpu->enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
     16655    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_out, u8Imm, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
    1665616656}
    1665716657
    … …  
    1666216662    IEMOP_MNEMONIC("call Jv");
    1666316663    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    16664     switch (pIemCpu->enmEffOpSize)
     16664    switch (pVCpu->iem.s.enmEffOpSize)
    1666516665    {
    1666616666        case IEMMODE_16BIT:
    … …  
    1669216692    IEMOP_MNEMONIC("jmp Jv");
    1669316693    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    16694     switch (pIemCpu->enmEffOpSize)
     16694    switch (pVCpu->iem.s.enmEffOpSize)
    1669516695    {
    1669616696        case IEMMODE_16BIT:
    … …  
    1672616726    /* Decode the far pointer address and pass it on to the far call C implementation. */
    1672716727    uint32_t offSeg;
    16728     if (pIemCpu->enmEffOpSize != IEMMODE_16BIT)
     16728    if (pVCpu->iem.s.enmEffOpSize != IEMMODE_16BIT)
    1672916729        IEM_OPCODE_GET_NEXT_U32(&offSeg);
    1673016730    else
    … …  
    1673216732    uint16_t uSel;  IEM_OPCODE_GET_NEXT_U16(&uSel);
    1673316733    IEMOP_HLP_NO_LOCK_PREFIX();
    16734     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_FarJmp, uSel, offSeg, pIemCpu->enmEffOpSize);
     16734    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_FarJmp, uSel, offSeg, pVCpu->iem.s.enmEffOpSize);
    1673516735}
    1673616736
    … …  
    1676516765    IEMOP_MNEMONIC("in  eAX,DX");
    1676616766    IEMOP_HLP_NO_LOCK_PREFIX();
    16767     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_in_eAX_DX, pIemCpu->enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
     16767    return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_in_eAX_DX, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
    1676816768}
    1676916769
    … …  
    1678316783    IEMOP_MNEMONIC("out DX,eAX");
    1678416784    IEMOP_HLP_NO_LOCK_PREFIX();
    16785     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_out_DX_eAX, pIemCpu->enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
     16785    return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_out_DX_eAX, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
    1678616786}
    1678716787
    … …  
    1679116791{
    1679216792    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("lock");
    16793     pIemCpu->fPrefixes |= IEM_OP_PRF_LOCK;
     16793    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_LOCK;
    1679416794
    1679516795    uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    1681216812{
    1681316813    /* This overrides any previous REPE prefix. */
    16814     pIemCpu->fPrefixes &= ~IEM_OP_PRF_REPZ;
     16814    pVCpu->iem.s.fPrefixes &= ~IEM_OP_PRF_REPZ;
    1681516815    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("repne");
    16816     pIemCpu->fPrefixes |= IEM_OP_PRF_REPNZ;
     16816    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REPNZ;
    1681716817
    1681816818    uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    1682516825{
    1682616826    /* This overrides any previous REPNE prefix. */
    16827     pIemCpu->fPrefixes &= ~IEM_OP_PRF_REPNZ;
     16827    pVCpu->iem.s.fPrefixes &= ~IEM_OP_PRF_REPNZ;
    1682816828    IEMOP_HLP_CLEAR_REX_NOT_BEFORE_OPCODE("repe");
    16829     pIemCpu->fPrefixes |= IEM_OP_PRF_REPZ;
     16829    pVCpu->iem.s.fPrefixes |= IEM_OP_PRF_REPZ;
    1683016830
    1683116831    uint8_t b; IEM_OPCODE_GET_NEXT_U8(&b);
    … …  
    1686916869        IEM_MC_ARG(uint8_t *,   pu8Dst, 0);
    1687016870        IEM_MC_ARG(uint32_t *,  pEFlags, 1);
    16871         IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     16871        IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1687216872        IEM_MC_REF_EFLAGS(pEFlags);
    1687316873        IEM_MC_CALL_VOID_AIMPL_2(pImpl->pfnNormalU8, pu8Dst, pEFlags);
    … …  
    1688416884
    1688516885        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    16886         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     16886        IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1688716887        IEM_MC_FETCH_EFLAGS(EFlags);
    16888         if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     16888        if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    1688916889            IEM_MC_CALL_VOID_AIMPL_2(pImpl->pfnNormalU8, pu8Dst, pEFlags);
    1689016890        else
    … …  
    1691016910    /* Registers are handled by a common worker. */
    1691116911    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    16912         return FNIEMOP_CALL_2(iemOpCommonUnaryGReg, pImpl, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     16912        return FNIEMOP_CALL_2(iemOpCommonUnaryGReg, pImpl, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1691316913
    1691416914    /* Memory we do here. */
    16915     switch (pIemCpu->enmEffOpSize)
     16915    switch (pVCpu->iem.s.enmEffOpSize)
    1691616916    {
    1691716917        case IEMMODE_16BIT:
    … …  
    1692216922
    1692316923            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    16924             IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     16924            IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1692516925            IEM_MC_FETCH_EFLAGS(EFlags);
    16926             if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     16926            if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    1692716927                IEM_MC_CALL_VOID_AIMPL_2(pImpl->pfnNormalU16, pu16Dst, pEFlags);
    1692816928            else
    … …  
    1694216942
    1694316943            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    16944             IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     16944            IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1694516945            IEM_MC_FETCH_EFLAGS(EFlags);
    16946             if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     16946            if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    1694716947                IEM_MC_CALL_VOID_AIMPL_2(pImpl->pfnNormalU32, pu32Dst, pEFlags);
    1694816948            else
    … …  
    1696216962
    1696316963            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    16964             IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     16964            IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_RW, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1696516965            IEM_MC_FETCH_EFLAGS(EFlags);
    16966             if (!(pIemCpu->fPrefixes & IEM_OP_PRF_LOCK))
     16966            if (!(pVCpu->iem.s.fPrefixes & IEM_OP_PRF_LOCK))
    1696716967                IEM_MC_CALL_VOID_AIMPL_2(pImpl->pfnNormalU64, pu64Dst, pEFlags);
    1696816968            else
    … …  
    1699616996        IEM_MC_ARG_CONST(uint8_t,   u8Src,/*=*/u8Imm,   1);
    1699716997        IEM_MC_ARG(uint32_t *,      pEFlags,            2);
    16998         IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     16998        IEM_MC_REF_GREG_U8(pu8Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1699916999        IEM_MC_REF_EFLAGS(pEFlags);
    1700017000        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u8, pu8Dst, u8Src, pEFlags);
    … …  
    1701617016        uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1701717017        IEM_MC_ASSIGN(u8Src, u8Imm);
    17018         IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_R, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     17018        IEM_MC_MEM_MAP(pu8Dst, IEM_ACCESS_DATA_R, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1701917019        IEM_MC_FETCH_EFLAGS(EFlags);
    1702017020        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u8, pu8Dst, u8Src, pEFlags);
    … …  
    1703917039    {
    1704017040        /* register access */
    17041         switch (pIemCpu->enmEffOpSize)
     17041        switch (pVCpu->iem.s.enmEffOpSize)
    1704217042        {
    1704317043            case IEMMODE_16BIT:
    … …  
    1704817048                IEM_MC_ARG_CONST(uint16_t,  u16Src,/*=*/u16Imm,     1);
    1704917049                IEM_MC_ARG(uint32_t *,      pEFlags,                2);
    17050                 IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17050                IEM_MC_REF_GREG_U16(pu16Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1705117051                IEM_MC_REF_EFLAGS(pEFlags);
    1705217052                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u16, pu16Dst, u16Src, pEFlags);
    … …  
    1706317063                IEM_MC_ARG_CONST(uint32_t,  u32Src,/*=*/u32Imm,     1);
    1706417064                IEM_MC_ARG(uint32_t *,      pEFlags,                2);
    17065                 IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17065                IEM_MC_REF_GREG_U32(pu32Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1706617066                IEM_MC_REF_EFLAGS(pEFlags);
    1706717067                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u32, pu32Dst, u32Src, pEFlags);
    … …  
    1707917079                IEM_MC_ARG_CONST(uint64_t,  u64Src,/*=*/u64Imm,     1);
    1708017080                IEM_MC_ARG(uint32_t *,      pEFlags,                2);
    17081                 IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17081                IEM_MC_REF_GREG_U64(pu64Dst, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1708217082                IEM_MC_REF_EFLAGS(pEFlags);
    1708317083                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u64, pu64Dst, u64Src, pEFlags);
    … …  
    1709317093    {
    1709417094        /* memory access. */
    17095         switch (pIemCpu->enmEffOpSize)
     17095        switch (pVCpu->iem.s.enmEffOpSize)
    1709617096        {
    1709717097            case IEMMODE_16BIT:
    … …  
    1710617106                uint16_t u16Imm; IEM_OPCODE_GET_NEXT_U16(&u16Imm);
    1710717107                IEM_MC_ASSIGN(u16Src, u16Imm);
    17108                 IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_R, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     17108                IEM_MC_MEM_MAP(pu16Dst, IEM_ACCESS_DATA_R, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1710917109                IEM_MC_FETCH_EFLAGS(EFlags);
    1711017110                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u16, pu16Dst, u16Src, pEFlags);
    … …  
    1712817128                uint32_t u32Imm; IEM_OPCODE_GET_NEXT_U32(&u32Imm);
    1712917129                IEM_MC_ASSIGN(u32Src, u32Imm);
    17130                 IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_R, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     17130                IEM_MC_MEM_MAP(pu32Dst, IEM_ACCESS_DATA_R, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1713117131                IEM_MC_FETCH_EFLAGS(EFlags);
    1713217132                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u32, pu32Dst, u32Src, pEFlags);
    … …  
    1715017150                uint64_t u64Imm; IEM_OPCODE_GET_NEXT_S32_SX_U64(&u64Imm);
    1715117151                IEM_MC_ASSIGN(u64Src, u64Imm);
    17152                 IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_R, pIemCpu->iEffSeg, GCPtrEffDst, 0 /*arg*/);
     17152                IEM_MC_MEM_MAP(pu64Dst, IEM_ACCESS_DATA_R, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 0 /*arg*/);
    1715317153                IEM_MC_FETCH_EFLAGS(EFlags);
    1715417154                IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_test_u64, pu64Dst, u64Src, pEFlags);
    … …  
    1718217182        IEM_MC_LOCAL(int32_t,       rc);
    1718317183
    17184         IEM_MC_FETCH_GREG_U8(u8Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17184        IEM_MC_FETCH_GREG_U8(u8Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1718517185        IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX);
    1718617186        IEM_MC_REF_EFLAGS(pEFlags);
    … …  
    1720717207
    1720817208        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    17209         IEM_MC_FETCH_MEM_U8(u8Value, pIemCpu->iEffSeg, GCPtrEffDst);
     17209        IEM_MC_FETCH_MEM_U8(u8Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1721017210        IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX);
    1721117211        IEM_MC_REF_EFLAGS(pEFlags);
    … …  
    1723217232    {
    1723317233        /* register access */
    17234         switch (pIemCpu->enmEffOpSize)
     17234        switch (pVCpu->iem.s.enmEffOpSize)
    1723517235        {
    1723617236            case IEMMODE_16BIT:
    … …  
    1724417244                IEM_MC_LOCAL(int32_t,       rc);
    1724517245
    17246                 IEM_MC_FETCH_GREG_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17246                IEM_MC_FETCH_GREG_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1724717247                IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX);
    1724817248                IEM_MC_REF_GREG_U16(pu16DX, X86_GREG_xDX);
    … …  
    1726917269                IEM_MC_LOCAL(int32_t,       rc);
    1727017270
    17271                 IEM_MC_FETCH_GREG_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17271                IEM_MC_FETCH_GREG_U32(u32Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1727217272                IEM_MC_REF_GREG_U32(pu32AX, X86_GREG_xAX);
    1727317273                IEM_MC_REF_GREG_U32(pu32DX, X86_GREG_xDX);
    … …  
    1729617296                IEM_MC_LOCAL(int32_t,       rc);
    1729717297
    17298                 IEM_MC_FETCH_GREG_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17298                IEM_MC_FETCH_GREG_U64(u64Value, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1729917299                IEM_MC_REF_GREG_U64(pu64AX, X86_GREG_xAX);
    1730017300                IEM_MC_REF_GREG_U64(pu64DX, X86_GREG_xDX);
    … …  
    1731717317    {
    1731817318        /* memory access. */
    17319         switch (pIemCpu->enmEffOpSize)
     17319        switch (pVCpu->iem.s.enmEffOpSize)
    1732017320        {
    1732117321            case IEMMODE_16BIT:
    … …  
    1733117331
    1733217332                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    17333                 IEM_MC_FETCH_MEM_U16(u16Value, pIemCpu->iEffSeg, GCPtrEffDst);
     17333                IEM_MC_FETCH_MEM_U16(u16Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1733417334                IEM_MC_REF_GREG_U16(pu16AX, X86_GREG_xAX);
    1733517335                IEM_MC_REF_GREG_U16(pu16DX, X86_GREG_xDX);
    … …  
    1735817358
    1735917359                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    17360                 IEM_MC_FETCH_MEM_U32(u32Value, pIemCpu->iEffSeg, GCPtrEffDst);
     17360                IEM_MC_FETCH_MEM_U32(u32Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1736117361                IEM_MC_REF_GREG_U32(pu32AX, X86_GREG_xAX);
    1736217362                IEM_MC_REF_GREG_U32(pu32DX, X86_GREG_xDX);
    … …  
    1738717387
    1738817388                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    17389                 IEM_MC_FETCH_MEM_U64(u64Value, pIemCpu->iEffSeg, GCPtrEffDst);
     17389                IEM_MC_FETCH_MEM_U64(u64Value, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    1739017390                IEM_MC_REF_GREG_U64(pu64AX, X86_GREG_xAX);
    1739117391                IEM_MC_REF_GREG_U64(pu64DX, X86_GREG_xDX);
    … …  
    1758417584    {
    1758517585        /* The new RIP is taken from a register. */
    17586         switch (pIemCpu->enmEffOpSize)
     17586        switch (pVCpu->iem.s.enmEffOpSize)
    1758717587        {
    1758817588            case IEMMODE_16BIT:
    1758917589                IEM_MC_BEGIN(1, 0);
    1759017590                IEM_MC_ARG(uint16_t, u16Target, 0);
    17591                 IEM_MC_FETCH_GREG_U16(u16Target, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17591                IEM_MC_FETCH_GREG_U16(u16Target, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1759217592                IEM_MC_CALL_CIMPL_1(iemCImpl_call_16, u16Target);
    1759317593                IEM_MC_END()
    … …  
    1759717597                IEM_MC_BEGIN(1, 0);
    1759817598                IEM_MC_ARG(uint32_t, u32Target, 0);
    17599                 IEM_MC_FETCH_GREG_U32(u32Target, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17599                IEM_MC_FETCH_GREG_U32(u32Target, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1760017600                IEM_MC_CALL_CIMPL_1(iemCImpl_call_32, u32Target);
    1760117601                IEM_MC_END()
    … …  
    1760517605                IEM_MC_BEGIN(1, 0);
    1760617606                IEM_MC_ARG(uint64_t, u64Target, 0);
    17607                 IEM_MC_FETCH_GREG_U64(u64Target, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17607                IEM_MC_FETCH_GREG_U64(u64Target, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1760817608                IEM_MC_CALL_CIMPL_1(iemCImpl_call_64, u64Target);
    1760917609                IEM_MC_END()
    … …  
    1761617616    {
    1761717617        /* The new RIP is taken from a register. */
    17618         switch (pIemCpu->enmEffOpSize)
     17618        switch (pVCpu->iem.s.enmEffOpSize)
    1761917619        {
    1762017620            case IEMMODE_16BIT:
    … …  
    1762317623                IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    1762417624                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    17625                 IEM_MC_FETCH_MEM_U16(u16Target, pIemCpu->iEffSeg, GCPtrEffSrc);
     17625                IEM_MC_FETCH_MEM_U16(u16Target, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1762617626                IEM_MC_CALL_CIMPL_1(iemCImpl_call_16, u16Target);
    1762717627                IEM_MC_END()
    … …  
    1763317633                IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    1763417634                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    17635                 IEM_MC_FETCH_MEM_U32(u32Target, pIemCpu->iEffSeg, GCPtrEffSrc);
     17635                IEM_MC_FETCH_MEM_U32(u32Target, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1763617636                IEM_MC_CALL_CIMPL_1(iemCImpl_call_32, u32Target);
    1763717637                IEM_MC_END()
    … …  
    1764317643                IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    1764417644                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    17645                 IEM_MC_FETCH_MEM_U64(u64Target, pIemCpu->iEffSeg, GCPtrEffSrc);
     17645                IEM_MC_FETCH_MEM_U64(u64Target, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1764617646                IEM_MC_CALL_CIMPL_1(iemCImpl_call_64, u64Target);
    1764717647                IEM_MC_END()
    … …  
    1766217662
    1766317663    /* Far pointer loaded from memory. */
    17664     switch (pIemCpu->enmEffOpSize)
     17664    switch (pVCpu->iem.s.enmEffOpSize)
    1766517665    {
    1766617666        case IEMMODE_16BIT:
    … …  
    1767217672            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    1767317673            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    17674             IEM_MC_FETCH_MEM_U16(offSeg, pIemCpu->iEffSeg, GCPtrEffSrc);
    17675             IEM_MC_FETCH_MEM_U16_DISP(u16Sel, pIemCpu->iEffSeg, GCPtrEffSrc, 2);
     17674            IEM_MC_FETCH_MEM_U16(offSeg, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     17675            IEM_MC_FETCH_MEM_U16_DISP(u16Sel, pVCpu->iem.s.iEffSeg, GCPtrEffSrc, 2);
    1767617676            IEM_MC_CALL_CIMPL_3(pfnCImpl, u16Sel, offSeg, enmEffOpSize);
    1767717677            IEM_MC_END();
    … …  
    1768217682             *        and will apparently ignore REX.W, at least for the jmp far qword [rsp]
    1768317683             *        and call far qword [rsp] encodings. */
    17684             if (!IEM_IS_GUEST_CPU_AMD(pIemCpu))
     17684            if (!IEM_IS_GUEST_CPU_AMD(pVCpu))
    1768517685            {
    1768617686                IEM_MC_BEGIN(3, 1);
    … …  
    1769117691                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    1769217692                IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    17693                 IEM_MC_FETCH_MEM_U64(offSeg, pIemCpu->iEffSeg, GCPtrEffSrc);
    17694                 IEM_MC_FETCH_MEM_U16_DISP(u16Sel, pIemCpu->iEffSeg, GCPtrEffSrc, 8);
     17693                IEM_MC_FETCH_MEM_U64(offSeg, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     17694                IEM_MC_FETCH_MEM_U16_DISP(u16Sel, pVCpu->iem.s.iEffSeg, GCPtrEffSrc, 8);
    1769517695                IEM_MC_CALL_CIMPL_3(pfnCImpl, u16Sel, offSeg, enmEffOpSize);
    1769617696                IEM_MC_END();
    … …  
    1770717707            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    1770817708            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    17709             IEM_MC_FETCH_MEM_U32(offSeg, pIemCpu->iEffSeg, GCPtrEffSrc);
    17710             IEM_MC_FETCH_MEM_U16_DISP(u16Sel, pIemCpu->iEffSeg, GCPtrEffSrc, 4);
     17709            IEM_MC_FETCH_MEM_U32(offSeg, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     17710            IEM_MC_FETCH_MEM_U16_DISP(u16Sel, pVCpu->iem.s.iEffSeg, GCPtrEffSrc, 4);
    1771117711            IEM_MC_CALL_CIMPL_3(pfnCImpl, u16Sel, offSeg, enmEffOpSize);
    1771217712            IEM_MC_END();
    … …  
    1774217742    {
    1774317743        /* The new RIP is taken from a register. */
    17744         switch (pIemCpu->enmEffOpSize)
     17744        switch (pVCpu->iem.s.enmEffOpSize)
    1774517745        {
    1774617746            case IEMMODE_16BIT:
    1774717747                IEM_MC_BEGIN(0, 1);
    1774817748                IEM_MC_LOCAL(uint16_t, u16Target);
    17749                 IEM_MC_FETCH_GREG_U16(u16Target, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17749                IEM_MC_FETCH_GREG_U16(u16Target, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1775017750                IEM_MC_SET_RIP_U16(u16Target);
    1775117751                IEM_MC_END()
    … …  
    1775517755                IEM_MC_BEGIN(0, 1);
    1775617756                IEM_MC_LOCAL(uint32_t, u32Target);
    17757                 IEM_MC_FETCH_GREG_U32(u32Target, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17757                IEM_MC_FETCH_GREG_U32(u32Target, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1775817758                IEM_MC_SET_RIP_U32(u32Target);
    1775917759                IEM_MC_END()
    … …  
    1776317763                IEM_MC_BEGIN(0, 1);
    1776417764                IEM_MC_LOCAL(uint64_t, u64Target);
    17765                 IEM_MC_FETCH_GREG_U64(u64Target, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17765                IEM_MC_FETCH_GREG_U64(u64Target, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1776617766                IEM_MC_SET_RIP_U64(u64Target);
    1776717767                IEM_MC_END()
    … …  
    1777417774    {
    1777517775        /* The new RIP is taken from a memory location. */
    17776         switch (pIemCpu->enmEffOpSize)
     17776        switch (pVCpu->iem.s.enmEffOpSize)
    1777717777        {
    1777817778            case IEMMODE_16BIT:
    … …  
    1778117781                IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    1778217782                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    17783                 IEM_MC_FETCH_MEM_U16(u16Target, pIemCpu->iEffSeg, GCPtrEffSrc);
     17783                IEM_MC_FETCH_MEM_U16(u16Target, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1778417784                IEM_MC_SET_RIP_U16(u16Target);
    1778517785                IEM_MC_END()
    … …  
    1779117791                IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    1779217792                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    17793                 IEM_MC_FETCH_MEM_U32(u32Target, pIemCpu->iEffSeg, GCPtrEffSrc);
     17793                IEM_MC_FETCH_MEM_U32(u32Target, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1779417794                IEM_MC_SET_RIP_U32(u32Target);
    1779517795                IEM_MC_END()
    … …  
    1780117801                IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    1780217802                IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    17803                 IEM_MC_FETCH_MEM_U64(u64Target, pIemCpu->iEffSeg, GCPtrEffSrc);
     17803                IEM_MC_FETCH_MEM_U64(u64Target, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1780417804                IEM_MC_SET_RIP_U64(u64Target);
    1780517805                IEM_MC_END()
    … …  
    1783417834    /* Registers are handled by a common worker. */
    1783517835    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    17836         return FNIEMOP_CALL_1(iemOpCommonPushGReg, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
     17836        return FNIEMOP_CALL_1(iemOpCommonPushGReg, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    1783717837
    1783817838    /* Memory we do here. */
    1783917839    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    17840     switch (pIemCpu->enmEffOpSize)
     17840    switch (pVCpu->iem.s.enmEffOpSize)
    1784117841    {
    1784217842        case IEMMODE_16BIT:
    … …  
    1784517845            IEM_MC_LOCAL(RTGCPTR,   GCPtrEffSrc);
    1784617846            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    17847             IEM_MC_FETCH_MEM_U16(u16Src, pIemCpu->iEffSeg, GCPtrEffSrc);
     17847            IEM_MC_FETCH_MEM_U16(u16Src, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1784817848            IEM_MC_PUSH_U16(u16Src);
    1784917849            IEM_MC_ADVANCE_RIP();
    … …  
    1785617856            IEM_MC_LOCAL(RTGCPTR,   GCPtrEffSrc);
    1785717857            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    17858             IEM_MC_FETCH_MEM_U32(u32Src, pIemCpu->iEffSeg, GCPtrEffSrc);
     17858            IEM_MC_FETCH_MEM_U32(u32Src, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1785917859            IEM_MC_PUSH_U32(u32Src);
    1786017860            IEM_MC_ADVANCE_RIP();
    … …  
    1786717867            IEM_MC_LOCAL(RTGCPTR,   GCPtrEffSrc);
    1786817868            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    17869             IEM_MC_FETCH_MEM_U64(u64Src, pIemCpu->iEffSeg, GCPtrEffSrc);
     17869            IEM_MC_FETCH_MEM_U64(u64Src, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1787017870            IEM_MC_PUSH_U64(u64Src);
    1787117871            IEM_MC_ADVANCE_RIP();
Note: See TracChangeset for help on using the changeset viewer.

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