VirtualBox

Changeset 104076 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
Mar 27, 2024 8:19:25 AM (10 months ago)
Author:
vboxsync
Message:

VMM/IEM: Implement 'microcoded' vpinsr[bwdq] instruction decode, dispatch & emulation, bugref:9898

  • eliminate '256 immediate instructions' jumptable implementations of pinsrw, vpinsrw
  • eliminate 'fallback' C implementations of pinsrw, vpinsrw
  • add 'IEM_MC_FETCH_MREG_U8' micro-op
  • add 'IEM_MC_STORE_MREG_U8, IEM_MC_STORE_MREG_U16, IEM_MC_STORE_MREG_U32' micro-ops
  • fix 'IEM_MC_STORE_XREG_U8' micro-op to store 8, not 32 bits (at the right offset)
  • fix 'IEM_MC_STORE_XREG_U16' micro-op to store 16, not 32 bits (at the right offset)
Location:
trunk/src/VBox/VMM/VMMAll
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r104051 r104076  
    59265926
    59275927;;
    5928 ; pinsrw instruction.
    5929 ;
    5930 ; @param    A0      Pointer to the first media register size operand (input/output).
    5931 ; @param    A1      The 16 bit input operand (input).
    5932 ; @param    A2      The 8-bit immediate
    5933 ;
    5934 BEGINPROC_FASTCALL iemAImpl_pinsrw_u64, 16
    5935         PROLOGUE_3_ARGS
    5936         IEMIMPL_SSE_PROLOGUE
    5937 
    5938         movzx   A2, A2_8                ; must clear top bits
    5939         movq    mm0,  [A0]
    5940         lea     T1, [.imm0 xWrtRIP]
    5941  %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
    5942         lea     T0, [A2 + A2*8]         ; sizeof(endbrxx+pinsrw+ret) == 9: A2 * 9
    5943  %else
    5944         lea     T0, [A2 + A2*4]         ; sizeof(pinsrw+ret)         == 5: A2 * 5
    5945  %endif
    5946         lea     T1, [T1 + T0]
    5947         IBT_NOTRACK
    5948         call    T1
    5949         movq    [A0], mm0
    5950 
    5951         IEMIMPL_SSE_EPILOGUE
    5952         EPILOGUE_3_ARGS
    5953  %assign bImm 0
    5954  %rep 256
    5955 .imm %+ bImm:
    5956         IBT_ENDBRxx_WITHOUT_NOTRACK
    5957         pinsrw  mm0, A1_32, bImm
    5958         ret
    5959   %assign bImm bImm + 1
    5960  %endrep
    5961 .immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x500
    5962 ENDPROC iemAImpl_pinsrw_u64
    5963 
    5964 BEGINPROC_FASTCALL iemAImpl_pinsrw_u128, 16
    5965         PROLOGUE_3_ARGS
    5966         IEMIMPL_SSE_PROLOGUE
    5967 
    5968         movzx   A2, A2_8                ; must clear top bits
    5969         movdqu  xmm0, [A0]
    5970         lea     T1, [.imm0 xWrtRIP]
    5971  %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
    5972         lea     T0, [A2 + A2*4]         ; sizeof(endbrxx+pinsrw+ret) == 10: A2 * 10 = (A2 * 5) * 2
    5973  %else
    5974         lea     T0, [A2 + A2*2]         ; sizeof(pinsrw+ret)         ==  6: A2 *  6 = (A2 * 3) * 2
    5975  %endif
    5976         lea     T1, [T1 + T0*2]
    5977         IBT_NOTRACK
    5978         call    T1
    5979         movdqu  [A0], xmm0
    5980 
    5981         IEMIMPL_SSE_EPILOGUE
    5982         EPILOGUE_3_ARGS
    5983  %assign bImm 0
    5984  %rep 256
    5985 .imm %+ bImm:
    5986         IBT_ENDBRxx_WITHOUT_NOTRACK
    5987         pinsrw  xmm0, A1_32, bImm
    5988         ret
    5989   %assign bImm bImm + 1
    5990  %endrep
    5991 .immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    5992 ENDPROC iemAImpl_pinsrw_u128
    5993 
    5994 ;;
    5995 ; vpinsrw instruction.
    5996 ;
    5997 ; @param    A0      Pointer to the first media register size operand (output).
    5998 ; @param    A1      Pointer to the source media register size operand (input).
    5999 ; @param    A2      The 16 bit input operand (input).
    6000 ; @param    A3      The 8-bit immediate
    6001 ;
    6002 BEGINPROC_FASTCALL iemAImpl_vpinsrw_u128, 16
    6003         PROLOGUE_4_ARGS
    6004         IEMIMPL_SSE_PROLOGUE
    6005 
    6006         movzx   A3, A3_8                ; must clear top bits
    6007         movdqu  xmm0, [A1]
    6008         lea     T1, [.imm0 xWrtRIP]
    6009  %ifdef RT_WITH_IBT_BRANCH_PROTECTION_WITHOUT_NOTRACK
    6010         lea     T0, [A3 + A3*4]         ; sizeof(endbrxx+vpinsrw+ret) == 10: A3 * 10 = (A3 * 5) * 2
    6011  %else
    6012         lea     T0, [A3 + A3*2]         ; sizeof(vpinsrw+ret)         ==  6: A3 *  6 = (A3 * 3) * 2
    6013  %endif
    6014         lea     T1, [T1 + T0*2]
    6015         mov     A1, A2                  ; A2 requires longer encoding on Windows
    6016         IBT_NOTRACK
    6017         call    T1
    6018         movdqu  [A0], xmm0
    6019 
    6020         IEMIMPL_SSE_EPILOGUE
    6021         EPILOGUE_4_ARGS
    6022  %assign bImm 0
    6023  %rep 256
    6024 .imm %+ bImm:
    6025         IBT_ENDBRxx_WITHOUT_NOTRACK
    6026         vpinsrw xmm0, xmm0, A1_32, bImm
    6027         ret
    6028   %assign bImm bImm + 1
    6029  %endrep
    6030 .immEnd: IEMCHECK_256_JUMP_ARRAY_SIZE (.immEnd - .imm0), 0x600
    6031 ENDPROC iemAImpl_vpinsrw_u128
    6032 
    6033 
    6034 ;;
    60355928; movmskp{s,d} SSE instruction template
    60365929;

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

    r104051 r104076  
    1827918279
    1828018280/**
    18281  * [V]PINSRW
    18282  */
    18283 #ifdef IEM_WITHOUT_ASSEMBLY
    18284 IEM_DECL_IMPL_DEF(void, iemAImpl_pinsrw_u64,(uint64_t *pu64Dst, uint16_t u16Src, uint8_t bEvil))
    18285 {
    18286     uint8_t cShift = (bEvil & 0x3) * 16;
    18287     *pu64Dst = (*pu64Dst & ~(UINT64_C(0xffff) << cShift)) | ((uint64_t)u16Src << cShift);
    18288 }
    18289 
    18290 
    18291 IEM_DECL_IMPL_DEF(void, iemAImpl_pinsrw_u128,(PRTUINT128U puDst, uint16_t u16Src, uint8_t bEvil))
    18292 {
    18293     puDst->au16[bEvil & 0x7] = u16Src;
    18294 }
    18295 #endif
    18296 
    18297 
    18298 IEM_DECL_IMPL_DEF(void, iemAImpl_vpinsrw_u128_fallback,(PRTUINT128U puDst, PCRTUINT128U puSrc, uint16_t u16Src, uint8_t bEvil))
    18299 {
    18300     *puDst = *puSrc;
    18301     puDst->au16[bEvil & 0x7] = u16Src;
    18302 }
    18303 
    18304 
    18305 /**
    1830618281 * [V]MOVMSKPS
    1830718282 */

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

    r104075 r104076  
    31003100    'IEM_MC_FETCH_MEM16_U8':                                     (McBlock.parseMcGeneric,           True,  True,  False, ),
    31013101    'IEM_MC_FETCH_MEM32_U8':                                     (McBlock.parseMcGeneric,           True,  True,  False, ),
     3102    'IEM_MC_FETCH_MREG_U8':                                      (McBlock.parseMcGeneric,           False, False, False, ),
    31023103    'IEM_MC_FETCH_MREG_U16':                                     (McBlock.parseMcGeneric,           False, False, False, ),
    31033104    'IEM_MC_FETCH_MREG_U32':                                     (McBlock.parseMcGeneric,           False, False, False, ),
    … …  
    33423343    'IEM_MC_STORE_MEM_U8':                                       (McBlock.parseMcGeneric,           True,  True,  True,  ),
    33433344    'IEM_MC_STORE_MEM_U8_CONST':                                 (McBlock.parseMcGeneric,           True,  True,  True,  ),
     3345    'IEM_MC_STORE_MREG_U8':                                      (McBlock.parseMcGeneric,           True,  True,  False, ),
     3346    'IEM_MC_STORE_MREG_U16':                                     (McBlock.parseMcGeneric,           True,  True,  False, ),
     3347    'IEM_MC_STORE_MREG_U32':                                     (McBlock.parseMcGeneric,           True,  True,  False, ),
    33443348    'IEM_MC_STORE_MREG_U32_ZX_U64':                              (McBlock.parseMcGeneric,           True,  True,  False, ),
    33453349    'IEM_MC_STORE_MREG_U64':                                     (McBlock.parseMcGeneric,           True,  True,  False, ),

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

    r104018 r104076  
    1240712407         * Register, register.
    1240812408         */
     12409        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
    1240912410        IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
    12410         uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     12411        IEM_MC_LOCAL(uint16_t,    uValue);
     12412
    1241112413        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX_EX_2_OR(fSse, fAmdMmxExts);
    12412         IEM_MC_ARG(uint64_t *,           pu64Dst,               0);
    12413         IEM_MC_ARG(uint16_t,             u16Src,                1);
    12414         IEM_MC_ARG_CONST(uint8_t,        bImmArg, /*=*/ bImm,   2);
    1241512414        IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    1241612415        IEM_MC_PREPARE_FPU_USAGE();
    1241712416        IEM_MC_FPU_TO_MMX_MODE();
    12418         IEM_MC_REF_MREG_U64(pu64Dst, IEM_GET_MODRM_REG_8(bRm));
    12419         IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_RM(pVCpu, bRm));
    12420         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_pinsrw_u64, pu64Dst, u16Src, bImmArg);
    12421         IEM_MC_MODIFIED_MREG_BY_REF(pu64Dst);
     12417
     12418        IEM_MC_FETCH_GREG_U16(uValue, IEM_GET_MODRM_RM(pVCpu, bRm));
     12419        IEM_MC_STORE_MREG_U16(IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 3, uValue);
     12420
    1242212421        IEM_MC_ADVANCE_RIP_AND_FINISH();
    1242312422        IEM_MC_END();
    … …  
    1242912428         */
    1243012429        IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
    12431         IEM_MC_ARG(uint64_t *,    pu64Dst,               0);
    12432         IEM_MC_ARG(uint16_t,      u16Src,                1);
    12433         IEM_MC_LOCAL(RTGCPTR,            GCPtrEffSrc);
     12430        IEM_MC_LOCAL(RTGCPTR,     GCPtrEffSrc);
     12431        IEM_MC_LOCAL(uint16_t,    uValue);
    1243412432
    1243512433        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
    1243612434        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
    12437         IEM_MC_ARG_CONST(uint8_t, bImmArg, /*=*/ bImm,   2);
    1243812435        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX_EX_2_OR(fSse, fAmdMmxExts);
    1243912436        IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    1244012437        IEM_MC_PREPARE_FPU_USAGE();
    1244112438
    12442         IEM_MC_FETCH_MEM_U16(u16Src, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     12439        IEM_MC_FETCH_MEM_U16(uValue, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    1244312440        IEM_MC_FPU_TO_MMX_MODE();
    12444 
    12445         IEM_MC_REF_MREG_U64(pu64Dst, IEM_GET_MODRM_REG_8(bRm));
    12446         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_pinsrw_u64, pu64Dst, u16Src, bImmArg);
    12447         IEM_MC_MODIFIED_MREG_BY_REF(pu64Dst);
     12441        IEM_MC_STORE_MREG_U16(IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 3, uValue);
     12442
    1244812443        IEM_MC_ADVANCE_RIP_AND_FINISH();
    1244912444        IEM_MC_END();
    … …  
    1246512460        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
    1246612461        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX_EX(fSse2);
    12467         IEM_MC_ARG(PRTUINT128U,          puDst,                 0);
    12468         IEM_MC_ARG(uint16_t,             u16Src,                1);
    12469         IEM_MC_ARG_CONST(uint8_t,        bImmArg, /*=*/ bImm,   2);
     12462
     12463        IEM_MC_LOCAL(uint16_t,           uValue);
    1247012464        IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    1247112465        IEM_MC_PREPARE_SSE_USAGE();
    12472         IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_RM(pVCpu, bRm));
    12473         IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    12474         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_pinsrw_u128, puDst, u16Src, bImmArg);
     12466
     12467        IEM_MC_FETCH_GREG_U16(uValue, IEM_GET_MODRM_RM(pVCpu, bRm));
     12468        IEM_MC_STORE_XREG_U16(IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 7, uValue);
    1247512469        IEM_MC_ADVANCE_RIP_AND_FINISH();
    1247612470        IEM_MC_END();
    … …  
    1248212476         */
    1248312477        IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
    12484         IEM_MC_ARG(PRTUINT128U,   puDst,                 0);
    12485         IEM_MC_ARG(uint16_t,      u16Src,                1);
    1248612478        IEM_MC_LOCAL(RTGCPTR,            GCPtrEffSrc);
     12479        IEM_MC_LOCAL(uint16_t,           uValue);
    1248712480
    1248812481        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
    1248912482        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
    12490         IEM_MC_ARG_CONST(uint8_t, bImmArg, /*=*/ bImm,   2);
    1249112483        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX_EX(fSse2);
    1249212484        IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT();
    1249312485        IEM_MC_PREPARE_SSE_USAGE();
    1249412486
    12495         IEM_MC_FETCH_MEM_U16(u16Src, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    12496         IEM_MC_REF_XREG_U128(puDst, IEM_GET_MODRM_REG(pVCpu, bRm));
    12497         IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_pinsrw_u128, puDst, u16Src, bImmArg);
     12487        IEM_MC_FETCH_MEM_U16(uValue, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     12488        IEM_MC_STORE_XREG_U16(IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 7, uValue);
    1249812489        IEM_MC_ADVANCE_RIP_AND_FINISH();
    1249912490        IEM_MC_END();

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

    r104058 r104076  
    45934593        IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
    45944594        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     4595        IEM_MC_LOCAL(RTUINT128U,       uSrc1);
     4596        IEM_MC_LOCAL(uint16_t,         uValue);
     4597
    45954598        IEMOP_HLP_DONE_VEX_DECODING_L0_EX(fAvx);
    4596         IEM_MC_ARG(PRTUINT128U,          puDst,                 0);
    4597         IEM_MC_ARG(PCRTUINT128U,         puSrc,                 1);
    4598         IEM_MC_ARG(uint16_t,             u16Src,                2);
    4599         IEM_MC_ARG_CONST(uint8_t,        bImmArg, /*=*/ bImm,   3);
    46004599        IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
    46014600        IEM_MC_PREPARE_AVX_USAGE();
    4602         IEM_MC_REF_XREG_U128(puDst,        IEM_GET_MODRM_REG(pVCpu, bRm));
    4603         IEM_MC_REF_XREG_U128_CONST(puSrc,  IEM_GET_MODRM_RM(pVCpu, bRm));
    4604         IEM_MC_FETCH_GREG_U16(u16Src, IEM_GET_MODRM_RM(pVCpu, bRm));
    4605         IEM_MC_CALL_VOID_AIMPL_4(IEM_SELECT_HOST_OR_FALLBACK(fAvx, iemAImpl_vpinsrw_u128, iemAImpl_vpinsrw_u128_fallback),
    4606                                  puDst, puSrc, u16Src, bImmArg);
    4607         IEM_MC_CLEAR_YREG_128_UP(          IEM_GET_MODRM_REG(pVCpu, bRm));
     4601
     4602        IEM_MC_FETCH_XREG_U128(uSrc1,  IEM_GET_EFFECTIVE_VVVV(pVCpu));
     4603        IEM_MC_FETCH_GREG_U16(uValue,  IEM_GET_MODRM_RM(pVCpu, bRm));
     4604        IEM_MC_STORE_XREG_U128(        IEM_GET_MODRM_REG(pVCpu, bRm), uSrc1);
     4605        IEM_MC_STORE_XREG_U16(         IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 7, uValue);
    46084606        IEM_MC_ADVANCE_RIP_AND_FINISH();
    46094607        IEM_MC_END();
    … …  
    46164614        IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
    46174615        IEM_MC_LOCAL(RTGCPTR,     GCPtrEffSrc);
    4618         IEM_MC_ARG(PRTUINT128U,   puDst,                 0);
    4619         IEM_MC_ARG(PCRTUINT128U, puSrc,                  1);
    4620         IEM_MC_ARG(uint16_t,      u16Src,                2);
    4621 
    4622         IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     4616        IEM_MC_LOCAL(RTUINT128U,       uSrc1);
     4617        IEM_MC_LOCAL(uint16_t,         uValue);
     4618
     4619        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
    46234620        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
    4624         IEM_MC_ARG_CONST(uint8_t, bImmArg, /*=*/ bImm,   3);
    46254621        IEMOP_HLP_DONE_VEX_DECODING_L0_EX(fAvx);
    46264622        IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
    46274623        IEM_MC_PREPARE_AVX_USAGE();
    46284624
    4629         IEM_MC_FETCH_MEM_U16(u16Src, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    4630         IEM_MC_REF_XREG_U128(puDst,         IEM_GET_MODRM_REG(pVCpu, bRm));
    4631         IEM_MC_REF_XREG_U128_CONST(puSrc,  IEM_GET_MODRM_RM(pVCpu, bRm));
    4632         IEM_MC_CALL_VOID_AIMPL_4(IEM_SELECT_HOST_OR_FALLBACK(fAvx, iemAImpl_vpinsrw_u128, iemAImpl_vpinsrw_u128_fallback),
    4633                                  puDst, puSrc, u16Src, bImmArg);
    4634         IEM_MC_CLEAR_YREG_128_UP(           IEM_GET_MODRM_REG(pVCpu, bRm));
    4635 
     4625        IEM_MC_FETCH_XREG_U128(uSrc1,  IEM_GET_EFFECTIVE_VVVV(pVCpu));
     4626        IEM_MC_FETCH_MEM_U16(uValue,   pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     4627        IEM_MC_STORE_XREG_U128(        IEM_GET_MODRM_REG(pVCpu, bRm), uSrc1);
     4628        IEM_MC_STORE_XREG_U16(         IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 7, uValue);
    46364629        IEM_MC_ADVANCE_RIP_AND_FINISH();
    46374630        IEM_MC_END();

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

    r104059 r104076  
    837837
    838838/** Opcode VEX.66.0F3A 0x20. */
    839 FNIEMOP_STUB(iemOp_vpinsrb_Vdq_Hdq_RyMb_Ib);
     839FNIEMOP_DEF(iemOp_vpinsrb_Vdq_Hdq_RyMb_Ib)
     840{
     841    /*IEMOP_MNEMONIC4(VEX_RMVI, VPINSRB, vpinsrb, Vdq, Hdq, Ey, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_VEX_L_ZERO);*/ /** @todo */
     842    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     843    if (IEM_IS_MODRM_REG_MODE(bRm))
     844    {
     845        /*
     846         * Register, register.
     847         */
     848        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     849        IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
     850        IEM_MC_LOCAL(RTUINT128U,       uSrc1);
     851        IEM_MC_LOCAL(uint16_t,         uValue);
     852
     853        IEMOP_HLP_DONE_VEX_DECODING_L0_EX(fAvx);
     854        IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
     855        IEM_MC_PREPARE_AVX_USAGE();
     856
     857        IEM_MC_FETCH_XREG_U128(uSrc1,  IEM_GET_EFFECTIVE_VVVV(pVCpu));
     858        IEM_MC_FETCH_GREG_U16(uValue,  IEM_GET_MODRM_RM(pVCpu, bRm));
     859        IEM_MC_STORE_XREG_U128(        IEM_GET_MODRM_REG(pVCpu, bRm), uSrc1);
     860        IEM_MC_STORE_XREG_U8(          IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 15, uValue & 0xff);
     861        IEM_MC_ADVANCE_RIP_AND_FINISH();
     862        IEM_MC_END();
     863    }
     864    else
     865    {
     866        /*
     867         * Register, memory.
     868         */
     869        IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
     870        IEM_MC_LOCAL(RTGCPTR,     GCPtrEffSrc);
     871        IEM_MC_LOCAL(RTUINT128U,       uSrc1);
     872        IEM_MC_LOCAL(uint8_t,          uValue);
     873
     874        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     875        uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     876        IEMOP_HLP_DONE_VEX_DECODING_L0_EX(fAvx);
     877        IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
     878        IEM_MC_PREPARE_AVX_USAGE();
     879
     880        IEM_MC_FETCH_XREG_U128(uSrc1,  IEM_GET_EFFECTIVE_VVVV(pVCpu));
     881        IEM_MC_FETCH_MEM_U8(uValue,    pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     882        IEM_MC_STORE_XREG_U128(        IEM_GET_MODRM_REG(pVCpu, bRm), uSrc1);
     883        IEM_MC_STORE_XREG_U8(          IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 15, uValue);
     884        IEM_MC_ADVANCE_RIP_AND_FINISH();
     885        IEM_MC_END();
     886    }
     887}
     888
     889
    840890/** Opcode VEX.66.0F3A 0x21, */
    841891FNIEMOP_STUB(iemOp_vinsertps_Vdq_Hdq_UdqMd_Ib);
     892
     893
    842894/** Opcode VEX.66.0F3A 0x22. */
    843 FNIEMOP_STUB(iemOp_vpinsrd_q_Vdq_Hdq_Ey_Ib);
     895FNIEMOP_DEF(iemOp_vpinsrd_q_Vdq_Hdq_Ey_Ib)
     896{
     897    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
     898    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     899    {
     900        /*IEMOP_MNEMONIC4(VEX_RMVI, VPINSRQ, vpinsrq, Vdq, Hdq, Ey, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_VEX_L_ZERO);*/ /** @todo */
     901        if (IEM_IS_MODRM_REG_MODE(bRm))
     902        {
     903            /*
     904             * Register, register.
     905             */
     906            uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     907            IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
     908            IEM_MC_LOCAL(RTUINT128U,       uSrc1);
     909            IEM_MC_LOCAL(uint64_t,         uValue);
     910   
     911            IEMOP_HLP_DONE_VEX_DECODING_L0_EX(fAvx);
     912            IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
     913            IEM_MC_PREPARE_AVX_USAGE();
     914   
     915            IEM_MC_FETCH_XREG_U128(uSrc1,  IEM_GET_EFFECTIVE_VVVV(pVCpu));
     916            IEM_MC_FETCH_GREG_U64(uValue,  IEM_GET_MODRM_RM(pVCpu, bRm));
     917            IEM_MC_STORE_XREG_U128(        IEM_GET_MODRM_REG(pVCpu, bRm), uSrc1);
     918            IEM_MC_STORE_XREG_U64(         IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 1, uValue);
     919            IEM_MC_ADVANCE_RIP_AND_FINISH();
     920            IEM_MC_END();
     921        }
     922        else
     923        {
     924            /*
     925             * Register, memory.
     926             */
     927            IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
     928            IEM_MC_LOCAL(RTGCPTR,     GCPtrEffSrc);
     929            IEM_MC_LOCAL(RTUINT128U,       uSrc1);
     930            IEM_MC_LOCAL(uint64_t,         uValue);
     931   
     932            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     933            uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     934            IEMOP_HLP_DONE_VEX_DECODING_L0_EX(fAvx);
     935            IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
     936            IEM_MC_PREPARE_AVX_USAGE();
     937   
     938            IEM_MC_FETCH_XREG_U128(uSrc1,  IEM_GET_EFFECTIVE_VVVV(pVCpu));
     939            IEM_MC_FETCH_MEM_U64(uValue,   pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     940            IEM_MC_STORE_XREG_U128(        IEM_GET_MODRM_REG(pVCpu, bRm), uSrc1);
     941            IEM_MC_STORE_XREG_U64(         IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 1, uValue);
     942            IEM_MC_ADVANCE_RIP_AND_FINISH();
     943            IEM_MC_END();
     944        }
     945    }
     946    else
     947    {
     948        /*IEMOP_MNEMONIC4(VEX_RMVI, VPINSRD, vpinsrd, Vdq, Hdq, Ey, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_VEX_L_ZERO);*/ /** @todo */
     949        if (IEM_IS_MODRM_REG_MODE(bRm))
     950        {
     951            /*
     952             * Register, register.
     953             */
     954            IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
     955            uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     956            IEM_MC_LOCAL(RTUINT128U,       uSrc1);
     957            IEM_MC_LOCAL(uint32_t,         uValue);
     958   
     959            IEMOP_HLP_DONE_VEX_DECODING_L0_EX(fAvx);
     960            IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
     961            IEM_MC_PREPARE_AVX_USAGE();
     962   
     963            IEM_MC_FETCH_XREG_U128(uSrc1,  IEM_GET_EFFECTIVE_VVVV(pVCpu));
     964            IEM_MC_FETCH_GREG_U32(uValue,  IEM_GET_MODRM_RM(pVCpu, bRm));
     965            IEM_MC_STORE_XREG_U128(        IEM_GET_MODRM_REG(pVCpu, bRm), uSrc1);
     966            IEM_MC_STORE_XREG_U32(         IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 3, uValue);
     967            IEM_MC_ADVANCE_RIP_AND_FINISH();
     968            IEM_MC_END();
     969        }
     970        else
     971        {
     972            /*
     973             * Register, memory.
     974             */
     975            IEM_MC_BEGIN(IEM_MC_F_NOT_286_OR_OLDER, 0);
     976            IEM_MC_LOCAL(RTGCPTR,     GCPtrEffSrc);
     977            IEM_MC_LOCAL(RTUINT128U,       uSrc1);
     978            IEM_MC_LOCAL(uint32_t,         uValue);
     979   
     980            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
     981            uint8_t bImm; IEM_OPCODE_GET_NEXT_U8(&bImm);
     982            IEMOP_HLP_DONE_VEX_DECODING_L0_EX(fAvx);
     983            IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
     984            IEM_MC_PREPARE_AVX_USAGE();
     985   
     986            IEM_MC_FETCH_XREG_U128(uSrc1,  IEM_GET_EFFECTIVE_VVVV(pVCpu));
     987            IEM_MC_FETCH_MEM_U32(uValue,   pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     988            IEM_MC_STORE_XREG_U128(        IEM_GET_MODRM_REG(pVCpu, bRm), uSrc1);
     989            IEM_MC_STORE_XREG_U32(         IEM_GET_MODRM_REG(pVCpu, bRm), bImm & 3, uValue);
     990            IEM_MC_ADVANCE_RIP_AND_FINISH();
     991            IEM_MC_END();
     992        }
     993    }
     994}
     995
     996
    844997/*  Opcode VEX.66.0F3A 0x23 - invalid */
    845998/*  Opcode VEX.66.0F3A 0x24 - invalid */

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

    r104058 r104076  
    665665#define IEM_MC_FETCH_MREG_U32(a_u32Value, a_iMReg, a_iDWord)        NOP()
    666666#define IEM_MC_FETCH_MREG_U16(a_u16Value, a_iMReg, a_iWord)         NOP()
     667#define IEM_MC_FETCH_MREG_U8(a_u8Value, a_iMReg, a_iByte)           NOP()
    667668#define IEM_MC_STORE_MREG_U64(a_iMReg, a_u64Value)                  NOP()
     669#define IEM_MC_STORE_MREG_U32(a_iMReg, a_iDword, a_u32Value)        NOP()
     670#define IEM_MC_STORE_MREG_U16(a_iMReg, a_iWord, a_u16Value)         NOP()
     671#define IEM_MC_STORE_MREG_U8(a_iMReg, a_iByte, a_u8Value)           NOP()
    668672#define IEM_MC_STORE_MREG_U32_ZX_U64(a_iMReg, a_u32Value)           NOP()
    669673#define IEM_MC_REF_MREG_U64(a_pu64Dst, a_iMReg)                     NOP()

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

    r104021 r104076  
    17661766        'IEM_MC_FETCH_MREG_U32':                    '__mreg32',
    17671767        'IEM_MC_FETCH_MREG_U16':                    '__mreg16',
     1768        'IEM_MC_FETCH_MREG_U8':                     '__mreg8',
    17681769        'IEM_MC_STORE_MREG_U64':                    '__mreg64',
     1770        'IEM_MC_STORE_MREG_U32':                    '__mreg32',
     1771        'IEM_MC_STORE_MREG_U16':                    '__mreg16',
     1772        'IEM_MC_STORE_MREG_U8':                     '__mreg8',
    17691773        'IEM_MC_STORE_MREG_U32_ZX_U64':             '__mreg32zx64',
    17701774        'IEM_MC_REF_MREG_U64':                      '__mreg64',
Note: See TracChangeset for help on using the changeset viewer.

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