VirtualBox

Changeset 104984 in vbox


Ignore:
Timestamp:
Jun 20, 2024 2:07:04 PM (9 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
163594
Message:

VMM/IEM: Relax alignment restrictions in native code TLB lookup, avoid the fallback/tlbmiss code path for most accesses as long as they're within the same page. bugref:10687

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/armv8.h

    r104728 r104984  
    40524052
    40534053
     4054/**
     4055 * A64: Encodes TBZ (conditional branch w/ immediate) instructions.
     4056 *
     4057 * @returns The encoded instruction.
     4058 * @param   iImm14          Signed number of instruction to jump (i.e. *4).
     4059 * @param   iReg            The GPR to check for zero / non-zero value.
     4060 * @param   iBitNo          The bit to test for.
     4061 */
     4062DECL_FORCE_INLINE(uint32_t) Armv8A64MkInstrTbz(int32_t iImm14, uint32_t iReg, uint32_t iBitNo)
     4063{
     4064    return Armv8A64MkInstrTbzTbnz(false /*fJmpIfNotZero*/, iImm14, iReg, iBitNo);
     4065}
     4066
     4067
     4068/**
     4069 * A64: Encodes TBNZ (conditional branch w/ immediate) instructions.
     4070 *
     4071 * @returns The encoded instruction.
     4072 * @param   iImm14          Signed number of instruction to jump (i.e. *4).
     4073 * @param   iReg            The GPR to check for zero / non-zero value.
     4074 * @param   iBitNo          The bit to test for.
     4075 */
     4076DECL_FORCE_INLINE(uint32_t) Armv8A64MkInstrTbnz(int32_t iImm14, uint32_t iReg, uint32_t iBitNo)
     4077{
     4078    return Armv8A64MkInstrTbzTbnz(true /*fJmpIfNotZero*/, iImm14, iReg, iBitNo);
     4079}
     4080
     4081
    40544082
    40554083/** Armv8 Condition codes.    */

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

    r104956 r104984  
    38433843        iemRaiseXcptAdjustState(pVCpu, u8Vector);
    38443844
    3845     iemRecalcExecModeAndCplFlags(pVCpu);
     3845    iemRecalcExecModeAndCplAndAcFlags(pVCpu);
    38463846
    38473847    return fFlags & IEM_XCPT_FLAGS_T_CPU_XCPT ? VINF_IEM_RAISED_XCPT : VINF_SUCCESS;

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

    r104722 r104984  
    912912    Assert(fEflNew & RT_BIT_32(1));
    913913    IEMMISC_SET_EFL(pVCpu, fEflNew);
     914    pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~IEM_F_X86_AC) | iemCalcExecAcFlag(pVCpu);
    914915    return iemRegAddToRipAndFinishingClearingRfEx(pVCpu, cbInstr, fEflOld);
    915916}
    … …  
    16921693    pVCpu->cpum.GstCtx.eflags.Bits.u1RF = 0;
    16931694
    1694     iemRecalcExecModeAndCplFlags(pVCpu);
     1695    iemRecalcExecModeAndCplAndAcFlags(pVCpu);
    16951696
    16961697/** @todo single stepping   */
    … …  
    19421943     *        mode.  */
    19431944
    1944     iemRecalcExecModeAndCplFlags(pVCpu);
     1945    iemRecalcExecModeAndCplAndAcFlags(pVCpu);
    19451946
    19461947    /* Flush the prefetch buffer. */
    … …  
    21682169     *        mode.  */
    21692170
    2170     iemRecalcExecModeAndCplFlags(pVCpu);
     2171    iemRecalcExecModeAndCplAndAcFlags(pVCpu);
    21712172
    21722173    /* Flush the prefetch buffer. */
    … …  
    24992500        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pVCpu->cpum.GstCtx.gs);
    25002501
    2501         iemRecalcExecModeAndCplFlags(pVCpu); /* Affects iemRegAddToRspEx and the setting of RSP/SP below.  */
     2502        iemRecalcExecModeAndCplAndAcFlags(pVCpu); /* Affects iemRegAddToRspEx and the setting of RSP/SP below.  */
    25022503
    25032504        if (cbPop)
    … …  
    25102511            pVCpu->cpum.GstCtx.sp            = (uint16_t)NewOuterRsp.u;
    25112512
    2512         iemRecalcExecModeAndCplFlags(pVCpu); /* Affects iemRegAddToRspEx and the setting of RSP/SP below.  */
     2513        iemRecalcExecModeAndCplAndAcFlags(pVCpu); /* Affects iemRegAddToRspEx and the setting of RSP/SP below.  */
    25132514
    25142515        /** @todo check if the hidden bits are loaded correctly for 64-bit
    … …  
    25852586         *        mode.  */
    25862587
    2587         iemRecalcExecModeAndCplFlags(pVCpu);
     2588        iemRecalcExecModeAndCplAndAcFlags(pVCpu);
    25882589    }
    25892590
    … …  
    29262927    Assert(uNewFlags & X86_EFL_1);
    29272928    IEMMISC_SET_EFL(pVCpu, uNewFlags);
     2929    pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~IEM_F_X86_AC) | iemCalcExecAcFlag(pVCpu);
    29282930
    29292931    /* Flush the prefetch buffer. */
    … …  
    30073009    pVCpu->cpum.GstCtx.rip      = (uint16_t)uNewEip;
    30083010    pVCpu->cpum.GstCtx.rsp      = uNewEsp; /** @todo check this out! */
    3009     pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK))
     3011    pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK | IEM_F_X86_AC))
    30103012                       | (3 << IEM_F_X86_CPL_SHIFT)
    3011                        | IEM_F_MODE_X86_16BIT_PROT_V86;
     3013                       | IEM_F_MODE_X86_16BIT_PROT_V86
     3014                       | iemCalcExecAcFlag(pVCpu);
    30123015
    30133016    /* Flush the prefetch buffer. */
    … …  
    33593362        iemHlpAdjustSelectorForNewCpl(pVCpu, uNewCs & X86_SEL_RPL, &pVCpu->cpum.GstCtx.gs);
    33603363
    3361         iemRecalcExecModeAndCplFlags(pVCpu);
     3364        iemRecalcExecModeAndCplAndAcFlags(pVCpu);
    33623365
    33633366        /* Done! */
    … …  
    34213424            pVCpu->cpum.GstCtx.rsp       = uNewRsp;
    34223425
    3423         iemRecalcExecModeAndCplFlags(pVCpu);
     3426        iemRecalcExecModeAndCplAndAcFlags(pVCpu);
    34243427
    34253428        /* Done! */
    … …  
    37363739    }
    37373740
    3738     iemRecalcExecModeAndCplFlags(pVCpu);
     3741    iemRecalcExecModeAndCplAndAcFlags(pVCpu);
    37393742
    37403743    /* Flush the prefetch buffer. */
    … …  
    39713974     * word as to what happens if those are not identical (probably bad things).
    39723975     */
    3973     iemRecalcExecModeAndCplFlags(pVCpu);
     3976    iemRecalcExecModeAndCplAndAcFlags(pVCpu);
    39743977    Assert(IEM_IS_16BIT_CODE(pVCpu));
    39753978
    … …  
    40584061        pVCpu->cpum.GstCtx.ss.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_D | X86DESCATTR_DT | X86_SEL_TYPE_RW_ACC;
    40594062
    4060         pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK))
     4063        pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK | IEM_F_X86_AC))
    40614064                           | IEM_F_MODE_X86_64BIT;
    40624065    }
    … …  
    40744077        pVCpu->cpum.GstCtx.ss.Attr.u     = X86DESCATTR_P | X86DESCATTR_G | X86DESCATTR_D | X86DESCATTR_DT | X86_SEL_TYPE_RW_ACC;
    40754078
    4076         pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK))
     4079        pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK | IEM_F_X86_AC))
    40774080                           | IEM_F_MODE_X86_32BIT_PROT
    40784081                           | iemCalc32BitFlatIndicatorEsDs(pVCpu);
    … …  
    42154218
    42164219    if (!f32Bit)
    4217         pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK))
     4220        pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK | IEM_F_X86_AC))
    42184221                           | (3 << IEM_F_X86_CPL_SHIFT)
    4219                            | IEM_F_MODE_X86_64BIT;
     4222                           | IEM_F_MODE_X86_64BIT
     4223                           | iemCalcExecAcFlag(pVCpu);
    42204224    else
    4221         pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK))
     4225        pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK | IEM_F_X86_AC))
    42224226                           | (3 << IEM_F_X86_CPL_SHIFT)
    42234227                           | IEM_F_MODE_X86_32BIT_PROT
    42244228                           /** @todo sort out the SS.BASE/LIM/ATTR claim by AMD and maybe we can switch to
    42254229                            * iemCalc32BitFlatIndicatorDsEs and move this up into the above branch. */
    4226                            | iemCalc32BitFlatIndicator(pVCpu);
     4230                           | iemCalc32BitFlatIndicator(pVCpu)
     4231                           | iemCalcExecAcFlag(pVCpu);
    42274232
    42284233    /* Flush the prefetch buffer. */
    … …  
    42984303        pVCpu->cpum.GstCtx.cs.Attr.u    = X86DESCATTR_L | X86DESCATTR_G | X86DESCATTR_P | X86DESCATTR_DT
    42994304                                        | X86DESCATTR_LIMIT_HIGH | X86_SEL_TYPE_ER_ACC;
    4300         pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK))
     4305        pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK | IEM_F_X86_AC))
    43014306                           | IEM_F_MODE_X86_64BIT;
    43024307    }
    … …  
    43094314        pVCpu->cpum.GstCtx.cs.Attr.u    = X86DESCATTR_D | X86DESCATTR_G | X86DESCATTR_P | X86DESCATTR_DT
    43104315                                        | X86DESCATTR_LIMIT_HIGH | X86_SEL_TYPE_ER_ACC;
    4311         pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK))
     4316        pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK | IEM_F_X86_AC))
    43124317                           | IEM_F_MODE_X86_32BIT_PROT
    43134318                           | iemCalc32BitFlatIndicatorEsDs(pVCpu);
    … …  
    44024407        pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK))
    44034408                           | (3 << IEM_F_X86_CPL_SHIFT)
    4404                            | IEM_F_MODE_X86_64BIT;
     4409                           | IEM_F_MODE_X86_64BIT
     4410                           | iemCalcExecAcFlag(pVCpu);
    44054411    }
    44064412    else
    … …  
    44204426                           | (3 << IEM_F_X86_CPL_SHIFT)
    44214427                           | IEM_F_MODE_X86_32BIT_PROT
    4422                            | iemCalc32BitFlatIndicatorEsDs(pVCpu);
     4428                           | iemCalc32BitFlatIndicatorEsDs(pVCpu)
     4429                           | iemCalcExecAcFlag(pVCpu);
    44234430    }
    44244431    pVCpu->cpum.GstCtx.cs.u64Base       = 0;
    … …  
    59915998            /* Update the fExec flags if PE changed. */
    59925999            if ((uNewCrX ^ uOldCrX) & X86_CR0_PE)
    5993                 iemRecalcExecModeAndCplFlags(pVCpu);
     6000                iemRecalcExecModeAndCplAndAcFlags(pVCpu);
    59946001
    59956002            /*

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

    r104419 r104984  
    71577157    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    71587158    IEMOP_HLP_DEFAULT_64BIT_OP_SIZE();
    7159     IEM_MC_DEFER_TO_CIMPL_1_RET(IEM_CIMPL_F_VMEXIT | IEM_CIMPL_F_RFLAGS | IEM_CIMPL_F_CHECK_IRQ_BEFORE_AND_AFTER,
     7159    IEM_MC_DEFER_TO_CIMPL_1_RET(IEM_CIMPL_F_VMEXIT | IEM_CIMPL_F_RFLAGS | IEM_CIMPL_F_MODE | IEM_CIMPL_F_CHECK_IRQ_BEFORE_AND_AFTER,
    71607160                                RT_BIT_64(kIemNativeGstReg_GprFirst + X86_GREG_xSP),
    71617161                                iemCImpl_popf, pVCpu->iem.s.enmEffOpSize);

  • trunk/src/VBox/VMM/VMMAll/IEMAllN8veRecompFuncs.h

    r104956 r104984  
    62736273DECL_INLINE_THROW(uint32_t)
    62746274iemNativeEmitMemFetchStoreDataCommon(PIEMRECOMPILERSTATE pReNative, uint32_t off,  uint8_t idxVarValue, uint8_t iSegReg,
    6275                                      uint8_t idxVarGCPtrMem, uint8_t cbMem, uint8_t fAlignMask, IEMNATIVEMITMEMOP enmOp,
     6275                                     uint8_t idxVarGCPtrMem, uint8_t cbMem, uint32_t fAlignMaskAndCtl, IEMNATIVEMITMEMOP enmOp,
    62766276                                     uintptr_t pfnFunction, uint8_t idxInstr, uint8_t offDisp = 0)
    62776277{
    … …  
    62966296    Assert(cbMem == 1 || cbMem == 2 || cbMem == 4 || cbMem == 8);
    62976297#endif
     6298    Assert(!(fAlignMaskAndCtl & ~(UINT32_C(0xff) | IEM_MEMMAP_F_ALIGN_GP | IEM_MEMMAP_F_ALIGN_SSE)));
    62986299    AssertCompile(IEMNATIVE_CALL_ARG_GREG_COUNT >= 4);
    62996300#ifdef VBOX_STRICT
    … …  
    63166317                           : enmOp == kIemNativeEmitMemOp_Fetch_Sx_U64 ? (uintptr_t)iemNativeHlpMemFlatFetchDataU8_Sx_U64
    63176318                           : UINT64_C(0xc000b000a0009000) ));
     6319                Assert(!fAlignMaskAndCtl);
    63186320                break;
    63196321            case 2:
    … …  
    63266328                           : enmOp == kIemNativeEmitMemOp_Fetch_Sx_U64 ? (uintptr_t)iemNativeHlpMemFlatFetchDataU16_Sx_U64
    63276329                           : UINT64_C(0xc000b000a0009000) ));
     6330                Assert(fAlignMaskAndCtl <= 1);
    63286331                break;
    63296332            case 4:
    … …  
    63346337                           : enmOp == kIemNativeEmitMemOp_Fetch_Sx_U64 ? (uintptr_t)iemNativeHlpMemFlatFetchDataU32_Sx_U64
    63356338                           : UINT64_C(0xc000b000a0009000) ));
     6339                Assert(fAlignMaskAndCtl <= 3);
    63366340                break;
    63376341            case 8:
    … …  
    63406344                           : enmOp == kIemNativeEmitMemOp_Fetch        ? (uintptr_t)iemNativeHlpMemFlatFetchDataU64
    63416345                           : UINT64_C(0xc000b000a0009000) ));
     6346                Assert(fAlignMaskAndCtl <= 7);
    63426347                break;
    63436348#ifdef IEMNATIVE_WITH_SIMD_REG_ALLOCATOR
    … …  
    63506355                           && (   pfnFunction == (uintptr_t)iemNativeHlpMemFlatStoreDataU128AlignedSse
    63516356                               || pfnFunction == (uintptr_t)iemNativeHlpMemFlatStoreDataU128NoAc)));
     6357                Assert(   pfnFunction == (uintptr_t)iemNativeHlpMemFlatFetchDataU128AlignedSse
     6358                       || pfnFunction == (uintptr_t)iemNativeHlpMemFlatStoreDataU128AlignedSse
     6359                       ? (fAlignMaskAndCtl & (IEM_MEMMAP_F_ALIGN_GP | IEM_MEMMAP_F_ALIGN_SSE)) && (uint8_t)fAlignMaskAndCtl == 15
     6360                       : fAlignMaskAndCtl <= 15);
    63526361                break;
    63536362            case sizeof(RTUINT256U):
    … …  
    63586367                           && (   pfnFunction == (uintptr_t)iemNativeHlpMemFlatStoreDataU256NoAc
    63596368                               || pfnFunction == (uintptr_t)iemNativeHlpMemFlatStoreDataU256AlignedAvx)));
     6369                Assert(   pfnFunction == (uintptr_t)iemNativeHlpMemFlatFetchDataU256AlignedAvx
     6370                       || pfnFunction == (uintptr_t)iemNativeHlpMemFlatStoreDataU256AlignedAvx
     6371                       ? (fAlignMaskAndCtl & IEM_MEMMAP_F_ALIGN_GP) && (uint8_t)fAlignMaskAndCtl == 31
     6372                       : fAlignMaskAndCtl <= 31);
    63606373                break;
    63616374#endif
    … …  
    63786391                           : enmOp == kIemNativeEmitMemOp_Fetch_Sx_U64 ? (uintptr_t)iemNativeHlpMemFetchDataU8_Sx_U64
    63796392                           : UINT64_C(0xc000b000a0009000) ));
     6393                Assert(!fAlignMaskAndCtl);
    63806394                break;
    63816395            case 2:
    … …  
    63886402                           : enmOp == kIemNativeEmitMemOp_Fetch_Sx_U64 ? (uintptr_t)iemNativeHlpMemFetchDataU16_Sx_U64
    63896403                           : UINT64_C(0xc000b000a0009000) ));
     6404                Assert(fAlignMaskAndCtl <= 1);
    63906405                break;
    63916406            case 4:
    … …  
    63966411                           : enmOp == kIemNativeEmitMemOp_Fetch_Sx_U64 ? (uintptr_t)iemNativeHlpMemFetchDataU32_Sx_U64
    63976412                           : UINT64_C(0xc000b000a0009000) ));
     6413                Assert(fAlignMaskAndCtl <= 3);
    63986414                break;
    63996415            case 8:
    … …  
    64026418                           : enmOp == kIemNativeEmitMemOp_Fetch        ? (uintptr_t)iemNativeHlpMemFetchDataU64
    64036419                           : UINT64_C(0xc000b000a0009000) ));
     6420                Assert(fAlignMaskAndCtl <= 7);
    64046421                break;
    64056422#ifdef IEMNATIVE_WITH_SIMD_REG_ALLOCATOR
    … …  
    64126429                           && (   pfnFunction == (uintptr_t)iemNativeHlpMemStoreDataU128AlignedSse
    64136430                               || pfnFunction == (uintptr_t)iemNativeHlpMemStoreDataU128NoAc)));
     6431                Assert(   pfnFunction == (uintptr_t)iemNativeHlpMemFetchDataU128AlignedSse
     6432                       || pfnFunction == (uintptr_t)iemNativeHlpMemStoreDataU128AlignedSse
     6433                       ? (fAlignMaskAndCtl & (IEM_MEMMAP_F_ALIGN_GP | IEM_MEMMAP_F_ALIGN_SSE)) && (uint8_t)fAlignMaskAndCtl == 15
     6434                       : fAlignMaskAndCtl <= 15);
    64146435                break;
    64156436            case sizeof(RTUINT256U):
    … …  
    64206441                           && (   pfnFunction == (uintptr_t)iemNativeHlpMemStoreDataU256NoAc
    64216442                               || pfnFunction == (uintptr_t)iemNativeHlpMemStoreDataU256AlignedAvx)));
     6443                Assert(   pfnFunction == (uintptr_t)iemNativeHlpMemFetchDataU256AlignedAvx
     6444                       || pfnFunction == (uintptr_t)iemNativeHlpMemStoreDataU256AlignedAvx
     6445                       ? (fAlignMaskAndCtl & IEM_MEMMAP_F_ALIGN_GP) && (uint8_t)fAlignMaskAndCtl == 31
     6446                       : fAlignMaskAndCtl <= 31);
    64226447                break;
    64236448#endif
    … …  
    66706695         * TlbLookup:
    66716696         */
    6672         off = iemNativeEmitTlbLookup<true>(pReNative, off, &TlbState, iSegReg, cbMem, fAlignMask,
     6697        off = iemNativeEmitTlbLookup<true>(pReNative, off, &TlbState, iSegReg, cbMem, fAlignMaskAndCtl,
    66736698                                           enmOp == kIemNativeEmitMemOp_Store ? IEM_ACCESS_TYPE_WRITE : IEM_ACCESS_TYPE_READ,
    66746699                                           idxLabelTlbLookup, idxLabelTlbMiss, idxRegMemResult, offDisp);
    … …  
    68296854    }
    68306855#else
    6831     RT_NOREF(fAlignMask, idxLabelTlbMiss);
     6856    RT_NOREF(fAlignMaskAndCtl, idxLabelTlbMiss);
    68326857#endif
    68336858
    … …  
    68466871#define IEM_MC_FETCH_MEM_U8(a_u8Dst, a_iSeg, a_GCPtrMem) \
    68476872    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u8Dst, a_iSeg, a_GCPtrMem, \
    6848                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch, \
     6873                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch, \
    68496874                                               (uintptr_t)iemNativeHlpMemFetchDataU8, pCallEntry->idxInstr)
    68506875
    68516876#define IEM_MC_FETCH_MEM_U8_ZX_U16(a_u16Dst, a_iSeg, a_GCPtrMem) \
    68526877    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u16Dst, a_iSeg, a_GCPtrMem, \
    6853                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Zx_U16, \
     6878                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Zx_U16, \
    68546879                                               (uintptr_t)iemNativeHlpMemFetchDataU8, pCallEntry->idxInstr)
    68556880
    68566881#define IEM_MC_FETCH_MEM_U8_ZX_U32(a_u32Dst, a_iSeg, a_GCPtrMem) \
    68576882    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u32Dst, a_iSeg, a_GCPtrMem, \
    6858                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Zx_U32, \
     6883                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Zx_U32, \
    68596884                                               (uintptr_t)iemNativeHlpMemFetchDataU8, pCallEntry->idxInstr)
    68606885
    68616886#define IEM_MC_FETCH_MEM_U8_ZX_U64(a_u64Dst, a_iSeg, a_GCPtrMem) \
    68626887    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u64Dst, a_iSeg, a_GCPtrMem, \
    6863                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Zx_U64, \
     6888                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Zx_U64, \
    68646889                                               (uintptr_t)iemNativeHlpMemFetchDataU8, pCallEntry->idxInstr)
    68656890
    68666891#define IEM_MC_FETCH_MEM_U8_SX_U16(a_u16Dst, a_iSeg, a_GCPtrMem) \
    68676892    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u16Dst, a_iSeg, a_GCPtrMem, \
    6868                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Sx_U16, \
     6893                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Sx_U16, \
    68696894                                               (uintptr_t)iemNativeHlpMemFetchDataU8_Sx_U16, pCallEntry->idxInstr)
    68706895
    68716896#define IEM_MC_FETCH_MEM_U8_SX_U32(a_u32Dst, a_iSeg, a_GCPtrMem) \
    68726897    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u32Dst, a_iSeg, a_GCPtrMem, \
    6873                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Sx_U32, \
     6898                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Sx_U32, \
    68746899                                               (uintptr_t)iemNativeHlpMemFetchDataU8_Sx_U32, pCallEntry->idxInstr)
    68756900
    68766901#define IEM_MC_FETCH_MEM_U8_SX_U64(a_u64Dst, a_iSeg, a_GCPtrMem) \
    68776902    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u64Dst, a_iSeg, a_GCPtrMem, \
    6878                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Sx_U64, \
     6903                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Sx_U64, \
    68796904                                               (uintptr_t)iemNativeHlpMemFetchDataU8_Sx_U64, pCallEntry->idxInstr)
    68806905
    … …  
    69706995#define IEM_MC_FETCH_MEM_FLAT_U8(a_u8Dst, a_GCPtrMem) \
    69716996    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u8Dst, UINT8_MAX, a_GCPtrMem, \
    6972                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch, \
     6997                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch, \
    69736998                                               (uintptr_t)iemNativeHlpMemFlatFetchDataU8, pCallEntry->idxInstr)
    69746999
    69757000#define IEM_MC_FETCH_MEM_FLAT_U8_ZX_U16(a_u16Dst, a_GCPtrMem) \
    69767001    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u16Dst, UINT8_MAX, a_GCPtrMem, \
    6977                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Zx_U16, \
     7002                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Zx_U16, \
    69787003                                               (uintptr_t)iemNativeHlpMemFlatFetchDataU8, pCallEntry->idxInstr)
    69797004
    69807005#define IEM_MC_FETCH_MEM_FLAT_U8_ZX_U32(a_u32Dst, a_GCPtrMem) \
    69817006    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u32Dst, UINT8_MAX, a_GCPtrMem, \
    6982                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Zx_U32, \
     7007                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Zx_U32, \
    69837008                                               (uintptr_t)iemNativeHlpMemFlatFetchDataU8, pCallEntry->idxInstr)
    69847009
    69857010#define IEM_MC_FETCH_MEM_FLAT_U8_ZX_U64(a_u64Dst, a_GCPtrMem) \
    69867011    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u64Dst, UINT8_MAX, a_GCPtrMem, \
    6987                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Zx_U64, \
     7012                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Zx_U64, \
    69887013                                               (uintptr_t)iemNativeHlpMemFlatFetchDataU8, pCallEntry->idxInstr)
    69897014
    69907015#define IEM_MC_FETCH_MEM_FLAT_U8_SX_U16(a_u16Dst, a_GCPtrMem) \
    69917016    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u16Dst, UINT8_MAX, a_GCPtrMem, \
    6992                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Sx_U16, \
     7017                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Sx_U16, \
    69937018                                               (uintptr_t)iemNativeHlpMemFlatFetchDataU8_Sx_U16, pCallEntry->idxInstr)
    69947019
    69957020#define IEM_MC_FETCH_MEM_FLAT_U8_SX_U32(a_u32Dst, a_GCPtrMem) \
    69967021    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u32Dst, UINT8_MAX, a_GCPtrMem, \
    6997                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Sx_U32, \
     7022                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Sx_U32, \
    69987023                                               (uintptr_t)iemNativeHlpMemFlatFetchDataU8_Sx_U32, pCallEntry->idxInstr)
    69997024
    70007025#define IEM_MC_FETCH_MEM_FLAT_U8_SX_U64(a_u64Dst, a_GCPtrMem) \
    70017026    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u64Dst, UINT8_MAX, a_GCPtrMem, \
    7002                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Fetch_Sx_U64, \
     7027                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Fetch_Sx_U64, \
    70037028                                               (uintptr_t)iemNativeHlpMemFlatFetchDataU8_Sx_U64, pCallEntry->idxInstr)
    70047029
    … …  
    70967121
    70977122#define IEM_MC_FETCH_MEM_U128_ALIGN_SSE(a_u128Dst, a_iSeg, a_GCPtrMem) \
    7098     off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u128Dst, a_iSeg, a_GCPtrMem, \
    7099                                                sizeof(RTUINT128U), sizeof(RTUINT128U) - 1, kIemNativeEmitMemOp_Fetch, \
     7123    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u128Dst, a_iSeg, a_GCPtrMem, sizeof(RTUINT128U), \
     7124                                               (sizeof(RTUINT128U) - 1U) | IEM_MEMMAP_F_ALIGN_GP | IEM_MEMMAP_F_ALIGN_SSE, \
     7125                                               kIemNativeEmitMemOp_Fetch, \
    71007126                                               (uintptr_t)iemNativeHlpMemFetchDataU128AlignedSse, pCallEntry->idxInstr)
    71017127
    71027128AssertCompileSize(X86XMMREG, sizeof(RTUINT128U));
    71037129#define IEM_MC_FETCH_MEM_XMM_ALIGN_SSE(a_uXmmDst, a_iSeg, a_GCPtrMem) \
    7104     off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_uXmmDst, a_iSeg, a_GCPtrMem, \
    7105                                                sizeof(X86XMMREG), sizeof(X86XMMREG) - 1, kIemNativeEmitMemOp_Fetch, \
     7130    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_uXmmDst, a_iSeg, a_GCPtrMem, sizeof(X86XMMREG), \
     7131                                               (sizeof(X86XMMREG) - 1U) | IEM_MEMMAP_F_ALIGN_GP | IEM_MEMMAP_F_ALIGN_SSE, \
     7132                                               kIemNativeEmitMemOp_Fetch, \
    71067133                                               (uintptr_t)iemNativeHlpMemFetchDataU128AlignedSse, pCallEntry->idxInstr)
    71077134
    … …  
    71187145
    71197146#define IEM_MC_FETCH_MEM_FLAT_U128_ALIGN_SSE(a_u128Dst, a_GCPtrMem) \
    7120     off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u128Dst, UINT8_MAX, a_GCPtrMem, \
    7121                                                sizeof(RTUINT128U), sizeof(RTUINT128U) - 1, kIemNativeEmitMemOp_Fetch, \
     7147    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u128Dst, UINT8_MAX, a_GCPtrMem, sizeof(RTUINT128U), \
     7148                                               (sizeof(RTUINT128U) - 1U) | IEM_MEMMAP_F_ALIGN_GP | IEM_MEMMAP_F_ALIGN_SSE, \
     7149                                               kIemNativeEmitMemOp_Fetch, \
    71227150                                               (uintptr_t)iemNativeHlpMemFlatFetchDataU128AlignedSse, pCallEntry->idxInstr)
    71237151
    71247152#define IEM_MC_FETCH_MEM_FLAT_XMM_ALIGN_SSE(a_uXmmDst, a_GCPtrMem) \
    7125     off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_uXmmDst, UINT8_MAX, a_GCPtrMem, \
    7126                                                sizeof(X86XMMREG), sizeof(X86XMMREG) - 1, kIemNativeEmitMemOp_Fetch, \
     7153    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_uXmmDst, UINT8_MAX, a_GCPtrMem, sizeof(X86XMMREG), \
     7154                                               (sizeof(X86XMMREG) - 1U) | IEM_MEMMAP_F_ALIGN_GP | IEM_MEMMAP_F_ALIGN_SSE, \
     7155                                               kIemNativeEmitMemOp_Fetch, \
    71277156                                               (uintptr_t)iemNativeHlpMemFlatFetchDataU128AlignedSse, pCallEntry->idxInstr)
    71287157
    … …  
    71447173
    71457174#define IEM_MC_FETCH_MEM_U256_ALIGN_AVX(a_u256Dst, a_iSeg, a_GCPtrMem) \
    7146     off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u256Dst, a_iSeg, a_GCPtrMem, \
    7147                                                sizeof(RTUINT256U), sizeof(RTUINT256U) - 1, kIemNativeEmitMemOp_Fetch, \
     7175    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u256Dst, a_iSeg, a_GCPtrMem, sizeof(RTUINT256U), \
     7176                                               (sizeof(RTUINT256U) - 1U) | IEM_MEMMAP_F_ALIGN_GP, kIemNativeEmitMemOp_Fetch, \
    71487177                                               (uintptr_t)iemNativeHlpMemFetchDataU256AlignedAvx, pCallEntry->idxInstr)
    71497178
    … …  
    71617190
    71627191#define IEM_MC_FETCH_MEM_FLAT_U256_ALIGN_AVX(a_u256Dst, a_GCPtrMem) \
    7163     off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u256Dst, UINT8_MAX, a_GCPtrMem, \
    7164                                                sizeof(RTUINT256U), sizeof(RTUINT256U) - 1, kIemNativeEmitMemOp_Fetch, \
     7192    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u256Dst, UINT8_MAX, a_GCPtrMem, sizeof(RTUINT256U), \
     7193                                               (sizeof(RTUINT256U) - 1U) | IEM_MEMMAP_F_ALIGN_GP, kIemNativeEmitMemOp_Fetch, \
    71657194                                               (uintptr_t)iemNativeHlpMemFlatFetchDataU256AlignedAvx, pCallEntry->idxInstr)
    71667195#endif
    … …  
    71737202#define IEM_MC_STORE_MEM_U8(a_iSeg, a_GCPtrMem, a_u8Value) \
    71747203    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u8Value, a_iSeg, a_GCPtrMem, \
    7175                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Store, \
     7204                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Store, \
    71767205                                               (uintptr_t)iemNativeHlpMemStoreDataU8, pCallEntry->idxInstr)
    71777206
    … …  
    71947223#define IEM_MC_STORE_MEM_FLAT_U8(a_GCPtrMem, a_u8Value) \
    71957224    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u8Value, UINT8_MAX, a_GCPtrMem, \
    7196                                                sizeof(uint8_t), 0 /*fAlignMask*/, kIemNativeEmitMemOp_Store, \
     7225                                               sizeof(uint8_t), 0 /*fAlignMaskAndCtl*/, kIemNativeEmitMemOp_Store, \
    71977226                                               (uintptr_t)iemNativeHlpMemFlatStoreDataU8, pCallEntry->idxInstr)
    71987227
    … …  
    72677296#ifdef IEMNATIVE_WITH_SIMD_REG_ALLOCATOR
    72687297# define IEM_MC_STORE_MEM_U128_ALIGN_SSE(a_iSeg, a_GCPtrMem, a_u128Value) \
    7269     off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u128Value, a_iSeg, a_GCPtrMem, \
    7270                                                sizeof(RTUINT128U), sizeof(RTUINT128U) - 1, kIemNativeEmitMemOp_Store, \
     7298    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u128Value, a_iSeg, a_GCPtrMem, sizeof(RTUINT128U), \
     7299                                               (sizeof(RTUINT128U) - 1U) | IEM_MEMMAP_F_ALIGN_GP | IEM_MEMMAP_F_ALIGN_SSE, \
     7300                                               kIemNativeEmitMemOp_Store, \
    72717301                                               (uintptr_t)iemNativeHlpMemStoreDataU128AlignedSse, pCallEntry->idxInstr)
    72727302
    … …  
    72827312
    72837313# define IEM_MC_STORE_MEM_U256_ALIGN_AVX(a_iSeg, a_GCPtrMem, a_u256Value) \
    7284     off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u256Value, a_iSeg, a_GCPtrMem, \
    7285                                                sizeof(RTUINT256U), sizeof(RTUINT256U) - 1, kIemNativeEmitMemOp_Store, \
     7314    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u256Value, a_iSeg, a_GCPtrMem, sizeof(RTUINT256U), \
     7315                                               (sizeof(RTUINT256U) - 1U) | IEM_MEMMAP_F_ALIGN_GP, kIemNativeEmitMemOp_Store, \
    72867316                                               (uintptr_t)iemNativeHlpMemStoreDataU256AlignedAvx, pCallEntry->idxInstr)
    72877317
    72887318
    72897319# define IEM_MC_STORE_MEM_FLAT_U128_ALIGN_SSE(a_GCPtrMem, a_u128Value) \
    7290     off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u128Value, UINT8_MAX, a_GCPtrMem, \
    7291                                                sizeof(RTUINT128U), sizeof(RTUINT128U) - 1, kIemNativeEmitMemOp_Store, \
     7320    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u128Value, UINT8_MAX, a_GCPtrMem, sizeof(RTUINT128U), \
     7321                                               (sizeof(RTUINT128U) - 1U) | IEM_MEMMAP_F_ALIGN_GP | IEM_MEMMAP_F_ALIGN_SSE, \
     7322                                               kIemNativeEmitMemOp_Store, \
    72927323                                               (uintptr_t)iemNativeHlpMemFlatStoreDataU128AlignedSse, pCallEntry->idxInstr)
    72937324
    … …  
    73037334
    73047335# define IEM_MC_STORE_MEM_FLAT_U256_ALIGN_AVX(a_GCPtrMem, a_u256Value) \
    7305     off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u256Value, UINT8_MAX, a_GCPtrMem, \
    7306                                                sizeof(RTUINT256U), sizeof(RTUINT256U) - 1, kIemNativeEmitMemOp_Store, \
     7336    off = iemNativeEmitMemFetchStoreDataCommon(pReNative, off, a_u256Value, UINT8_MAX, a_GCPtrMem, sizeof(RTUINT256U), \
     7337                                               (sizeof(RTUINT256U) - 1U) | IEM_MEMMAP_F_ALIGN_GP, kIemNativeEmitMemOp_Store, \
    73077338                                               (uintptr_t)iemNativeHlpMemFlatStoreDataU256AlignedAvx, pCallEntry->idxInstr)
    73087339#endif
    … …  
    80238054#define IEM_MC_MEM_MAP_U8_ATOMIC(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80248055    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint8_t), \
    8025                                     IEM_ACCESS_DATA_ATOMIC,  0 /*fAlignMask*/, \
     8056                                    IEM_ACCESS_DATA_ATOMIC,  0 /*fAlignMaskAndCtl*/, \
    80268057                                    (uintptr_t)iemNativeHlpMemMapDataU8Atomic, pCallEntry->idxInstr)
    80278058
    80288059#define IEM_MC_MEM_MAP_U8_RW(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80298060    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint8_t), \
    8030                                     IEM_ACCESS_DATA_RW,  0 /*fAlignMask*/, \
     8061                                    IEM_ACCESS_DATA_RW,  0 /*fAlignMaskAndCtl*/, \
    80318062                                    (uintptr_t)iemNativeHlpMemMapDataU8Rw, pCallEntry->idxInstr)
    80328063
    80338064#define IEM_MC_MEM_MAP_U8_WO(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80348065    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint8_t), \
    8035                                     IEM_ACCESS_DATA_W,  0 /*fAlignMask*/, \
     8066                                    IEM_ACCESS_DATA_W,  0 /*fAlignMaskAndCtl*/, \
    80368067                                    (uintptr_t)iemNativeHlpMemMapDataU8Wo, pCallEntry->idxInstr) \
    80378068
    80388069#define IEM_MC_MEM_MAP_U8_RO(a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80398070    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu8Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint8_t), \
    8040                                     IEM_ACCESS_DATA_R,  0 /*fAlignMask*/, \
     8071                                    IEM_ACCESS_DATA_R,  0 /*fAlignMaskAndCtl*/, \
    80418072                                    (uintptr_t)iemNativeHlpMemMapDataU8Ro, pCallEntry->idxInstr)
    80428073
    … …  
    80448075#define IEM_MC_MEM_MAP_U16_ATOMIC(a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80458076    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint16_t), \
    8046                                     IEM_ACCESS_DATA_ATOMIC,  sizeof(uint16_t) - 1 /*fAlignMask*/, \
     8077                                    IEM_ACCESS_DATA_ATOMIC,  sizeof(uint16_t) - 1 /*fAlignMaskAndCtl*/, \
    80478078                                    (uintptr_t)iemNativeHlpMemMapDataU16Atomic, pCallEntry->idxInstr)
    80488079
    80498080#define IEM_MC_MEM_MAP_U16_RW(a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80508081    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint16_t), \
    8051                                     IEM_ACCESS_DATA_RW,  sizeof(uint16_t) - 1 /*fAlignMask*/, \
     8082                                    IEM_ACCESS_DATA_RW,  sizeof(uint16_t) - 1 /*fAlignMaskAndCtl*/, \
    80528083                                    (uintptr_t)iemNativeHlpMemMapDataU16Rw, pCallEntry->idxInstr)
    80538084
    80548085#define IEM_MC_MEM_MAP_U16_WO(a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80558086    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint16_t), \
    8056                                     IEM_ACCESS_DATA_W, sizeof(uint16_t) - 1 /*fAlignMask*/, \
     8087                                    IEM_ACCESS_DATA_W, sizeof(uint16_t) - 1 /*fAlignMaskAndCtl*/, \
    80578088                                    (uintptr_t)iemNativeHlpMemMapDataU16Wo, pCallEntry->idxInstr) \
    80588089
    80598090#define IEM_MC_MEM_MAP_U16_RO(a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80608091    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint16_t), \
    8061                                     IEM_ACCESS_DATA_R,  sizeof(uint16_t) - 1 /*fAlignMask*/, \
     8092                                    IEM_ACCESS_DATA_R,  sizeof(uint16_t) - 1 /*fAlignMaskAndCtl*/, \
    80628093                                    (uintptr_t)iemNativeHlpMemMapDataU16Ro, pCallEntry->idxInstr)
    80638094
    80648095#define IEM_MC_MEM_MAP_I16_WO(a_pi16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80658096    off = iemNativeEmitMemMapCommon(pReNative, off, a_pi16Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(int16_t), \
    8066                                     IEM_ACCESS_DATA_W, sizeof(uint16_t) - 1 /*fAlignMask*/, \
     8097                                    IEM_ACCESS_DATA_W, sizeof(uint16_t) - 1 /*fAlignMaskAndCtl*/, \
    80678098                                    (uintptr_t)iemNativeHlpMemMapDataU16Wo, pCallEntry->idxInstr) \
    80688099
    … …  
    80708101#define IEM_MC_MEM_MAP_U32_ATOMIC(a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80718102    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint32_t), \
    8072                                     IEM_ACCESS_DATA_ATOMIC, sizeof(uint32_t) - 1 /*fAlignMask*/, \
     8103                                    IEM_ACCESS_DATA_ATOMIC, sizeof(uint32_t) - 1 /*fAlignMaskAndCtl*/, \
    80738104                                    (uintptr_t)iemNativeHlpMemMapDataU32Atomic, pCallEntry->idxInstr)
    80748105
    80758106#define IEM_MC_MEM_MAP_U32_RW(a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80768107    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint32_t), \
    8077                                     IEM_ACCESS_DATA_RW, sizeof(uint32_t) - 1 /*fAlignMask*/, \
     8108                                    IEM_ACCESS_DATA_RW, sizeof(uint32_t) - 1 /*fAlignMaskAndCtl*/, \
    80788109                                    (uintptr_t)iemNativeHlpMemMapDataU32Rw, pCallEntry->idxInstr)
    80798110
    80808111#define IEM_MC_MEM_MAP_U32_WO(a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80818112    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint32_t), \
    8082                                     IEM_ACCESS_DATA_W, sizeof(uint32_t) - 1 /*fAlignMask*/, \
     8113                                    IEM_ACCESS_DATA_W, sizeof(uint32_t) - 1 /*fAlignMaskAndCtl*/, \
    80838114                                    (uintptr_t)iemNativeHlpMemMapDataU32Wo, pCallEntry->idxInstr) \
    80848115
    80858116#define IEM_MC_MEM_MAP_U32_RO(a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80868117    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint32_t), \
    8087                                     IEM_ACCESS_DATA_R,  sizeof(uint32_t) - 1 /*fAlignMask*/, \
     8118                                    IEM_ACCESS_DATA_R,  sizeof(uint32_t) - 1 /*fAlignMaskAndCtl*/, \
    80888119                                    (uintptr_t)iemNativeHlpMemMapDataU32Ro, pCallEntry->idxInstr)
    80898120
    80908121#define IEM_MC_MEM_MAP_I32_WO(a_pi32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80918122    off = iemNativeEmitMemMapCommon(pReNative, off, a_pi32Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(int32_t), \
    8092                                     IEM_ACCESS_DATA_W, sizeof(uint32_t) - 1 /*fAlignMask*/, \
     8123                                    IEM_ACCESS_DATA_W, sizeof(uint32_t) - 1 /*fAlignMaskAndCtl*/, \
    80938124                                    (uintptr_t)iemNativeHlpMemMapDataU32Wo, pCallEntry->idxInstr) \
    80948125
    … …  
    80968127#define IEM_MC_MEM_MAP_U64_ATOMIC(a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    80978128    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint64_t), \
    8098                                     IEM_ACCESS_DATA_ATOMIC, sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8129                                    IEM_ACCESS_DATA_ATOMIC, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    80998130                                    (uintptr_t)iemNativeHlpMemMapDataU64Atomic, pCallEntry->idxInstr)
    81008131
    81018132#define IEM_MC_MEM_MAP_U64_RW(a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    81028133    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint64_t), \
    8103                                     IEM_ACCESS_DATA_RW, sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8134                                    IEM_ACCESS_DATA_RW, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    81048135                                    (uintptr_t)iemNativeHlpMemMapDataU64Rw, pCallEntry->idxInstr)
    81058136#define IEM_MC_MEM_MAP_U64_WO(a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    81068137    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint64_t), \
    8107                                     IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8138                                    IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    81088139                                    (uintptr_t)iemNativeHlpMemMapDataU64Wo, pCallEntry->idxInstr) \
    81098140
    81108141#define IEM_MC_MEM_MAP_U64_RO(a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    81118142    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(uint64_t), \
    8112                                     IEM_ACCESS_DATA_R,  sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8143                                    IEM_ACCESS_DATA_R,  sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    81138144                                    (uintptr_t)iemNativeHlpMemMapDataU64Ro, pCallEntry->idxInstr)
    81148145
    81158146#define IEM_MC_MEM_MAP_I64_WO(a_pi64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    81168147    off = iemNativeEmitMemMapCommon(pReNative, off, a_pi64Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(int64_t), \
    8117                                     IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8148                                    IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    81188149                                    (uintptr_t)iemNativeHlpMemMapDataU64Wo, pCallEntry->idxInstr) \
    81198150
    … …  
    81218152#define IEM_MC_MEM_MAP_R80_WO(a_pr80Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    81228153    off = iemNativeEmitMemMapCommon(pReNative, off, a_pr80Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(RTFLOAT80U), \
    8123                                     IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8154                                    IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    81248155                                    (uintptr_t)iemNativeHlpMemMapDataR80Wo, pCallEntry->idxInstr) \
    81258156
    81268157#define IEM_MC_MEM_MAP_D80_WO(a_pd80Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    81278158    off = iemNativeEmitMemMapCommon(pReNative, off, a_pd80Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(RTFLOAT80U), \
    8128                                     IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMask*/, /** @todo check BCD align */ \
     8159                                    IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, /** @todo check BCD align */ \
    81298160                                    (uintptr_t)iemNativeHlpMemMapDataD80Wo, pCallEntry->idxInstr) \
    81308161
    … …  
    81328163#define IEM_MC_MEM_MAP_U128_ATOMIC(a_pu128Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    81338164    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu128Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(RTUINT128U), \
    8134                                     IEM_ACCESS_DATA_ATOMIC, sizeof(RTUINT128U) - 1 /*fAlignMask*/, \
     8165                                    IEM_ACCESS_DATA_ATOMIC, sizeof(RTUINT128U) - 1 /*fAlignMaskAndCtl*/, \
    81358166                                    (uintptr_t)iemNativeHlpMemMapDataU128Atomic, pCallEntry->idxInstr)
    81368167
    81378168#define IEM_MC_MEM_MAP_U128_RW(a_pu128Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    81388169    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu128Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(RTUINT128U), \
    8139                                     IEM_ACCESS_DATA_RW, sizeof(RTUINT128U) - 1 /*fAlignMask*/, \
     8170                                    IEM_ACCESS_DATA_RW, sizeof(RTUINT128U) - 1 /*fAlignMaskAndCtl*/, \
    81408171                                    (uintptr_t)iemNativeHlpMemMapDataU128Rw, pCallEntry->idxInstr)
    81418172
    81428173#define IEM_MC_MEM_MAP_U128_WO(a_pu128Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    81438174    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu128Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(RTUINT128U), \
    8144                                     IEM_ACCESS_DATA_W, sizeof(RTUINT128U) - 1 /*fAlignMask*/, \
     8175                                    IEM_ACCESS_DATA_W, sizeof(RTUINT128U) - 1 /*fAlignMaskAndCtl*/, \
    81458176                                    (uintptr_t)iemNativeHlpMemMapDataU128Wo, pCallEntry->idxInstr) \
    81468177
    81478178#define IEM_MC_MEM_MAP_U128_RO(a_pu128Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem) \
    81488179    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu128Mem, a_bUnmapInfo, a_iSeg, a_GCPtrMem, sizeof(RTUINT128U), \
    8149                                     IEM_ACCESS_DATA_R,  sizeof(RTUINT128U) - 1 /*fAlignMask*/, \
     8180                                    IEM_ACCESS_DATA_R,  sizeof(RTUINT128U) - 1 /*fAlignMaskAndCtl*/, \
    81508181                                    (uintptr_t)iemNativeHlpMemMapDataU128Ro, pCallEntry->idxInstr)
    81518182
    … …  
    81548185#define IEM_MC_MEM_FLAT_MAP_U8_ATOMIC(a_pu8Mem, a_bUnmapInfo, a_GCPtrMem) \
    81558186    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu8Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint8_t), \
    8156                                     IEM_ACCESS_DATA_ATOMIC,  0 /*fAlignMask*/, \
     8187                                    IEM_ACCESS_DATA_ATOMIC,  0 /*fAlignMaskAndCtl*/, \
    81578188                                    (uintptr_t)iemNativeHlpMemFlatMapDataU8Atomic, pCallEntry->idxInstr)
    81588189
    81598190#define IEM_MC_MEM_FLAT_MAP_U8_RW(a_pu8Mem, a_bUnmapInfo, a_GCPtrMem) \
    81608191    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu8Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint8_t), \
    8161                                     IEM_ACCESS_DATA_RW,  0 /*fAlignMask*/, \
     8192                                    IEM_ACCESS_DATA_RW,  0 /*fAlignMaskAndCtl*/, \
    81628193                                    (uintptr_t)iemNativeHlpMemFlatMapDataU8Rw, pCallEntry->idxInstr)
    81638194
    81648195#define IEM_MC_MEM_FLAT_MAP_U8_WO(a_pu8Mem, a_bUnmapInfo, a_GCPtrMem) \
    81658196    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu8Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint8_t), \
    8166                                     IEM_ACCESS_DATA_W,  0 /*fAlignMask*/, \
     8197                                    IEM_ACCESS_DATA_W,  0 /*fAlignMaskAndCtl*/, \
    81678198                                    (uintptr_t)iemNativeHlpMemFlatMapDataU8Wo, pCallEntry->idxInstr) \
    81688199
    81698200#define IEM_MC_MEM_FLAT_MAP_U8_RO(a_pu8Mem, a_bUnmapInfo, a_GCPtrMem) \
    81708201    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu8Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint8_t), \
    8171                                     IEM_ACCESS_DATA_R,  0 /*fAlignMask*/, \
     8202                                    IEM_ACCESS_DATA_R,  0 /*fAlignMaskAndCtl*/, \
    81728203                                    (uintptr_t)iemNativeHlpMemFlatMapDataU8Ro, pCallEntry->idxInstr)
    81738204
    … …  
    81758206#define IEM_MC_MEM_FLAT_MAP_U16_ATOMIC(a_pu16Mem, a_bUnmapInfo, a_GCPtrMem) \
    81768207    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu16Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint16_t), \
    8177                                     IEM_ACCESS_DATA_ATOMIC,  sizeof(uint16_t) - 1 /*fAlignMask*/, \
     8208                                    IEM_ACCESS_DATA_ATOMIC,  sizeof(uint16_t) - 1 /*fAlignMaskAndCtl*/, \
    81788209                                    (uintptr_t)iemNativeHlpMemFlatMapDataU16Atomic, pCallEntry->idxInstr)
    81798210
    81808211#define IEM_MC_MEM_FLAT_MAP_U16_RW(a_pu16Mem, a_bUnmapInfo, a_GCPtrMem) \
    81818212    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu16Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint16_t), \
    8182                                     IEM_ACCESS_DATA_RW,  sizeof(uint16_t) - 1 /*fAlignMask*/, \
     8213                                    IEM_ACCESS_DATA_RW,  sizeof(uint16_t) - 1 /*fAlignMaskAndCtl*/, \
    81838214                                    (uintptr_t)iemNativeHlpMemFlatMapDataU16Rw, pCallEntry->idxInstr)
    81848215
    81858216#define IEM_MC_MEM_FLAT_MAP_U16_WO(a_pu16Mem, a_bUnmapInfo, a_GCPtrMem) \
    81868217    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu16Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint16_t), \
    8187                                     IEM_ACCESS_DATA_W, sizeof(uint16_t) - 1 /*fAlignMask*/, \
     8218                                    IEM_ACCESS_DATA_W, sizeof(uint16_t) - 1 /*fAlignMaskAndCtl*/, \
    81888219                                    (uintptr_t)iemNativeHlpMemFlatMapDataU16Wo, pCallEntry->idxInstr) \
    81898220
    81908221#define IEM_MC_MEM_FLAT_MAP_U16_RO(a_pu16Mem, a_bUnmapInfo, a_GCPtrMem) \
    81918222    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu16Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint16_t), \
    8192                                     IEM_ACCESS_DATA_R,  sizeof(uint16_t) - 1 /*fAlignMask*/, \
     8223                                    IEM_ACCESS_DATA_R,  sizeof(uint16_t) - 1 /*fAlignMaskAndCtl*/, \
    81938224                                    (uintptr_t)iemNativeHlpMemFlatMapDataU16Ro, pCallEntry->idxInstr)
    81948225
    81958226#define IEM_MC_MEM_FLAT_MAP_I16_WO(a_pi16Mem, a_bUnmapInfo, a_GCPtrMem) \
    81968227    off = iemNativeEmitMemMapCommon(pReNative, off, a_pi16Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(int16_t), \
    8197                                     IEM_ACCESS_DATA_W, sizeof(uint16_t) - 1 /*fAlignMask*/, \
     8228                                    IEM_ACCESS_DATA_W, sizeof(uint16_t) - 1 /*fAlignMaskAndCtl*/, \
    81988229                                    (uintptr_t)iemNativeHlpMemFlatMapDataU16Wo, pCallEntry->idxInstr) \
    81998230
    … …  
    82018232#define IEM_MC_MEM_FLAT_MAP_U32_ATOMIC(a_pu32Mem, a_bUnmapInfo, a_GCPtrMem) \
    82028233    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu32Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint32_t), \
    8203                                     IEM_ACCESS_DATA_ATOMIC, sizeof(uint32_t) - 1 /*fAlignMask*/, \
     8234                                    IEM_ACCESS_DATA_ATOMIC, sizeof(uint32_t) - 1 /*fAlignMaskAndCtl*/, \
    82048235                                    (uintptr_t)iemNativeHlpMemFlatMapDataU32Atomic, pCallEntry->idxInstr)
    82058236
    82068237#define IEM_MC_MEM_FLAT_MAP_U32_RW(a_pu32Mem, a_bUnmapInfo, a_GCPtrMem) \
    82078238    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu32Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint32_t), \
    8208                                     IEM_ACCESS_DATA_RW, sizeof(uint32_t) - 1 /*fAlignMask*/, \
     8239                                    IEM_ACCESS_DATA_RW, sizeof(uint32_t) - 1 /*fAlignMaskAndCtl*/, \
    82098240                                    (uintptr_t)iemNativeHlpMemFlatMapDataU32Rw, pCallEntry->idxInstr)
    82108241
    82118242#define IEM_MC_MEM_FLAT_MAP_U32_WO(a_pu32Mem, a_bUnmapInfo, a_GCPtrMem) \
    82128243    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu32Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint32_t), \
    8213                                     IEM_ACCESS_DATA_W, sizeof(uint32_t) - 1 /*fAlignMask*/, \
     8244                                    IEM_ACCESS_DATA_W, sizeof(uint32_t) - 1 /*fAlignMaskAndCtl*/, \
    82148245                                    (uintptr_t)iemNativeHlpMemFlatMapDataU32Wo, pCallEntry->idxInstr) \
    82158246
    82168247#define IEM_MC_MEM_FLAT_MAP_U32_RO(a_pu32Mem, a_bUnmapInfo, a_GCPtrMem) \
    82178248    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu32Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint32_t), \
    8218                                     IEM_ACCESS_DATA_R,  sizeof(uint32_t) - 1 /*fAlignMask*/, \
     8249                                    IEM_ACCESS_DATA_R,  sizeof(uint32_t) - 1 /*fAlignMaskAndCtl*/, \
    82198250                                    (uintptr_t)iemNativeHlpMemFlatMapDataU32Ro, pCallEntry->idxInstr)
    82208251
    82218252#define IEM_MC_MEM_FLAT_MAP_I32_WO(a_pi32Mem, a_bUnmapInfo, a_GCPtrMem) \
    82228253    off = iemNativeEmitMemMapCommon(pReNative, off, a_pi32Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(int32_t), \
    8223                                     IEM_ACCESS_DATA_W, sizeof(uint32_t) - 1 /*fAlignMask*/, \
     8254                                    IEM_ACCESS_DATA_W, sizeof(uint32_t) - 1 /*fAlignMaskAndCtl*/, \
    82248255                                    (uintptr_t)iemNativeHlpMemFlatMapDataU32Wo, pCallEntry->idxInstr) \
    82258256
    … …  
    82278258#define IEM_MC_MEM_FLAT_MAP_U64_ATOMIC(a_pu64Mem, a_bUnmapInfo, a_GCPtrMem) \
    82288259    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu64Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint64_t), \
    8229                                     IEM_ACCESS_DATA_ATOMIC, sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8260                                    IEM_ACCESS_DATA_ATOMIC, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    82308261                                    (uintptr_t)iemNativeHlpMemFlatMapDataU64Atomic, pCallEntry->idxInstr)
    82318262
    82328263#define IEM_MC_MEM_FLAT_MAP_U64_RW(a_pu64Mem, a_bUnmapInfo, a_GCPtrMem) \
    82338264    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu64Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint64_t), \
    8234                                     IEM_ACCESS_DATA_RW, sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8265                                    IEM_ACCESS_DATA_RW, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    82358266                                    (uintptr_t)iemNativeHlpMemFlatMapDataU64Rw, pCallEntry->idxInstr)
    82368267
    82378268#define IEM_MC_MEM_FLAT_MAP_U64_WO(a_pu64Mem, a_bUnmapInfo, a_GCPtrMem) \
    82388269    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu64Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint64_t), \
    8239                                     IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8270                                    IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    82408271                                    (uintptr_t)iemNativeHlpMemFlatMapDataU64Wo, pCallEntry->idxInstr) \
    82418272
    82428273#define IEM_MC_MEM_FLAT_MAP_U64_RO(a_pu64Mem, a_bUnmapInfo, a_GCPtrMem) \
    82438274    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu64Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(uint64_t), \
    8244                                     IEM_ACCESS_DATA_R,  sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8275                                    IEM_ACCESS_DATA_R,  sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    82458276                                    (uintptr_t)iemNativeHlpMemFlatMapDataU64Ro, pCallEntry->idxInstr)
    82468277
    82478278#define IEM_MC_MEM_FLAT_MAP_I64_WO(a_pi64Mem, a_bUnmapInfo, a_GCPtrMem) \
    82488279    off = iemNativeEmitMemMapCommon(pReNative, off, a_pi64Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(int64_t), \
    8249                                     IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8280                                    IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    82508281                                    (uintptr_t)iemNativeHlpMemFlatMapDataU64Wo, pCallEntry->idxInstr) \
    82518282
    … …  
    82538284#define IEM_MC_MEM_FLAT_MAP_R80_WO(a_pr80Mem, a_bUnmapInfo, a_GCPtrMem) \
    82548285    off = iemNativeEmitMemMapCommon(pReNative, off, a_pr80Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(RTFLOAT80U), \
    8255                                     IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMask*/, \
     8286                                    IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, \
    82568287                                    (uintptr_t)iemNativeHlpMemFlatMapDataR80Wo, pCallEntry->idxInstr) \
    82578288
    82588289#define IEM_MC_MEM_FLAT_MAP_D80_WO(a_pd80Mem, a_bUnmapInfo, a_GCPtrMem) \
    82598290    off = iemNativeEmitMemMapCommon(pReNative, off, a_pd80Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(RTFLOAT80U), \
    8260                                     IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMask*/, /** @todo check BCD align */ \
     8291                                    IEM_ACCESS_DATA_W, sizeof(uint64_t) - 1 /*fAlignMaskAndCtl*/, /** @todo check BCD align */ \
    82618292                                    (uintptr_t)iemNativeHlpMemFlatMapDataD80Wo, pCallEntry->idxInstr) \
    82628293
    … …  
    82648295#define IEM_MC_MEM_FLAT_MAP_U128_ATOMIC(a_pu128Mem, a_bUnmapInfo, a_GCPtrMem) \
    82658296    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu128Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(RTUINT128U), \
    8266                                     IEM_ACCESS_DATA_ATOMIC, sizeof(RTUINT128U) - 1 /*fAlignMask*/, \
     8297                                    IEM_ACCESS_DATA_ATOMIC, sizeof(RTUINT128U) - 1 /*fAlignMaskAndCtl*/, \
    82678298                                    (uintptr_t)iemNativeHlpMemFlatMapDataU128Atomic, pCallEntry->idxInstr)
    82688299
    82698300#define IEM_MC_MEM_FLAT_MAP_U128_RW(a_pu128Mem, a_bUnmapInfo, a_GCPtrMem) \
    82708301    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu128Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(RTUINT128U), \
    8271                                     IEM_ACCESS_DATA_RW, sizeof(RTUINT128U) - 1 /*fAlignMask*/, \
     8302                                    IEM_ACCESS_DATA_RW, sizeof(RTUINT128U) - 1 /*fAlignMaskAndCtl*/, \
    82728303                                    (uintptr_t)iemNativeHlpMemFlatMapDataU128Rw, pCallEntry->idxInstr)
    82738304
    82748305#define IEM_MC_MEM_FLAT_MAP_U128_WO(a_pu128Mem, a_bUnmapInfo, a_GCPtrMem) \
    82758306    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu128Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(RTUINT128U), \
    8276                                     IEM_ACCESS_DATA_W, sizeof(RTUINT128U) - 1 /*fAlignMask*/, \
     8307                                    IEM_ACCESS_DATA_W, sizeof(RTUINT128U) - 1 /*fAlignMaskAndCtl*/, \
    82778308                                    (uintptr_t)iemNativeHlpMemFlatMapDataU128Wo, pCallEntry->idxInstr) \
    82788309
    82798310#define IEM_MC_MEM_FLAT_MAP_U128_RO(a_pu128Mem, a_bUnmapInfo, a_GCPtrMem) \
    82808311    off = iemNativeEmitMemMapCommon(pReNative, off, a_pu128Mem, a_bUnmapInfo, UINT8_MAX, a_GCPtrMem, sizeof(RTUINT128U), \
    8281                                     IEM_ACCESS_DATA_R,  sizeof(RTUINT128U) - 1 /*fAlignMask*/, \
     8312                                    IEM_ACCESS_DATA_R,  sizeof(RTUINT128U) - 1 /*fAlignMaskAndCtl*/, \
    82828313                                    (uintptr_t)iemNativeHlpMemFlatMapDataU128Ro, pCallEntry->idxInstr)
    82838314
    … …  
    82858316DECL_INLINE_THROW(uint32_t)
    82868317iemNativeEmitMemMapCommon(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t idxVarMem, uint8_t idxVarUnmapInfo,
    8287                           uint8_t iSegReg, uint8_t idxVarGCPtrMem, uint8_t cbMem, uint32_t fAccess, uint8_t fAlignMask,
     8318                          uint8_t iSegReg, uint8_t idxVarGCPtrMem, uint8_t cbMem, uint32_t fAccess, uint32_t fAlignMaskAndCtl,
    82888319                          uintptr_t pfnFunction, uint8_t idxInstr)
    82898320{
    … …  
    83318362        switch (cbMem)
    83328363        {
    8333             case 1:  Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemFlatMapDataU8)); break;
    8334             case 2:  Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemFlatMapDataU16)); break;
    8335             case 4:  Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemFlatMapDataU32)); break;
    8336             case 8:  Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemFlatMapDataU64)); break;
     8364            case 1:
     8365                Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemFlatMapDataU8));
     8366                Assert(!fAlignMaskAndCtl);
     8367                break;
     8368            case 2:
     8369                Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemFlatMapDataU16));
     8370                Assert(fAlignMaskAndCtl < 2);
     8371                break;
     8372            case 4:
     8373                Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemFlatMapDataU32));
     8374                Assert(fAlignMaskAndCtl < 4);
     8375                break;
     8376            case 8:
     8377                Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemFlatMapDataU64));
     8378                Assert(fAlignMaskAndCtl < 8);
     8379                break;
    83378380            case 10:
    83388381                Assert(   pfnFunction == (uintptr_t)iemNativeHlpMemFlatMapDataR80Wo
    83398382                       || pfnFunction == (uintptr_t)iemNativeHlpMemFlatMapDataD80Wo);
    83408383                Assert((fAccess & IEM_ACCESS_TYPE_MASK) == IEM_ACCESS_TYPE_WRITE);
     8384                Assert(fAlignMaskAndCtl < 8);
    83418385                break;
    8342             case 16: Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemFlatMapDataU128)); break;
     8386            case 16:
     8387                Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemFlatMapDataU128));
     8388                Assert(fAlignMaskAndCtl < 16);
     8389                break;
    83438390# if 0
    8344             case 32: Assert(pfnFunction == IEM_MAP_HLP_FN_NO_AT(fAccess, iemNativeHlpMemFlatMapDataU256)); break;
    8345             case 64: Assert(pfnFunction == IEM_MAP_HLP_FN_NO_AT(fAccess, iemNativeHlpMemFlatMapDataU512)); break;
     8391            case 32:
     8392                Assert(pfnFunction == IEM_MAP_HLP_FN_NO_AT(fAccess, iemNativeHlpMemFlatMapDataU256));
     8393                Assert(fAlignMaskAndCtl < 32);
     8394                break;
     8395            case 64:
     8396                Assert(pfnFunction == IEM_MAP_HLP_FN_NO_AT(fAccess, iemNativeHlpMemFlatMapDataU512));
     8397                Assert(fAlignMaskAndCtl < 64);
     8398                break;
    83468399# endif
    83478400            default: AssertFailed(); break;
    … …  
    83538406        switch (cbMem)
    83548407        {
    8355             case 1:  Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemMapDataU8)); break;
    8356             case 2:  Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemMapDataU16)); break;
    8357             case 4:  Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemMapDataU32)); break;
    8358             case 8:  Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemMapDataU64)); break;
     8408            case 1:
     8409                Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemMapDataU8));
     8410                Assert(!fAlignMaskAndCtl);
     8411                break;
     8412            case 2:
     8413                Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemMapDataU16));
     8414                Assert(fAlignMaskAndCtl < 2);
     8415                break;
     8416            case 4:
     8417                Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemMapDataU32));
     8418                Assert(fAlignMaskAndCtl < 4);
     8419                break;
     8420            case 8:
     8421                Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemMapDataU64));
     8422                Assert(fAlignMaskAndCtl < 8);
     8423                break;
    83598424            case 10:
    83608425                Assert(   pfnFunction == (uintptr_t)iemNativeHlpMemMapDataR80Wo
    83618426                       || pfnFunction == (uintptr_t)iemNativeHlpMemMapDataD80Wo);
    83628427                Assert((fAccess & IEM_ACCESS_TYPE_MASK) == IEM_ACCESS_TYPE_WRITE);
     8428                Assert(fAlignMaskAndCtl < 8);
    83638429                break;
    8364             case 16: Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemMapDataU128)); break;
     8430            case 16:
     8431                Assert(pfnFunction == IEM_MAP_HLP_FN(fAccess, iemNativeHlpMemMapDataU128));
     8432                Assert(fAlignMaskAndCtl < 16);
     8433                break;
    83658434# if 0
    8366             case 32: Assert(pfnFunction == IEM_MAP_HLP_FN_NO_AT(fAccess, iemNativeHlpMemMapDataU256)); break;
    8367             case 64: Assert(pfnFunction == IEM_MAP_HLP_FN_NO_AT(fAccess, iemNativeHlpMemMapDataU512)); break;
     8435            case 32:
     8436                Assert(pfnFunction == IEM_MAP_HLP_FN_NO_AT(fAccess, iemNativeHlpMemMapDataU256));
     8437                Assert(fAlignMaskAndCtl < 32);
     8438                break;
     8439            case 64:
     8440                Assert(pfnFunction == IEM_MAP_HLP_FN_NO_AT(fAccess, iemNativeHlpMemMapDataU512));
     8441                Assert(fAlignMaskAndCtl < 64);
     8442                break;
    83688443# endif
    83698444            default: AssertFailed(); break;
    … …  
    84958570         * TlbLookup:
    84968571         */
    8497         off = iemNativeEmitTlbLookup<true>(pReNative, off, &TlbState, iSegReg, cbMem, fAlignMask, fAccess,
     8572        off = iemNativeEmitTlbLookup<true>(pReNative, off, &TlbState, iSegReg, cbMem, fAlignMaskAndCtl, fAccess,
    84988573                                           idxLabelTlbLookup, idxLabelTlbMiss, idxRegMemResult);
    84998574# ifdef IEM_WITH_TLB_STATISTICS
    … …  
    85188593    }
    85198594#else
    8520     RT_NOREF(fAccess, fAlignMask, idxLabelTlbMiss);
     8595    RT_NOREF(fAccess, fAlignMaskAndCtl, idxLabelTlbMiss);
    85218596#endif
    85228597

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

    r104424 r104984  
    172172
    173173/**
     174 * Calculates the IEM_F_X86_AC flags.
     175 *
     176 * @returns IEM_F_X86_AC or zero
     177 * @param   pVCpu               The cross context virtual CPU structure of the
     178 *                              calling thread.
     179 */
     180DECL_FORCE_INLINE(uint32_t) iemCalcExecAcFlag(PVMCPUCC pVCpu) RT_NOEXCEPT
     181{
     182    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_RFLAGS);
     183    Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ss));
     184
     185    if (   !pVCpu->cpum.GstCtx.eflags.Bits.u1AC
     186        || (pVCpu->cpum.GstCtx.cr0 & (X86_CR0_AM | X86_CR0_PE)) != (X86_CR0_AM | X86_CR0_PE)
     187        || (   !pVCpu->cpum.GstCtx.eflags.Bits.u1VM
     188            && pVCpu->cpum.GstCtx.ss.Attr.n.u2Dpl != 3))
     189        return 0;
     190    return IEM_F_X86_AC;
     191}
     192
     193
     194/**
    174195 * Calculates the IEM_F_MODE_X86_32BIT_FLAT flag.
    175196 *
    … …  
    246267
    247268/**
    248  * Calculates the IEM_F_MODE_XXX and CPL flags.
    249  *
    250  * @returns IEM_F_MODE_XXX
     269 * Calculates the IEM_F_MODE_XXX, CPL and AC flags.
     270 *
     271 * @returns IEM_F_MODE_XXX, IEM_F_X86_CPL_MASK and IEM_F_X86_AC.
    251272 * @param   pVCpu               The cross context virtual CPU structure of the
    252273 *                              calling thread.
    … …  
    266287            Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(pVCpu, &pVCpu->cpum.GstCtx.ss));
    267288            uint32_t fExec = ((uint32_t)pVCpu->cpum.GstCtx.ss.Attr.n.u2Dpl << IEM_F_X86_CPL_SHIFT);
     289            if (   !pVCpu->cpum.GstCtx.eflags.Bits.u1AC
     290                || !(pVCpu->cpum.GstCtx.cr0 & X86_CR0_AM)
     291                || fExec != (3U << IEM_F_X86_CPL_SHIFT))
     292            { /* likely */ }
     293            else
     294                fExec |= IEM_F_X86_AC;
     295
    268296            if (pVCpu->cpum.GstCtx.cs.Attr.n.u1DefBig)
    269297            {
    … …  
    280308            return fExec;
    281309        }
    282         return IEM_F_MODE_X86_16BIT_PROT_V86 | (UINT32_C(3) << IEM_F_X86_CPL_SHIFT);
     310        if (   !pVCpu->cpum.GstCtx.eflags.Bits.u1AC
     311            || !(pVCpu->cpum.GstCtx.cr0 & X86_CR0_AM))
     312            return IEM_F_MODE_X86_16BIT_PROT_V86 | (UINT32_C(3) << IEM_F_X86_CPL_SHIFT);
     313        return IEM_F_MODE_X86_16BIT_PROT_V86 | (UINT32_C(3) << IEM_F_X86_CPL_SHIFT) | IEM_F_X86_AC;
    283314    }
    284315
    … …  
    374405 *                              calling thread.
    375406 */
    376 DECL_FORCE_INLINE(void) iemRecalcExecModeAndCplFlags(PVMCPUCC pVCpu)
    377 {
    378     pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK))
     407DECL_FORCE_INLINE(void) iemRecalcExecModeAndCplAndAcFlags(PVMCPUCC pVCpu)
     408{
     409    pVCpu->iem.s.fExec = (pVCpu->iem.s.fExec & ~(IEM_F_MODE_MASK | IEM_F_X86_CPL_MASK | IEM_F_X86_AC))
    379410                       | iemCalcExecModeAndCplFlags(pVCpu);
    380411}
    … …  
    46384669
    46394670
    4640 /* Every template reyling on unaligned accesses inside a page not being okay should go below. */
     4671/* Every template relying on unaligned accesses inside a page not being okay should go below. */
    46414672#undef TMPL_MEM_CHECK_UNALIGNED_WITHIN_PAGE_OK
    46424673#define TMPL_MEM_CHECK_UNALIGNED_WITHIN_PAGE_OK(a_pVCpu, a_GCPtrEff, a_TmplMemType) 0

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

    r104956 r104984  
    842842/** X86: The current protection level (CPL) shifted mask. */
    843843#define IEM_F_X86_CPL_SMASK                 UINT32_C(0x00000003)
     844
     845/** X86: Alignment checks enabled (CR0.AM=1 & EFLAGS.AC=1). */
     846#define IEM_F_X86_AC                        UINT32_C(0x00080000)
    844847
    845848/** X86 execution context.

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

    r104798 r104984  
    632632}
    633633
    634 
    635634/**
    636635 * Emits a 32-bit GPR load of a VCpu value.
    … …  
    638637 */
    639638DECL_INLINE_THROW(uint32_t)
     639iemNativeEmitLoadGprFromVCpuU32Ex(PIEMNATIVEINSTR pCodeBuf, uint32_t off, uint8_t iGpr, uint32_t offVCpu)
     640{
     641#ifdef RT_ARCH_AMD64
     642    /* mov reg32, mem32 */
     643    if (iGpr >= 8)
     644        pCodeBuf[off++] = X86_OP_REX_R;
     645    pCodeBuf[off++] = 0x8b;
     646    off = iemNativeEmitGprByVCpuDisp(pCodeBuf, off, iGpr, offVCpu);
     647
     648#elif defined(RT_ARCH_ARM64)
     649    off = iemNativeEmitGprByVCpuLdStEx(pCodeBuf, off, iGpr, offVCpu, kArmv8A64InstrLdStType_Ld_Word, sizeof(uint32_t));
     650
     651#else
     652# error "port me"
     653#endif
     654    return off;
     655}
     656
     657
     658/**
     659 * Emits a 32-bit GPR load of a VCpu value.
     660 * @note Bits 32 thru 63 in the GPR will be zero after the operation.
     661 */
     662DECL_INLINE_THROW(uint32_t)
    640663iemNativeEmitLoadGprFromVCpuU32(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t iGpr, uint32_t offVCpu)
    641664{
    642665#ifdef RT_ARCH_AMD64
    643     /* mov reg32, mem32 */
    644     uint8_t *pbCodeBuf = iemNativeInstrBufEnsure(pReNative, off, 7);
    645     if (iGpr >= 8)
    646         pbCodeBuf[off++] = X86_OP_REX_R;
    647     pbCodeBuf[off++] = 0x8b;
    648     off = iemNativeEmitGprByVCpuDisp(pbCodeBuf, off, iGpr, offVCpu);
     666    off = iemNativeEmitLoadGprFromVCpuU32Ex(iemNativeInstrBufEnsure(pReNative, off, 7), off, iGpr, offVCpu);
    649667    IEMNATIVE_ASSERT_INSTR_BUF_ENSURE(pReNative, off);
    650668
    … …  
    69526970 */
    69536971DECL_INLINE_THROW(uint32_t)
    6954 iemNativeEmitTestBitInGprAndJmpToLabelIfCc(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t iGprSrc,
    6955                                            uint8_t iBitNo, uint32_t idxLabel, bool fJmpIfSet)
     6972iemNativeEmitTestBitInGprAndJmpToFixedIfCcEx(PIEMNATIVEINSTR pCodeBuf, uint32_t off, uint8_t iGprSrc, uint8_t iBitNo,
     6973                                             uint32_t offTarget, uint32_t *poffFixup, bool fJmpIfSet)
    69566974{
    69576975    Assert(iBitNo < 64);
    69586976#ifdef RT_ARCH_AMD64
    6959     uint8_t * const pbCodeBuf = iemNativeInstrBufEnsure(pReNative, off, 5);
    69606977    if (iBitNo < 8)
    69616978    {
    69626979        /* test Eb, imm8 */
    69636980        if (iGprSrc >= 4)
    6964             pbCodeBuf[off++] = iGprSrc >= 8 ? X86_OP_REX_B : X86_OP_REX;
    6965         pbCodeBuf[off++] = 0xf6;
    6966         pbCodeBuf[off++] = X86_MODRM_MAKE(X86_MOD_REG, 0, iGprSrc & 7);
    6967         pbCodeBuf[off++] = (uint8_t)1 << iBitNo;
    6968         off = iemNativeEmitJccToLabel(pReNative, off, idxLabel, fJmpIfSet ? kIemNativeInstrCond_ne : kIemNativeInstrCond_e);
     6981            pCodeBuf[off++] = iGprSrc >= 8 ? X86_OP_REX_B : X86_OP_REX;
     6982        pCodeBuf[off++] = 0xf6;
     6983        pCodeBuf[off++] = X86_MODRM_MAKE(X86_MOD_REG, 0, iGprSrc & 7);
     6984        pCodeBuf[off++] = (uint8_t)1 << iBitNo;
     6985        if (poffFixup)
     6986            *poffFixup = off;
     6987        off = iemNativeEmitJccToFixedEx(pCodeBuf, off, offTarget, fJmpIfSet ? kIemNativeInstrCond_ne : kIemNativeInstrCond_e);
    69696988    }
    69706989    else
    … …  
    69726991        /* bt Ev, imm8 */
    69736992        if (iBitNo >= 32)
    6974             pbCodeBuf[off++] = X86_OP_REX_W | (iGprSrc < 8 ? 0 : X86_OP_REX_B);
     6993            pCodeBuf[off++] = X86_OP_REX_W | (iGprSrc < 8 ? 0 : X86_OP_REX_B);
    69756994        else if (iGprSrc >= 8)
    6976             pbCodeBuf[off++] = X86_OP_REX_B;
    6977         pbCodeBuf[off++] = 0x0f;
    6978         pbCodeBuf[off++] = 0xba;
    6979         pbCodeBuf[off++] = X86_MODRM_MAKE(X86_MOD_REG, 4, iGprSrc & 7);
    6980         pbCodeBuf[off++] = iBitNo;
    6981         off = iemNativeEmitJccToLabel(pReNative, off, idxLabel, fJmpIfSet ? kIemNativeInstrCond_c : kIemNativeInstrCond_nc);
     6995            pCodeBuf[off++] = X86_OP_REX_B;
     6996        pCodeBuf[off++] = 0x0f;
     6997        pCodeBuf[off++] = 0xba;
     6998        pCodeBuf[off++] = X86_MODRM_MAKE(X86_MOD_REG, 4, iGprSrc & 7);
     6999        pCodeBuf[off++] = iBitNo;
     7000        if (poffFixup)
     7001            *poffFixup = off;
     7002        off = iemNativeEmitJccToFixedEx(pCodeBuf, off, offTarget, fJmpIfSet ? kIemNativeInstrCond_c : kIemNativeInstrCond_nc);
     7003    }
     7004
     7005#elif defined(RT_ARCH_ARM64)
     7006    /* Just use the TBNZ instruction here. */
     7007    if (poffFixup)
     7008        *poffFixup = off;
     7009    pCodeBuf[off++] = Armv8A64MkInstrTbzTbnz(fJmpIfSet, off - offTarget, iGprSrc, iBitNo);
     7010
     7011#else
     7012# error "Port me!"
     7013#endif
     7014    return off;
     7015}
     7016
     7017
     7018/**
     7019 * Emits a jump to @a idxTarget on the condition that bit @a iBitNo _is_ _set_
     7020 * in @a iGprSrc.
     7021 */
     7022DECL_INLINE_THROW(uint32_t)
     7023iemNativeEmitTestBitInGprAndJmpToFixedIfSetEx(PIEMNATIVEINSTR pCodeBuf, uint32_t off, uint8_t iGprSrc, uint8_t iBitNo,
     7024                                              uint32_t offTarget, uint32_t *poffFixup)
     7025{
     7026    return iemNativeEmitTestBitInGprAndJmpToFixedIfCcEx(pCodeBuf, off, iGprSrc, iBitNo, offTarget, poffFixup, true /*fJmpIfSet*/);
     7027}
     7028
     7029
     7030/**
     7031 * Emits a jump to @a idxTarget on the condition that bit @a iBitNo _is_ _not_
     7032 * _set_ in @a iGprSrc.
     7033 */
     7034DECL_INLINE_THROW(uint32_t)
     7035iemNativeEmitTestBitInGprAndJmpToLabelIfNotSetEx(PIEMNATIVEINSTR pCodeBuf, uint32_t off, uint8_t iGprSrc, uint8_t iBitNo,
     7036                                                 uint32_t offTarget, uint32_t *poffFixup)
     7037{
     7038    return iemNativeEmitTestBitInGprAndJmpToFixedIfCcEx(pCodeBuf, off, iGprSrc, iBitNo, offTarget, poffFixup, false /*fJmpIfSet*/);
     7039}
     7040
     7041
     7042
     7043/**
     7044 * Internal helper, don't call directly.
     7045 */
     7046DECL_INLINE_THROW(uint32_t)
     7047iemNativeEmitTestBitInGprAndJmpToLabelIfCcEx(PIEMRECOMPILERSTATE pReNative, PIEMNATIVEINSTR pCodeBuf, uint32_t off,
     7048                                             uint8_t iGprSrc, uint8_t iBitNo, uint32_t idxLabel, bool fJmpIfSet)
     7049{
     7050    Assert(iBitNo < 64);
     7051#ifdef RT_ARCH_AMD64
     7052    if (iBitNo < 8)
     7053    {
     7054        /* test Eb, imm8 */
     7055        if (iGprSrc >= 4)
     7056            pCodeBuf[off++] = iGprSrc >= 8 ? X86_OP_REX_B : X86_OP_REX;
     7057        pCodeBuf[off++] = 0xf6;
     7058        pCodeBuf[off++] = X86_MODRM_MAKE(X86_MOD_REG, 0, iGprSrc & 7);
     7059        pCodeBuf[off++] = (uint8_t)1 << iBitNo;
     7060        off = iemNativeEmitJccToLabelEx(pReNative, pCodeBuf, off, idxLabel,
     7061                                        fJmpIfSet ? kIemNativeInstrCond_ne : kIemNativeInstrCond_e);
     7062    }
     7063    else
     7064    {
     7065        /* bt Ev, imm8 */
     7066        if (iBitNo >= 32)
     7067            pCodeBuf[off++] = X86_OP_REX_W | (iGprSrc < 8 ? 0 : X86_OP_REX_B);
     7068        else if (iGprSrc >= 8)
     7069            pCodeBuf[off++] = X86_OP_REX_B;
     7070        pCodeBuf[off++] = 0x0f;
     7071        pCodeBuf[off++] = 0xba;
     7072        pCodeBuf[off++] = X86_MODRM_MAKE(X86_MOD_REG, 4, iGprSrc & 7);
     7073        pCodeBuf[off++] = iBitNo;
     7074        off = iemNativeEmitJccToLabelEx(pReNative, pCodeBuf, off, idxLabel,
     7075                                        fJmpIfSet ? kIemNativeInstrCond_c : kIemNativeInstrCond_nc);
    69827076    }
    69837077
    69847078#elif defined(RT_ARCH_ARM64)
    69857079    /* Use the TBNZ instruction here. */
    6986     uint32_t * const pu32CodeBuf = iemNativeInstrBufEnsure(pReNative, off, 2);
    69877080    if (pReNative->paLabels[idxLabel].enmType > kIemNativeLabelType_LastWholeTbBranch)
    69887081    {
    … …  
    69937086        {
    69947087            iemNativeAddFixup(pReNative, off, idxLabel, kIemNativeFixupType_RelImm14At5);
    6995             pu32CodeBuf[off++] = Armv8A64MkInstrTbzTbnz(fJmpIfSet, 0, iGprSrc, iBitNo);
     7088            pCodeBuf[off++] = Armv8A64MkInstrTbzTbnz(fJmpIfSet, 0, iGprSrc, iBitNo);
    69967089        }
    69977090        //else
    … …  
    69997092        //    RT_BREAKPOINT();
    70007093        //    Assert(off - offLabel <= 0x1fffU);
    7001         //    pu32CodeBuf[off++] = Armv8A64MkInstrTbzTbnz(fJmpIfSet, offLabel - off, iGprSrc, iBitNo);
     7094        //    pCodeBuf[off++] = Armv8A64MkInstrTbzTbnz(fJmpIfSet, offLabel - off, iGprSrc, iBitNo);
    70027095        //
    70037096        //}
    … …  
    70067099    {
    70077100        Assert(Armv8A64ConvertImmRImmS2Mask64(0x40, (64U - iBitNo) & 63U) == RT_BIT_64(iBitNo));
    7008         pu32CodeBuf[off++] = Armv8A64MkInstrTstImm(iGprSrc, 0x40, (64U - iBitNo) & 63U);
     7101        pCodeBuf[off++] = Armv8A64MkInstrTstImm(iGprSrc, 0x40, (64U - iBitNo) & 63U);
    70097102        iemNativeAddFixup(pReNative, off, idxLabel, kIemNativeFixupType_RelImm19At5);
    7010         pu32CodeBuf[off++] = Armv8A64MkInstrBCond(fJmpIfSet ? kArmv8InstrCond_Ne : kArmv8InstrCond_Eq, 0);
     7103        pCodeBuf[off++] = Armv8A64MkInstrBCond(fJmpIfSet ? kArmv8InstrCond_Ne : kArmv8InstrCond_Eq, 0);
    70117104    }
    70127105
    … …  
    70147107# error "Port me!"
    70157108#endif
    7016     IEMNATIVE_ASSERT_INSTR_BUF_ENSURE(pReNative, off);
    70177109    return off;
    70187110}
    … …  
    70227114 * Emits a jump to @a idxLabel on the condition that bit @a iBitNo _is_ _set_ in
    70237115 * @a iGprSrc.
    7024  *
    7025  * @note On ARM64 the range is only +/-8191 instructions.
     7116 */
     7117DECL_INLINE_THROW(uint32_t)
     7118iemNativeEmitTestBitInGprAndJmpToLabelIfSetEx(PIEMRECOMPILERSTATE pReNative, PIEMNATIVEINSTR pCodeBuf, uint32_t off,
     7119                                              uint8_t iGprSrc, uint8_t iBitNo, uint32_t idxLabel)
     7120{
     7121    return iemNativeEmitTestBitInGprAndJmpToLabelIfCcEx(pReNative, pCodeBuf, off, iGprSrc, iBitNo, idxLabel, true /*fJmpIfSet*/);
     7122}
     7123
     7124
     7125/**
     7126 * Emits a jump to @a idxLabel on the condition that bit @a iBitNo _is_ _not_
     7127 * _set_ in @a iGprSrc.
     7128 */
     7129DECL_INLINE_THROW(uint32_t)
     7130iemNativeEmitTestBitInGprAndJmpToLabelIfNotSetEx(PIEMRECOMPILERSTATE pReNative, PIEMNATIVEINSTR pCodeBuf, uint32_t off,
     7131                                                 uint8_t iGprSrc, uint8_t iBitNo, uint32_t idxLabel)
     7132{
     7133    return iemNativeEmitTestBitInGprAndJmpToLabelIfCcEx(pReNative, pCodeBuf, off, iGprSrc, iBitNo, idxLabel, false /*fJmpIfSet*/);
     7134}
     7135
     7136
     7137/**
     7138 * Internal helper, don't call directly.
     7139 */
     7140DECL_INLINE_THROW(uint32_t)
     7141iemNativeEmitTestBitInGprAndJmpToLabelIfCc(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t iGprSrc,
     7142                                           uint8_t iBitNo, uint32_t idxLabel, bool fJmpIfSet)
     7143{
     7144#ifdef RT_ARCH_AMD64
     7145    off = iemNativeEmitTestBitInGprAndJmpToLabelIfCcEx(pReNative, iemNativeInstrBufEnsure(pReNative, off, 5+6), off,
     7146                                                       iGprSrc, iBitNo, idxLabel, fJmpIfSet);
     7147#elif defined(RT_ARCH_ARM64)
     7148    off = iemNativeEmitTestBitInGprAndJmpToLabelIfCcEx(pReNative, iemNativeInstrBufEnsure(pReNative, off, 2), off,
     7149                                                       iGprSrc, iBitNo, idxLabel, fJmpIfSet);
     7150#else
     7151# error "Port me!"
     7152#endif
     7153    IEMNATIVE_ASSERT_INSTR_BUF_ENSURE(pReNative, off);
     7154    return off;
     7155}
     7156
     7157
     7158/**
     7159 * Emits a jump to @a idxLabel on the condition that bit @a iBitNo _is_ _set_ in
     7160 * @a iGprSrc.
    70267161 */
    70277162DECL_INLINE_THROW(uint32_t) iemNativeEmitTestBitInGprAndJmpToLabelIfSet(PIEMRECOMPILERSTATE pReNative, uint32_t off,
    … …  
    70357170 * Emits a jump to @a idxLabel on the condition that bit @a iBitNo _is_ _not_
    70367171 * _set_ in @a iGprSrc.
    7037  *
    7038  * @note On ARM64 the range is only +/-8191 instructions.
    70397172 */
    70407173DECL_INLINE_THROW(uint32_t) iemNativeEmitTestBitInGprAndJmpToLabelIfNotSet(PIEMRECOMPILERSTATE pReNative, uint32_t off,

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

    r104956 r104984  
    298298
    299299#ifdef IEMNATIVE_WITH_TLB_LOOKUP
     300/**
     301 *
     302 * @returns New @a off value.
     303 * @param   pReNative           .
     304 * @param   off                 .
     305 * @param   pTlbState           .
     306 * @param   iSegReg             .
     307 * @param   cbMem               .
     308 * @param   fAlignMaskAndCtl    The low 8-bit is the alignment mask, ie. a
     309 *                              128-bit aligned access passes 15.  This is only
     310 *                              applied to ring-3 code, when dictated by the
     311 *                              control bits and for atomic accesses.
     312 *
     313 *                              The other bits are used for alignment control:
     314 *                                  - IEM_MEMMAP_F_ALIGN_GP
     315 *                                  - IEM_MEMMAP_F_ALIGN_SSE
     316 *                                  - IEM_MEMMAP_F_ALIGN_GP_OR_AC
     317 *                              Any non-zero upper bits means we will go to
     318 *                              tlbmiss on anything out of alignment according
     319 *                              to the mask in the low 8 bits.
     320 * @param   fAccess             .
     321 * @param   idxLabelTlbLookup   .
     322 * @param   idxLabelTlbMiss     .
     323 * @param   idxRegMemResult     .
     324 * @param   offDisp             .
     325 * @tparam  a_fDataTlb          .
     326 * @tparam  a_fNoReturn         .
     327 */
    300328template<bool const a_fDataTlb, bool const a_fNoReturn = false>
    301329DECL_INLINE_THROW(uint32_t)
    302330iemNativeEmitTlbLookup(PIEMRECOMPILERSTATE pReNative, uint32_t off, IEMNATIVEEMITTLBSTATE const * const pTlbState,
    303                        uint8_t iSegReg, uint8_t cbMem, uint8_t fAlignMask, uint32_t fAccess,
     331                       uint8_t iSegReg, uint8_t cbMem, uint8_t fAlignMaskAndCtl, uint32_t fAccess,
    304332                       uint32_t idxLabelTlbLookup, uint32_t idxLabelTlbMiss, uint8_t idxRegMemResult,
    305333                       uint8_t offDisp = 0)
    … …  
    535563
    536564    /*
    537      * 2. Check that the address doesn't cross a page boundrary and doesn't have alignment issues.
     565     * 2. Check that the address doesn't cross a page boundrary and doesn't
     566     *    have alignment issues (not applicable to code).
    538567     *
    539      * 2a. Alignment check using fAlignMask.
     568     *    For regular accesses (non-SSE/AVX & atomic stuff) we only need to
     569     *    check for #AC in ring-3 code.  To simplify this, the need for AC
     570     *    checking is indicated by IEM_F_X86_AC in IEMCPU::fExec.
     571     *
     572     *    The caller informs us about about SSE/AVX aligned accesses via the
     573     *    upper bits of fAlignMaskAndCtl and atomic accesses via fAccess.
    540574     */
    541     if (fAlignMask)
    542     {
    543         Assert(RT_IS_POWER_OF_TWO(fAlignMask + 1));
    544         Assert(fAlignMask < 128);
    545         /* test regflat, fAlignMask */
    546         off = iemNativeEmitTestAnyBitsInGpr8Ex(pCodeBuf, off, idxRegFlatPtr, fAlignMask);
     575    if (a_fDataTlb)
     576    {
     577        uint8_t const fAlignMask = (uint8_t)fAlignMaskAndCtl;
     578        Assert(!(fAlignMaskAndCtl & ~(UINT32_C(0xff) | IEM_MEMMAP_F_ALIGN_SSE | IEM_MEMMAP_F_ALIGN_GP | IEM_MEMMAP_F_ALIGN_GP_OR_AC)));
     579        Assert(RT_IS_POWER_OF_TWO(fAlignMask + 1U));
     580        Assert(cbMem == fAlignMask + 1U || !(fAccess & IEM_ACCESS_ATOMIC));
     581        Assert(cbMem < 128); /* alignment test assumptions */
     582
     583        /*
     584         * 2a. Strict alignment check using fAlignMask for atomic, strictly
     585         *     aligned stuff (SSE & AVX) and AC=1 (ring-3).
     586         */
     587        bool const fStrictAlignmentCheck = fAlignMask
     588                                        && (   (fAlignMaskAndCtl & ~UINT32_C(0xff))
     589                                            || (fAccess & IEM_ACCESS_ATOMIC)
     590                                            || (pReNative->fExec & IEM_F_X86_AC) );
     591        if (fStrictAlignmentCheck)
     592        {
     593            /* test regflat, fAlignMask */
     594            off = iemNativeEmitTestAnyBitsInGpr8Ex(pCodeBuf, off, idxRegFlatPtr, fAlignMask);
     595
    547596#ifndef IEM_WITH_TLB_STATISTICS
    548         /* jnz tlbmiss */
    549         off = iemNativeEmitJccToLabelEx(pReNative, pCodeBuf, off, idxLabelTlbMiss, kIemNativeInstrCond_ne);
     597            /* jnz tlbmiss */
     598            off = iemNativeEmitJccToLabelEx(pReNative, pCodeBuf, off, idxLabelTlbMiss, kIemNativeInstrCond_ne);
    550599#else
    551         /* jz  1F; inc stat; jmp tlbmiss */
    552         uint32_t const offFixup1 = off;
    553         off = iemNativeEmitJccToFixedEx(pCodeBuf, off, off + 16, kIemNativeInstrCond_e);
    554         off = iemNativeEmitIncStamCounterInVCpuEx(pCodeBuf, off, pTlbState->idxReg1, pTlbState->idxReg2,
    555                                                   offVCpuTlb + RT_UOFFSETOF(IEMTLB, cTlbNativeMissAlignment));
    556         off = iemNativeEmitJmpToLabelEx(pReNative, pCodeBuf, off, idxLabelTlbMiss);
    557         iemNativeFixupFixedJump(pReNative, offFixup1, off);
    558 #endif
    559     }
    560 
    561     /*
    562      * 2b. Check that it's not crossing page a boundrary. This is implicit in
    563      *     the previous test if the alignment is same or larger than the type.
    564      */
    565     if (cbMem > fAlignMask + 1)
    566     {
    567         /* reg1 = regflat & 0xfff */
    568         off = iemNativeEmitGpr32EqGprAndImmEx(pCodeBuf, off, pTlbState->idxReg1,/*=*/ idxRegFlatPtr,/*&*/ GUEST_PAGE_OFFSET_MASK);
    569         /* cmp reg1, GUEST_PAGE_SIZE - cbMem */
    570         off = iemNativeEmitCmpGpr32WithImmEx(pCodeBuf, off, pTlbState->idxReg1, GUEST_PAGE_SIZE);
     600            /* jz  1F; inc stat; jmp tlbmiss */
     601            uint32_t const offFixup1 = off;
     602            off = iemNativeEmitJccToFixedEx(pCodeBuf, off, off + 16, kIemNativeInstrCond_e);
     603            off = iemNativeEmitIncStamCounterInVCpuEx(pCodeBuf, off, pTlbState->idxReg1, pTlbState->idxReg2,
     604                                                      offVCpuTlb + RT_UOFFSETOF(IEMTLB, cTlbNativeMissAlignment));
     605            off = iemNativeEmitJmpToLabelEx(pReNative, pCodeBuf, off, idxLabelTlbMiss);
     606            iemNativeFixupFixedJump(pReNative, offFixup1, off);
     607#endif
     608        }
     609
     610        /*
     611         * 2b. Check that it's not crossing page a boundrary if the access is
     612         *     larger than the aligment mask or if we didn't do the strict
     613         *     alignment check above.
     614         */
     615        if (   cbMem > 1
     616            && (   !fStrictAlignmentCheck
     617                || cbMem > fAlignMask + 1U))
     618        {
     619            /* reg1 = regflat & 0xfff */
     620            off = iemNativeEmitGpr32EqGprAndImmEx(pCodeBuf, off, pTlbState->idxReg1,/*=*/ idxRegFlatPtr,/*&*/ GUEST_PAGE_OFFSET_MASK);
     621            /* cmp reg1, GUEST_PAGE_SIZE - cbMem */
     622            off = iemNativeEmitCmpGpr32WithImmEx(pCodeBuf, off, pTlbState->idxReg1, GUEST_PAGE_SIZE - cbMem);
    571623#ifndef IEM_WITH_TLB_STATISTICS
    572         /* ja  tlbmiss */
    573         off = iemNativeEmitJccToLabelEx(pReNative, pCodeBuf, off, idxLabelTlbMiss, kIemNativeInstrCond_nbe);
     624            /* ja  tlbmiss */
     625            off = iemNativeEmitJccToLabelEx(pReNative, pCodeBuf, off, idxLabelTlbMiss, kIemNativeInstrCond_nbe);
    574626#else
    575         /* jbe 1F; inc stat; jmp tlbmiss */
    576         uint32_t const offFixup1 = off;
    577         off = iemNativeEmitJccToFixedEx(pCodeBuf, off, off + 16, kIemNativeInstrCond_be);
    578         off = iemNativeEmitIncU32CounterInVCpuEx(pCodeBuf, off, pTlbState->idxReg1, pTlbState->idxReg2,
    579                                                  offVCpuTlb + RT_UOFFSETOF(IEMTLB, cTlbNativeMissCrossPage));
    580         off = iemNativeEmitJmpToLabelEx(pReNative, pCodeBuf, off, idxLabelTlbMiss);
    581         iemNativeFixupFixedJump(pReNative, offFixup1, off);
    582 #endif
    583     }
     627            /* jbe 1F; inc stat; jmp tlbmiss */
     628            uint32_t const offFixup1 = off;
     629            off = iemNativeEmitJccToFixedEx(pCodeBuf, off, off + 16, kIemNativeInstrCond_be);
     630            off = iemNativeEmitIncU32CounterInVCpuEx(pCodeBuf, off, pTlbState->idxReg1, pTlbState->idxReg2,
     631                                                     offVCpuTlb + RT_UOFFSETOF(IEMTLB, cTlbNativeMissCrossPage));
     632            off = iemNativeEmitJmpToLabelEx(pReNative, pCodeBuf, off, idxLabelTlbMiss);
     633            iemNativeFixupFixedJump(pReNative, offFixup1, off);
     634#endif
     635        }
     636    }
     637    else
     638        Assert(fAlignMaskAndCtl == 0);
    584639
    585640    /*
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