VirtualBox

Changeset 66314 in vbox


Ignore:
Timestamp:
Mar 28, 2017 9:28:34 PM (8 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
114243
Message:

IEM: Use RTUINT128U instead of uint128_t; started on movsldup Vdq,Wdq.

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/x86.h

    r66227 r66314  
    25642564typedef union X86XMMREG
    25652565{
    2566     /** XMM Register view *. */
     2566    /** XMM Register view. */
    25672567    uint128_t   xmm;
    25682568    /** 8-bit view. */
    … …  
    25762576    /** 128-bit view. (yeah, very helpful) */
    25772577    uint128_t   au128[1];
     2578    /** Confusing nested 128-bit union view (this is what xmm should've been). */
     2579    RTUINT128U  uXmm;
    25782580} X86XMMREG;
    25792581#ifndef VBOX_FOR_DTRACE_LIB

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

    r66309 r66314  
    91789178 * @param   GCPtrMem            The address of the guest memory.
    91799179 */
    9180 IEM_STATIC VBOXSTRICTRC iemMemFetchDataU128(PVMCPU pVCpu, uint128_t *pu128Dst, uint8_t iSegReg, RTGCPTR GCPtrMem)
     9180IEM_STATIC VBOXSTRICTRC iemMemFetchDataU128(PVMCPU pVCpu, PRTUINT128U pu128Dst, uint8_t iSegReg, RTGCPTR GCPtrMem)
    91819181{
    91829182    /* The lazy approach for now... */
    9183     uint128_t const *pu128Src;
     9183    PCRTUINT128U pu128Src;
    91849184    VBOXSTRICTRC rc = iemMemMap(pVCpu, (void **)&pu128Src, sizeof(*pu128Src), iSegReg, GCPtrMem, IEM_ACCESS_DATA_R);
    91859185    if (rc == VINF_SUCCESS)
    91869186    {
    9187         *pu128Dst = *pu128Src;
     9187        pu128Dst->au64[0] = pu128Src->au64[0];
     9188        pu128Dst->au64[1] = pu128Src->au64[1];
    91889189        rc = iemMemCommitAndUnmap(pVCpu, (void *)pu128Src, IEM_ACCESS_DATA_R);
    91899190    }
    … …  
    92029203 * @param   GCPtrMem            The address of the guest memory.
    92039204 */
    9204 IEM_STATIC void iemMemFetchDataU128Jmp(PVMCPU pVCpu, uint128_t *pu128Dst, uint8_t iSegReg, RTGCPTR GCPtrMem)
     9205IEM_STATIC void iemMemFetchDataU128Jmp(PVMCPU pVCpu, PRTUINT128U pu128Dst, uint8_t iSegReg, RTGCPTR GCPtrMem)
    92059206{
    92069207    /* The lazy approach for now... */
    9207     uint128_t const *pu128Src = (uint128_t const *)iemMemMapJmp(pVCpu, sizeof(*pu128Src), iSegReg, GCPtrMem, IEM_ACCESS_DATA_R);
    9208     *pu128Dst = *pu128Src;
     9208    PCRTUINT128U pu128Src = (PCRTUINT128U)iemMemMapJmp(pVCpu, sizeof(*pu128Src), iSegReg, GCPtrMem, IEM_ACCESS_DATA_R);
     9209    pu128Dst->au64[0] = pu128Src->au64[0];
     9210    pu128Dst->au64[1] = pu128Src->au64[1];
    92099211    iemMemCommitAndUnmapJmp(pVCpu, (void *)pu128Src, IEM_ACCESS_DATA_R);
    92109212}
    … …  
    92259227 * @param   GCPtrMem            The address of the guest memory.
    92269228 */
    9227 IEM_STATIC VBOXSTRICTRC iemMemFetchDataU128AlignedSse(PVMCPU pVCpu, uint128_t *pu128Dst, uint8_t iSegReg, RTGCPTR GCPtrMem)
     9229IEM_STATIC VBOXSTRICTRC iemMemFetchDataU128AlignedSse(PVMCPU pVCpu, PRTUINT128U pu128Dst, uint8_t iSegReg, RTGCPTR GCPtrMem)
    92289230{
    92299231    /* The lazy approach for now... */
    … …  
    92339235        return iemRaiseGeneralProtectionFault0(pVCpu);
    92349236
    9235     uint128_t const *pu128Src;
     9237    PCRTUINT128U pu128Src;
    92369238    VBOXSTRICTRC rc = iemMemMap(pVCpu, (void **)&pu128Src, sizeof(*pu128Src), iSegReg, GCPtrMem, IEM_ACCESS_DATA_R);
    92379239    if (rc == VINF_SUCCESS)
    92389240    {
    9239         *pu128Dst = *pu128Src;
     9241        pu128Dst->au64[0] = pu128Src->au64[0];
     9242        pu128Dst->au64[1] = pu128Src->au64[1];
    92409243        rc = iemMemCommitAndUnmap(pVCpu, (void *)pu128Src, IEM_ACCESS_DATA_R);
    92419244    }
    … …  
    92579260 * @param   GCPtrMem            The address of the guest memory.
    92589261 */
    9259 DECL_NO_INLINE(IEM_STATIC, void) iemMemFetchDataU128AlignedSseJmp(PVMCPU pVCpu, uint128_t *pu128Dst, uint8_t iSegReg, RTGCPTR GCPtrMem)
     9262DECL_NO_INLINE(IEM_STATIC, void) iemMemFetchDataU128AlignedSseJmp(PVMCPU pVCpu, PRTUINT128U pu128Dst, uint8_t iSegReg, RTGCPTR GCPtrMem)
    92609263{
    92619264    /* The lazy approach for now... */
    … …  
    92649267        || (IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.MXCSR & X86_MXSCR_MM)) /** @todo should probably check this *after* applying seg.u64Base... Check real HW. */
    92659268    {
    9266         uint128_t const *pu128Src = (uint128_t const *)iemMemMapJmp(pVCpu, sizeof(*pu128Src), iSegReg, GCPtrMem,
    9267                                                                     IEM_ACCESS_DATA_R);
    9268         *pu128Dst = *pu128Src;
     9269        PCRTUINT128U pu128Src = (PCRTUINT128U)iemMemMapJmp(pVCpu, sizeof(*pu128Src), iSegReg, GCPtrMem, IEM_ACCESS_DATA_R);
     9270        pu128Dst->au64[0] = pu128Src->au64[0];
     9271        pu128Dst->au64[1] = pu128Src->au64[1];
    92699272        iemMemCommitAndUnmapJmp(pVCpu, (void *)pu128Src, IEM_ACCESS_DATA_R);
    92709273        return;
    … …  
    95379540 * @param   u128Value            The value to store.
    95389541 */
    9539 IEM_STATIC VBOXSTRICTRC iemMemStoreDataU128(PVMCPU pVCpu, uint8_t iSegReg, RTGCPTR GCPtrMem, uint128_t u128Value)
     9542IEM_STATIC VBOXSTRICTRC iemMemStoreDataU128(PVMCPU pVCpu, uint8_t iSegReg, RTGCPTR GCPtrMem, RTUINT128U u128Value)
    95409543{
    95419544    /* The lazy approach for now... */
    9542     uint128_t *pu128Dst;
     9545    PRTUINT128U pu128Dst;
    95439546    VBOXSTRICTRC rc = iemMemMap(pVCpu, (void **)&pu128Dst, sizeof(*pu128Dst), iSegReg, GCPtrMem, IEM_ACCESS_DATA_W);
    95449547    if (rc == VINF_SUCCESS)
    95459548    {
    9546         *pu128Dst = u128Value;
     9549        pu128Dst->au64[0] = u128Value.au64[0];
     9550        pu128Dst->au64[1] = u128Value.au64[1];
    95479551        rc = iemMemCommitAndUnmap(pVCpu, pu128Dst, IEM_ACCESS_DATA_W);
    95489552    }
    … …  
    95619565 * @param   u128Value            The value to store.
    95629566 */
    9563 IEM_STATIC void iemMemStoreDataU128Jmp(PVMCPU pVCpu, uint8_t iSegReg, RTGCPTR GCPtrMem, uint128_t u128Value)
     9567IEM_STATIC void iemMemStoreDataU128Jmp(PVMCPU pVCpu, uint8_t iSegReg, RTGCPTR GCPtrMem, RTUINT128U u128Value)
    95649568{
    95659569    /* The lazy approach for now... */
    9566     uint128_t *pu128Dst = (uint128_t *)iemMemMapJmp(pVCpu, sizeof(*pu128Dst), iSegReg, GCPtrMem, IEM_ACCESS_DATA_W);
    9567     *pu128Dst = u128Value;
     9570    PRTUINT128U pu128Dst = (PRTUINT128U)iemMemMapJmp(pVCpu, sizeof(*pu128Dst), iSegReg, GCPtrMem, IEM_ACCESS_DATA_W);
     9571    pu128Dst->au64[0] = u128Value.au64[0];
     9572    pu128Dst->au64[1] = u128Value.au64[1];
    95689573    iemMemCommitAndUnmapJmp(pVCpu, pu128Dst, IEM_ACCESS_DATA_W);
    95699574}
    … …  
    95819586 * @param   u128Value           The value to store.
    95829587 */
    9583 IEM_STATIC VBOXSTRICTRC iemMemStoreDataU128AlignedSse(PVMCPU pVCpu, uint8_t iSegReg, RTGCPTR GCPtrMem, uint128_t u128Value)
     9588IEM_STATIC VBOXSTRICTRC iemMemStoreDataU128AlignedSse(PVMCPU pVCpu, uint8_t iSegReg, RTGCPTR GCPtrMem, RTUINT128U u128Value)
    95849589{
    95859590    /* The lazy approach for now... */
    … …  
    95889593        return iemRaiseGeneralProtectionFault0(pVCpu);
    95899594
    9590     uint128_t *pu128Dst;
     9595    PRTUINT128U pu128Dst;
    95919596    VBOXSTRICTRC rc = iemMemMap(pVCpu, (void **)&pu128Dst, sizeof(*pu128Dst), iSegReg, GCPtrMem, IEM_ACCESS_DATA_W);
    95929597    if (rc == VINF_SUCCESS)
    95939598    {
    9594         *pu128Dst = u128Value;
     9599        pu128Dst->au64[0] = u128Value.au64[0];
     9600        pu128Dst->au64[1] = u128Value.au64[1];
    95959601        rc = iemMemCommitAndUnmap(pVCpu, pu128Dst, IEM_ACCESS_DATA_W);
    95969602    }
    … …  
    96119617 */
    96129618DECL_NO_INLINE(IEM_STATIC, void)
    9613 iemMemStoreDataU128AlignedSseJmp(PVMCPU pVCpu, uint8_t iSegReg, RTGCPTR GCPtrMem, uint128_t u128Value)
     9619iemMemStoreDataU128AlignedSseJmp(PVMCPU pVCpu, uint8_t iSegReg, RTGCPTR GCPtrMem, RTUINT128U u128Value)
    96149620{
    96159621    /* The lazy approach for now... */
    … …  
    96179623        || (IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.MXCSR & X86_MXSCR_MM)) /** @todo should probably check this *after* applying seg.u64Base... Check real HW. */
    96189624    {
    9619         uint128_t *pu128Dst = (uint128_t *)iemMemMapJmp(pVCpu, sizeof(*pu128Dst), iSegReg, GCPtrMem, IEM_ACCESS_DATA_W);
    9620         *pu128Dst = u128Value;
     9625        PRTUINT128U pu128Dst = (PRTUINT128U)iemMemMapJmp(pVCpu, sizeof(*pu128Dst), iSegReg, GCPtrMem, IEM_ACCESS_DATA_W);
     9626        pu128Dst->au64[0] = u128Value.au64[0];
     9627        pu128Dst->au64[1] = u128Value.au64[1];
    96219628        iemMemCommitAndUnmapJmp(pVCpu, pu128Dst, IEM_ACCESS_DATA_W);
    96229629        return;
    … …  
    1053310540        if ((pVCpu)->iem.s.CTX_SUFF(pCtx)->CTX_SUFF(pXState)->x87.FSW & X86_FSW_ES) \
    1053410541            return iemRaiseMathFault(pVCpu); \
     10542    } while (0)
     10543#define IEM_MC_MAYBE_RAISE_SSE3_RELATED_XCPT() \
     10544    do { \
     10545        if (   (IEM_GET_CTX(pVCpu)->cr0 & X86_CR0_EM) \
     10546            || !(IEM_GET_CTX(pVCpu)->cr4 & X86_CR4_OSFXSR) \
     10547            || !IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSse3) \
     10548            return iemRaiseUndefinedOpcode(pVCpu); \
     10549        if (IEM_GET_CTX(pVCpu)->cr0 & X86_CR0_TS) \
     10550            return iemRaiseDeviceNotAvailable(pVCpu); \
    1053510551    } while (0)
    1053610552#define IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT() \
    … …  
    1075410770
    1075510771#define IEM_MC_FETCH_XREG_U128(a_u128Value, a_iXReg) \
    10756     do { (a_u128Value) = IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].xmm; } while (0)
     10772    do { (a_u128Value).au64[0] = IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].au64[0]; \
     10773         (a_u128Value).au64[1] = IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].au64[1]; \
     10774    } while (0)
    1075710775#define IEM_MC_FETCH_XREG_U64(a_u64Value, a_iXReg) \
    1075810776    do { (a_u64Value) = IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].au64[0]; } while (0)
    … …  
    1076210780    do { (a_u64Value) = IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].au64[1]; } while (0)
    1076310781#define IEM_MC_STORE_XREG_U128(a_iXReg, a_u128Value) \
    10764     do { IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].xmm = (a_u128Value); } while (0)
     10782    do { IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].au64[0] = (a_u128Value).au64[0]; \
     10783         IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].au64[1] = (a_u128Value).au64[1]; \
     10784    } while (0)
    1076510785#define IEM_MC_STORE_XREG_U64(a_iXReg, a_u64Value) \
    1076610786    do { IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].au64[0] = (a_u64Value); } while (0)
    … …  
    1077610796    } while (0)
    1077710797#define IEM_MC_REF_XREG_U128(a_pu128Dst, a_iXReg)       \
    10778     (a_pu128Dst) = (&IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].xmm)
     10798    (a_pu128Dst) = (&IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].uXmm)
    1077910799#define IEM_MC_REF_XREG_U128_CONST(a_pu128Dst, a_iXReg) \
    10780     (a_pu128Dst) = ((uint128_t const *)&IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].xmm)
     10800    (a_pu128Dst) = ((PCRTUINT128U)&IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].uXmm)
    1078110801#define IEM_MC_REF_XREG_U64_CONST(a_pu64Dst, a_iXReg) \
    1078210802    (a_pu64Dst) = ((uint64_t const *)&IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXReg)].au64[0])
    1078310803#define IEM_MC_COPY_XREG_U128(a_iXRegDst, a_iXRegSrc) \
    10784     do { IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXRegDst)].xmm \
    10785             = IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXRegSrc)].xmm; } while (0)
     10804    do { IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXRegDst)].au64[0] \
     10805            = IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXRegSrc)].au64[0]; \
     10806         IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXRegDst)].au64[1] \
     10807            = IEM_GET_CTX(pVCpu)->CTX_SUFF(pXState)->x87.aXMM[(a_iXRegSrc)].au64[1]; \
     10808    } while (0)
    1078610809
    1078710810#ifndef IEM_WITH_SETJMP

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

    r65634 r66314  
    13711371}
    13721372
     1373
     1374IEM_DECL_IMPL_DEF(void, iemAImpl_movsldup,(PCX86FXSTATE pFpuState, PRTUINT128U puDst, PCRTUINT128U puSrc))
     1375{
     1376    RT_NOREF(pFpuState);
     1377    puDst->au32[0] = puSrc->au32[0];
     1378    puDst->au32[1] = puSrc->au32[0];
     1379    puDst->au32[2] = puSrc->au32[2];
     1380    puDst->au32[3] = puSrc->au32[2];
     1381}
     1382

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

    r66313 r66314  
    165165    'Wps':  ( 'IDX_UseModRM',       'rm',     '%Wps', 'Wps',     ),
    166166    'Wpd':  ( 'IDX_UseModRM',       'rm',     '%Wpd', 'Wpd',     ),
     167    'Wdq':  ( 'IDX_UseModRM',       'rm',     '%Wdq', 'Wdq',     ),
    167168
    168169    # ModR/M.rm - register only.
    … …  
    183184    'Vpd':  ( 'IDX_UseModRM',       'reg',    '%Vpd', 'Vpd',     ),
    184185    'Vq':   ( 'IDX_UseModRM',       'reg',    '%Vq',  'Vq',      ),
     186    'Vdq':  ( 'IDX_UseModRM',       'reg',    '%Vpd', 'Vpd',     ),
    185187
    186188    # Immediate values.

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

    r66313 r66314  
    11091109         */
    11101110        IEM_MC_BEGIN(0, 2);
    1111         IEM_MC_LOCAL(uint128_t,                 uSrc); /** @todo optimize this one day... */
     1111        IEM_MC_LOCAL(RTUINT128U,                uSrc); /** @todo optimize this one day... */
    11121112        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    11131113
    … …  
    11601160         */
    11611161        IEM_MC_BEGIN(0, 2);
    1162         IEM_MC_LOCAL(uint128_t,                 uSrc); /** @todo optimize this one day... */
     1162        IEM_MC_LOCAL(RTUINT128U,                uSrc); /** @todo optimize this one day... */
    11631163        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    11641164
    … …  
    13971397}
    13981398
    1399 
    1400 /** Opcode 0xf3 0x0f 0x12. */
     1399#if 0
    14011400FNIEMOP_STUB(iemOp_vmovsldup_Vx_Wx); //NEXT
     1401#else
     1402/**
     1403 * opcode      0x12
     1404 * opcodesub   !11 mr/reg
     1405 * oppfx       0xf3
     1406 * opcpuid     sse3
     1407 * opgroup     og_sse3_pcksclr_datamove
     1408 * opxcpttype  4
     1409 * optest      op1=-1 op2=0xdddddddd00000002eeeeeeee00000001 ->
     1410 *              op1=0x00000002000000020000000100000001
     1411 */
     1412FNIEMOP_DEF(iemOp_vmovsldup_Vx_Wx)
     1413{
     1414    IEMOP_MNEMONIC2(RM, MOVSLDUP, movsldup, Vdq, Wdq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1415    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     1416    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     1417    {
     1418        /*
     1419         * Register, register.
     1420         */
     1421        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1422        IEM_MC_BEGIN(2, 0);
     1423        IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
     1424        IEM_MC_ARG(PCRTUINT128U,                puSrc, 1);
     1425
     1426        IEM_MC_MAYBE_RAISE_SSE3_RELATED_XCPT();
     1427        IEM_MC_PREPARE_SSE_USAGE();
     1428
     1429        IEM_MC_REF_XREG_U128_CONST(puSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     1430        IEM_MC_REF_XREG_U128(puDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1431        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_movsldup, puDst, puSrc);
     1432
     1433        IEM_MC_ADVANCE_RIP();
     1434        IEM_MC_END();
     1435    }
     1436    else
     1437    {
     1438        /*
     1439         * Register, memory.
     1440         */
     1441        IEM_MC_BEGIN(2, 2);
     1442        IEM_MC_LOCAL(RTUINT128U,                uSrc);
     1443        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
     1444        IEM_MC_ARG(PRTUINT128U,                 puDst, 0);
     1445        IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      puSrc, uSrc, 1);
     1446
     1447        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     1448        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     1449        IEM_MC_MAYBE_RAISE_SSE3_RELATED_XCPT();
     1450        IEM_MC_PREPARE_SSE_USAGE();
     1451
     1452        IEM_MC_FETCH_MEM_U128(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     1453        IEM_MC_REF_XREG_U128(puDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
     1454        IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_movsldup, puDst, puSrc);
     1455
     1456        IEM_MC_ADVANCE_RIP();
     1457        IEM_MC_END();
     1458    }
     1459    return VINF_SUCCESS;
     1460
     1461}
     1462#endif
    14021463
    14031464/** Opcode 0xf2 0x0f 0x12. */
    … …  
    16861747         */
    16871748        IEM_MC_BEGIN(0, 2);
    1688         IEM_MC_LOCAL(uint128_t,                 uSrc); /** @todo optimize this one day... */
     1749        IEM_MC_LOCAL(RTUINT128U,                uSrc); /** @todo optimize this one day... */
    16891750        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    16901751
    … …  
    17281789         */
    17291790        IEM_MC_BEGIN(0, 2);
    1730         IEM_MC_LOCAL(uint128_t,                 uSrc); /** @todo optimize this one day... */
     1791        IEM_MC_LOCAL(RTUINT128U,                uSrc); /** @todo optimize this one day... */
    17311792        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    17321793
    … …  
    17731834         */
    17741835        IEM_MC_BEGIN(0, 2);
    1775         IEM_MC_LOCAL(uint128_t,                 uSrc); /** @todo optimize this one day... */
     1836        IEM_MC_LOCAL(RTUINT128U,                uSrc); /** @todo optimize this one day... */
    17761837        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    17771838
    … …  
    18151876         */
    18161877        IEM_MC_BEGIN(0, 2);
    1817         IEM_MC_LOCAL(uint128_t,                 uSrc); /** @todo optimize this one day... */
     1878        IEM_MC_LOCAL(RTUINT128U,                uSrc); /** @todo optimize this one day... */
    18181879        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    18191880
    … …  
    18571918         */
    18581919        IEM_MC_BEGIN(0, 2);
    1859         IEM_MC_LOCAL(uint128_t,                 uSrc); /** @todo optimize this one day... */
     1920        IEM_MC_LOCAL(RTUINT128U,                uSrc); /** @todo optimize this one day... */
    18601921        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    18611922
    … …  
    18881949         */
    18891950        IEM_MC_BEGIN(0, 2);
    1890         IEM_MC_LOCAL(uint128_t,                 uSrc); /** @todo optimize this one day... */
     1951        IEM_MC_LOCAL(RTUINT128U,                uSrc); /** @todo optimize this one day... */
    18911952        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    18921953
    … …  
    23652426        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    23662427        IEM_MC_BEGIN(2, 0);
    2367         IEM_MC_ARG(uint128_t *,          pDst, 0);
     2428        IEM_MC_ARG(PRTUINT128U,          pDst, 0);
    23682429        IEM_MC_ARG(uint64_t const *,     pSrc, 1);
    23692430        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    … …  
    23812442         */
    23822443        IEM_MC_BEGIN(2, 2);
    2383         IEM_MC_ARG(uint128_t *,                 pDst,       0);
     2444        IEM_MC_ARG(PRTUINT128U,                 pDst,       0);
    23842445        IEM_MC_LOCAL(uint64_t,                  uSrc);
    23852446        IEM_MC_ARG_LOCAL_REF(uint64_t const *,  pSrc, uSrc, 1);
    … …  
    26262687        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    26272688        IEM_MC_BEGIN(2, 0);
    2628         IEM_MC_ARG(uint128_t *,          pDst, 0);
    2629         IEM_MC_ARG(uint128_t const *,    pSrc, 1);
     2689        IEM_MC_ARG(PRTUINT128U,          pDst, 0);
     2690        IEM_MC_ARG(PCRTUINT128U,         pSrc, 1);
    26302691        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    26312692        IEM_MC_PREPARE_SSE_USAGE();
    … …  
    26422703         */
    26432704        IEM_MC_BEGIN(2, 2);
    2644         IEM_MC_ARG(uint128_t *,                 pDst,       0);
    2645         IEM_MC_LOCAL(uint128_t,                 uSrc);
    2646         IEM_MC_ARG_LOCAL_REF(uint128_t const *, pSrc, uSrc, 1);
     2705        IEM_MC_ARG(PRTUINT128U,                 pDst,       0);
     2706        IEM_MC_LOCAL(RTUINT128U,                uSrc);
     2707        IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      pSrc, uSrc, 1);
    26472708        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    26482709
    … …  
    29242985         */
    29252986        IEM_MC_BEGIN(0, 2);
    2926         IEM_MC_LOCAL(uint128_t, u128Tmp);
     2987        IEM_MC_LOCAL(RTUINT128U, u128Tmp);
    29272988        IEM_MC_LOCAL(RTGCPTR,    GCPtrEffSrc);
    29282989
    … …  
    29653026         */
    29663027        IEM_MC_BEGIN(0, 2);
    2967         IEM_MC_LOCAL(uint128_t, u128Tmp);
     3028        IEM_MC_LOCAL(RTUINT128U, u128Tmp);
    29683029        IEM_MC_LOCAL(RTGCPTR,    GCPtrEffSrc);
    29693030
    … …  
    30493110
    30503111        IEM_MC_BEGIN(3, 0);
    3051         IEM_MC_ARG(uint128_t *,         pDst, 0);
    3052         IEM_MC_ARG(uint128_t const *,   pSrc, 1);
     3112        IEM_MC_ARG(PRTUINT128U,         pDst, 0);
     3113        IEM_MC_ARG(PCRTUINT128U,        pSrc, 1);
    30533114        IEM_MC_ARG_CONST(uint8_t,       bEvilArg, /*=*/ bEvil, 2);
    30543115        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    … …  
    30663127         */
    30673128        IEM_MC_BEGIN(3, 2);
    3068         IEM_MC_ARG(uint128_t *,                 pDst,       0);
    3069         IEM_MC_LOCAL(uint128_t,                 uSrc);
    3070         IEM_MC_ARG_LOCAL_REF(uint128_t const *, pSrc, uSrc, 1);
     3129        IEM_MC_ARG(PRTUINT128U,                 pDst,       0);
     3130        IEM_MC_LOCAL(RTUINT128U,                uSrc);
     3131        IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      pSrc, uSrc, 1);
    30713132        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    30723133
    … …  
    31023163
    31033164        IEM_MC_BEGIN(3, 0);
    3104         IEM_MC_ARG(uint128_t *,         pDst, 0);
    3105         IEM_MC_ARG(uint128_t const *,   pSrc, 1);
     3165        IEM_MC_ARG(PRTUINT128U,         pDst, 0);
     3166        IEM_MC_ARG(PCRTUINT128U,        pSrc, 1);
    31063167        IEM_MC_ARG_CONST(uint8_t,       bEvilArg, /*=*/ bEvil, 2);
    31073168        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    … …  
    31193180         */
    31203181        IEM_MC_BEGIN(3, 2);
    3121         IEM_MC_ARG(uint128_t *,                 pDst,       0);
    3122         IEM_MC_LOCAL(uint128_t,                 uSrc);
    3123         IEM_MC_ARG_LOCAL_REF(uint128_t const *, pSrc, uSrc, 1);
     3182        IEM_MC_ARG(PRTUINT128U,                 pDst,       0);
     3183        IEM_MC_LOCAL(RTUINT128U,                uSrc);
     3184        IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      pSrc, uSrc, 1);
    31243185        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    31253186
    … …  
    31553216
    31563217        IEM_MC_BEGIN(3, 0);
    3157         IEM_MC_ARG(uint128_t *,         pDst, 0);
    3158         IEM_MC_ARG(uint128_t const *,   pSrc, 1);
     3218        IEM_MC_ARG(PRTUINT128U,         pDst, 0);
     3219        IEM_MC_ARG(PCRTUINT128U,        pSrc, 1);
    31593220        IEM_MC_ARG_CONST(uint8_t,       bEvilArg, /*=*/ bEvil, 2);
    31603221        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    … …  
    31723233         */
    31733234        IEM_MC_BEGIN(3, 2);
    3174         IEM_MC_ARG(uint128_t *,                 pDst,       0);
    3175         IEM_MC_LOCAL(uint128_t,                 uSrc);
    3176         IEM_MC_ARG_LOCAL_REF(uint128_t const *, pSrc, uSrc, 1);
     3235        IEM_MC_ARG(PRTUINT128U,                 pDst,       0);
     3236        IEM_MC_LOCAL(RTUINT128U,                uSrc);
     3237        IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      pSrc, uSrc, 1);
    31773238        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    31783239
    … …  
    34073468        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    34083469        IEM_MC_BEGIN(2, 0);
    3409         IEM_MC_ARG(uint128_t *,          pDst, 0);
    3410         IEM_MC_ARG(uint128_t const *,    pSrc, 1);
     3470        IEM_MC_ARG(PRTUINT128U,          pDst, 0);
     3471        IEM_MC_ARG(PCRTUINT128U,         pSrc, 1);
    34113472        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    34123473        IEM_MC_PREPARE_SSE_USAGE();
    … …  
    34233484         */
    34243485        IEM_MC_BEGIN(2, 2);
    3425         IEM_MC_ARG(uint128_t *,                 pDst,       0);
    3426         IEM_MC_LOCAL(uint128_t,                 uSrc);
    3427         IEM_MC_ARG_LOCAL_REF(uint128_t const *, pSrc, uSrc, 1);
     3486        IEM_MC_ARG(PRTUINT128U,                 pDst,       0);
     3487        IEM_MC_LOCAL(RTUINT128U,                uSrc);
     3488        IEM_MC_ARG_LOCAL_REF(PCRTUINT128U,      pSrc, uSrc, 1);
    34283489        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    34293490
    … …  
    37313792         */
    37323793        IEM_MC_BEGIN(0, 2);
    3733         IEM_MC_LOCAL(uint128_t, u128Tmp);
     3794        IEM_MC_LOCAL(RTUINT128U, u128Tmp);
    37343795        IEM_MC_LOCAL(RTGCPTR,    GCPtrEffSrc);
    37353796
    … …  
    37733834         */
    37743835        IEM_MC_BEGIN(0, 2);
    3775         IEM_MC_LOCAL(uint128_t, u128Tmp);
     3836        IEM_MC_LOCAL(RTUINT128U, u128Tmp);
    37763837        IEM_MC_LOCAL(RTGCPTR,    GCPtrEffSrc);
    37773838
    … …  
    74547515            IEM_MC_BEGIN(2, 0);
    74557516            IEM_MC_ARG(uint64_t *,           pDst, 0);
    7456             IEM_MC_ARG(uint128_t const *,    pSrc, 1);
     7517            IEM_MC_ARG(PCRTUINT128U,         pSrc, 1);
    74577518            IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    74587519            IEM_MC_PREPARE_SSE_USAGE();
    … …  
    75317592        IEM_MC_BEGIN(2, 0);
    75327593        IEM_MC_ARG(uint64_t *,           pDst, 0);
    7533         IEM_MC_ARG(uint128_t const *,    pSrc, 1);
     7594        IEM_MC_ARG(PCRTUINT128U,         pSrc, 1);
    75347595        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    75357596        IEM_MC_PREPARE_SSE_USAGE();
    … …  
    76927753        IEMOP_MNEMONIC(vmovntdq_Mx_Vx, "vmovntdq Mx,Vx");
    76937754        IEM_MC_BEGIN(0, 2);
    7694         IEM_MC_LOCAL(uint128_t,                 uSrc);
     7755        IEM_MC_LOCAL(RTUINT128U,                uSrc);
    76957756        IEM_MC_LOCAL(RTGCPTR,                   GCPtrEffSrc);
    76967757

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

    r66160 r66314  
    15081508typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF2U64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src));
    15091509typedef FNIEMAIMPLMEDIAF2U64   *PFNIEMAIMPLMEDIAF2U64;
    1510 typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF2U128,(PCX86FXSTATE pFpuState, uint128_t *pu128Dst, uint128_t const *pu128Src));
     1510typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF2U128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src));
    15111511typedef FNIEMAIMPLMEDIAF2U128  *PFNIEMAIMPLMEDIAF2U128;
    15121512FNIEMAIMPLMEDIAF2U64  iemAImpl_pxor_u64,  iemAImpl_pcmpeqb_u64,  iemAImpl_pcmpeqw_u64,  iemAImpl_pcmpeqd_u64;
    … …  
    15181518typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF1L1U64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint32_t const *pu32Src));
    15191519typedef FNIEMAIMPLMEDIAF1L1U64   *PFNIEMAIMPLMEDIAF1L1U64;
    1520 typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF1L1U128,(PCX86FXSTATE pFpuState, uint128_t *pu128Dst, uint64_t const *pu64Src));
     1520typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF1L1U128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, uint64_t const *pu64Src));
    15211521typedef FNIEMAIMPLMEDIAF1L1U128  *PFNIEMAIMPLMEDIAF1L1U128;
    15221522FNIEMAIMPLMEDIAF1L1U64  iemAImpl_punpcklbw_u64,  iemAImpl_punpcklwd_u64,  iemAImpl_punpckldq_u64;
    … …  
    15281528typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF1H1U64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src));
    15291529typedef FNIEMAIMPLMEDIAF2U64   *PFNIEMAIMPLMEDIAF1H1U64;
    1530 typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF1H1U128,(PCX86FXSTATE pFpuState, uint128_t *pu128Dst, uint128_t const *pu128Src));
     1530typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAF1H1U128,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst, PCRTUINT128U pu128Src));
    15311531typedef FNIEMAIMPLMEDIAF2U128  *PFNIEMAIMPLMEDIAF1H1U128;
    15321532FNIEMAIMPLMEDIAF1H1U64  iemAImpl_punpckhbw_u64,  iemAImpl_punpckhwd_u64,  iemAImpl_punpckhdq_u64;
    … …  
    15361536/** @name Media (SSE/MMX/AVX) operation: Packed Shuffle Stuff (evil)
    15371537 * @{ */
    1538 typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAPSHUF,(PCX86FXSTATE pFpuState, uint128_t *pu128Dst,
    1539                                                        uint128_t const *pu128Src, uint8_t bEvil));
     1538typedef IEM_DECL_IMPL_TYPE(void, FNIEMAIMPLMEDIAPSHUF,(PCX86FXSTATE pFpuState, PRTUINT128U pu128Dst,
     1539                                                       PCRTUINT128U pu128Src, uint8_t bEvil));
    15401540typedef FNIEMAIMPLMEDIAPSHUF *PFNIEMAIMPLMEDIAPSHUF;
    15411541FNIEMAIMPLMEDIAPSHUF iemAImpl_pshufhw, iemAImpl_pshuflw, iemAImpl_pshufd;
    … …  
    15461546 * @{ */
    15471547IEM_DECL_IMPL_DEF(void, iemAImpl_pmovmskb_u64,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint64_t const *pu64Src));
    1548 IEM_DECL_IMPL_DEF(void, iemAImpl_pmovmskb_u128,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, uint128_t const *pu128Src));
    1549 /** @} */
    1550 
     1548IEM_DECL_IMPL_DEF(void, iemAImpl_pmovmskb_u128,(PCX86FXSTATE pFpuState, uint64_t *pu64Dst, PCRTUINT128U pu128Src));
     1549/** @} */
     1550
     1551/** @name Media (SSE/MMX/AVX) operation: Sort this later
     1552 * @{ */
     1553IEM_DECL_IMPL_DEF(void, iemAImpl_movsldup,(PCX86FXSTATE pFpuState, PRTUINT128U puDst, PCRTUINT128U puSrc));
     1554/** @} */
    15511555
    15521556

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

    r66309 r66314  
    3737bool volatile       g_fRandom;
    3838uint8_t volatile    g_bRandom;
    39 uint128_t           g_u128Zero;
     39RTUINT128U          g_u128Zero;
    4040
    4141
    … …  
    345345#define IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT()           do {} while (0)
    346346#define IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT()          do {} while (0)
     347#define IEM_MC_MAYBE_RAISE_SSE3_RELATED_XCPT()          do {} while (0)
    347348#define IEM_MC_RAISE_GP0_IF_CPL_NOT_ZERO()              do {} while (0)
    348349#define IEM_MC_RAISE_GP0_IF_EFF_ADDR_UNALIGNED(a_EffAddr, a_cbAlign) \
    … …  
    495496#define IEM_MC_REF_MREG_U32_CONST(a_pu32Dst, a_iMReg)       do { (a_pu32Dst) = (uint32_t const *)((uintptr_t)0); CHK_PTYPE(uint32_t const *, a_pu32Dst); (void)fFpuWrite; } while (0)
    496497
    497 #define IEM_MC_FETCH_XREG_U128(a_u128Value, a_iXReg)        do { (a_u128Value) = g_u128Zero; CHK_TYPE(uint128_t, a_u128Value); (void)fSseRead;  } while (0)
     498#define IEM_MC_FETCH_XREG_U128(a_u128Value, a_iXReg)        do { (a_u128Value) = g_u128Zero; CHK_TYPE(RTUINT128U, a_u128Value); (void)fSseRead;  } while (0)
    498499#define IEM_MC_FETCH_XREG_U64(a_u64Value, a_iXReg)          do { (a_u64Value) = 0; CHK_TYPE(uint64_t, a_u64Value); (void)fSseRead; } while (0)
    499500#define IEM_MC_FETCH_XREG_U32(a_u32Value, a_iXReg)          do { (a_u32Value) = 0; CHK_TYPE(uint32_t, a_u32Value); (void)fSseRead; } while (0)
    500501#define IEM_MC_FETCH_XREG_HI_U64(a_u64Value, a_iXReg)       do { (a_u64Value) = 0; CHK_TYPE(uint64_t, a_u64Value); (void)fSseRead; } while (0)
    501 #define IEM_MC_STORE_XREG_U128(a_iXReg, a_u128Value)        do { CHK_TYPE(uint128_t, a_u128Value); (void)fSseWrite; } while (0)
     502#define IEM_MC_STORE_XREG_U128(a_iXReg, a_u128Value)        do { CHK_TYPE(RTUINT128U, a_u128Value); (void)fSseWrite; } while (0)
    502503#define IEM_MC_STORE_XREG_U64(a_iXReg, a_u64Value)          do { CHK_TYPE(uint64_t,  a_u64Value);  (void)fSseWrite; } while (0)
    503504#define IEM_MC_STORE_XREG_U64_ZX_U128(a_iXReg, a_u64Value)  do { CHK_TYPE(uint64_t,  a_u64Value);  (void)fSseWrite; } while (0)
    504505#define IEM_MC_STORE_XREG_U32(a_iXReg, a_u32Value)          do { CHK_TYPE(uint32_t,  a_u32Value);  (void)fSseWrite; } while (0)
    505506#define IEM_MC_STORE_XREG_U32_ZX_U128(a_iXReg, a_u32Value)  do { CHK_TYPE(uint32_t,  a_u32Value);  (void)fSseWrite; } while (0)
    506 #define IEM_MC_REF_XREG_U128(a_pu128Dst, a_iXReg)           do { (a_pu128Dst) = (uint128_t *)((uintptr_t)0);        CHK_PTYPE(uint128_t *, a_pu128Dst);       (void)fSseWrite; } while (0)
    507 #define IEM_MC_REF_XREG_U128_CONST(a_pu128Dst, a_iXReg)     do { (a_pu128Dst) = (uint128_t const *)((uintptr_t)0);  CHK_PTYPE(uint128_t const *, a_pu128Dst); (void)fSseWrite; } while (0)
     507#define IEM_MC_REF_XREG_U128(a_pu128Dst, a_iXReg)           do { (a_pu128Dst) = (PRTUINT128U)((uintptr_t)0);        CHK_PTYPE(PRTUINT128U, a_pu128Dst);       (void)fSseWrite; } while (0)
     508#define IEM_MC_REF_XREG_U128_CONST(a_pu128Dst, a_iXReg)     do { (a_pu128Dst) = (PCRTUINT128U)((uintptr_t)0);  CHK_PTYPE(PCRTUINT128U, a_pu128Dst); (void)fSseWrite; } while (0)
    508509#define IEM_MC_REF_XREG_U64_CONST(a_pu64Dst, a_iXReg)       do { (a_pu64Dst)  = (uint64_t const *)((uintptr_t)0);   CHK_PTYPE(uint64_t const *, a_pu64Dst);   (void)fSseWrite; } while (0)
    509510#define IEM_MC_COPY_XREG_U128(a_iXRegDst, a_iXRegSrc)       do { (void)fSseWrite; } while (0)
    … …  
    545546#define IEM_MC_FETCH_MEM_R64(a_r64Dst, a_iSeg, a_GCPtrMem)              do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTFLOAT64U, a_r64Dst);} while (0)
    546547#define IEM_MC_FETCH_MEM_R80(a_r80Dst, a_iSeg, a_GCPtrMem)              do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTFLOAT80U, a_r80Dst);} while (0)
    547 #define IEM_MC_FETCH_MEM_U128(a_u128Dst, a_iSeg, a_GCPtrMem)            do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(uint128_t, a_u128Dst);} while (0)
    548 #define IEM_MC_FETCH_MEM_U128_ALIGN_SSE(a_u128Dst, a_iSeg, a_GCPtrMem)  do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(uint128_t, a_u128Dst);} while (0)
     548#define IEM_MC_FETCH_MEM_U128(a_u128Dst, a_iSeg, a_GCPtrMem)            do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTUINT128U, a_u128Dst);} while (0)
     549#define IEM_MC_FETCH_MEM_U128_ALIGN_SSE(a_u128Dst, a_iSeg, a_GCPtrMem)  do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTUINT128U, a_u128Dst);} while (0)
    549550
    550551#define IEM_MC_STORE_MEM_U8(a_iSeg, a_GCPtrMem, a_u8Value)              do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(uint8_t,  a_u8Value); CHK_SEG_IDX(a_iSeg); } while (0)
    … …  
    563564#define IEM_MC_STORE_MEM_NEG_QNAN_R64_BY_REF(a_pr64Dst)                 do { CHK_TYPE(PRTFLOAT64U, a_pr64Dst); } while (0)
    564565#define IEM_MC_STORE_MEM_NEG_QNAN_R80_BY_REF(a_pr80Dst)                 do { CHK_TYPE(PRTFLOAT80U, a_pr80Dst); } while (0)
    565 #define IEM_MC_STORE_MEM_U128(a_iSeg, a_GCPtrMem, a_u128Dst)            do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(uint128_t, a_u128Dst); CHK_SEG_IDX(a_iSeg);} while (0)
    566 #define IEM_MC_STORE_MEM_U128_ALIGN_SSE(a_iSeg, a_GCPtrMem, a_u128Dst)  do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(uint128_t, a_u128Dst); CHK_SEG_IDX(a_iSeg);} while (0)
     566#define IEM_MC_STORE_MEM_U128(a_iSeg, a_GCPtrMem, a_u128Dst)            do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTUINT128U, a_u128Dst); CHK_SEG_IDX(a_iSeg);} while (0)
     567#define IEM_MC_STORE_MEM_U128_ALIGN_SSE(a_iSeg, a_GCPtrMem, a_u128Dst)  do { CHK_GCPTR(a_GCPtrMem); CHK_TYPE(RTUINT128U, a_u128Dst); CHK_SEG_IDX(a_iSeg);} while (0)
    567568
    568569#define IEM_MC_PUSH_U16(a_u16Value)                                     do {} while (0)
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