VirtualBox

Changeset 67003 in vbox for trunk/src/VBox


Ignore:
Timestamp:
May 22, 2017 10:03:15 AM (8 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
115561
Message:

IEM: movq Pq,Eq & movd Pd,Ed docs+tests+fixes.

Location:
trunk/src/VBox
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r66957 r67003  
    5757 * @openc       ModR/M
    5858 * @opflmodify  cf,pf,af,zf,sf,of
    59  * @ophints     harmless ignores_op_size
     59 * @ophints     harmless ignores_op_sizes
    6060 * @opstats     add_Eb_Gb
    6161 * @opgroup     og_gen_arith_bin
    … …  
    6767FNIEMOP_DEF(iemOp_add_Eb_Gb)
    6868{
    69     IEMOP_MNEMONIC2(MR, ADD, add, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_LOCK_ALLOWED);
     69    IEMOP_MNEMONIC2(MR, ADD, add, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    7070    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_r8, &g_iemAImpl_add);
    7171}
    … …  
    9696FNIEMOP_DEF(iemOp_add_Gb_Eb)
    9797{
    98     IEMOP_MNEMONIC2(RM, ADD, add, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     98    IEMOP_MNEMONIC2(RM, ADD, add, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    9999    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_r8_rm, &g_iemAImpl_add);
    100100}
    … …  
    122122FNIEMOP_DEF(iemOp_add_Al_Ib)
    123123{
    124     IEMOP_MNEMONIC2(FIXED, ADD, add, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     124    IEMOP_MNEMONIC2(FIXED, ADD, add, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    125125    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_AL_Ib, &g_iemAImpl_add);
    126126}
    … …  
    181181FNIEMOP_DEF(iemOp_or_Eb_Gb)
    182182{
    183     IEMOP_MNEMONIC2(MR, OR, or, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_LOCK_ALLOWED);
     183    IEMOP_MNEMONIC2(MR, OR, or, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    184184    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    185185    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_r8, &g_iemAImpl_or);
    … …  
    218218FNIEMOP_DEF(iemOp_or_Gb_Eb)
    219219{
    220     IEMOP_MNEMONIC2(RM, OR, or, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_LOCK_ALLOWED);
     220    IEMOP_MNEMONIC2(RM, OR, or, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    221221    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    222222    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_r8_rm, &g_iemAImpl_or);
    … …  
    250250FNIEMOP_DEF(iemOp_or_Al_Ib)
    251251{
    252     IEMOP_MNEMONIC2(FIXED, OR, or, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     252    IEMOP_MNEMONIC2(FIXED, OR, or, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    253253    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    254254    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_AL_Ib, &g_iemAImpl_or);
    … …  
    345345FNIEMOP_DEF(iemOp_adc_Eb_Gb)
    346346{
    347     IEMOP_MNEMONIC2(MR, ADC, adc, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_LOCK_ALLOWED);
     347    IEMOP_MNEMONIC2(MR, ADC, adc, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    348348    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_r8, &g_iemAImpl_adc);
    349349}
    … …  
    377377FNIEMOP_DEF(iemOp_adc_Gb_Eb)
    378378{
    379     IEMOP_MNEMONIC2(RM, ADC, adc, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     379    IEMOP_MNEMONIC2(RM, ADC, adc, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    380380    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_r8_rm, &g_iemAImpl_adc);
    381381}
    … …  
    405405FNIEMOP_DEF(iemOp_adc_Al_Ib)
    406406{
    407     IEMOP_MNEMONIC2(FIXED, ADC, adc, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     407    IEMOP_MNEMONIC2(FIXED, ADC, adc, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    408408    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_AL_Ib, &g_iemAImpl_adc);
    409409}
    … …  
    458458FNIEMOP_DEF(iemOp_sbb_Eb_Gb)
    459459{
    460     IEMOP_MNEMONIC2(MR, SBB, sbb, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_LOCK_ALLOWED);
     460    IEMOP_MNEMONIC2(MR, SBB, sbb, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    461461    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_r8, &g_iemAImpl_sbb);
    462462}
    … …  
    484484FNIEMOP_DEF(iemOp_sbb_Gb_Eb)
    485485{
    486     IEMOP_MNEMONIC2(RM, SBB, sbb, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     486    IEMOP_MNEMONIC2(RM, SBB, sbb, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    487487    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_r8_rm, &g_iemAImpl_sbb);
    488488}
    … …  
    510510FNIEMOP_DEF(iemOp_sbb_Al_Ib)
    511511{
    512     IEMOP_MNEMONIC2(FIXED, SBB, sbb, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     512    IEMOP_MNEMONIC2(FIXED, SBB, sbb, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    513513    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_AL_Ib, &g_iemAImpl_sbb);
    514514}
    … …  
    562562FNIEMOP_DEF(iemOp_and_Eb_Gb)
    563563{
    564     IEMOP_MNEMONIC2(MR, AND, and, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_LOCK_ALLOWED);
     564    IEMOP_MNEMONIC2(MR, AND, and, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    565565    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    566566    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_r8, &g_iemAImpl_and);
    … …  
    592592FNIEMOP_DEF(iemOp_and_Gb_Eb)
    593593{
    594     IEMOP_MNEMONIC2(RM, AND, and, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     594    IEMOP_MNEMONIC2(RM, AND, and, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    595595    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    596596    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_r8_rm, &g_iemAImpl_and);
    … …  
    686686FNIEMOP_DEF(iemOp_sub_Eb_Gb)
    687687{
    688     IEMOP_MNEMONIC2(MR, SUB, sub, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_LOCK_ALLOWED);
     688    IEMOP_MNEMONIC2(MR, SUB, sub, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    689689    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_r8, &g_iemAImpl_sub);
    690690}
    … …  
    710710FNIEMOP_DEF(iemOp_sub_Gb_Eb)
    711711{
    712     IEMOP_MNEMONIC2(RM, SUB, sub, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     712    IEMOP_MNEMONIC2(RM, SUB, sub, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    713713    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_r8_rm, &g_iemAImpl_sub);
    714714}
    … …  
    734734FNIEMOP_DEF(iemOp_sub_Al_Ib)
    735735{
    736     IEMOP_MNEMONIC2(FIXED, SUB, sub, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     736    IEMOP_MNEMONIC2(FIXED, SUB, sub, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    737737    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_AL_Ib, &g_iemAImpl_sub);
    738738}
    … …  
    796796FNIEMOP_DEF(iemOp_xor_Eb_Gb)
    797797{
    798     IEMOP_MNEMONIC2(MR, XOR, xor, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_LOCK_ALLOWED);
     798    IEMOP_MNEMONIC2(MR, XOR, xor, Eb, Gb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_LOCK_ALLOWED);
    799799    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    800800    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rm_r8, &g_iemAImpl_xor);
    … …  
    826826FNIEMOP_DEF(iemOp_xor_Gb_Eb)
    827827{
    828     IEMOP_MNEMONIC2(RM, XOR, xor, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     828    IEMOP_MNEMONIC2(RM, XOR, xor, Gb, Eb, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    829829    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    830830    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_r8_rm, &g_iemAImpl_xor);
    … …  
    856856FNIEMOP_DEF(iemOp_xor_Al_Ib)
    857857{
    858     IEMOP_MNEMONIC2(FIXED, XOR, xor, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     858    IEMOP_MNEMONIC2(FIXED, XOR, xor, AL, Ib, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    859859    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    860860    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_AL_Ib, &g_iemAImpl_xor);
    … …  
    871871FNIEMOP_DEF(iemOp_xor_eAX_Iz)
    872872{
    873     IEMOP_MNEMONIC2(FIXED, XOR, xor, rAX, Iz, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     873    IEMOP_MNEMONIC2(FIXED, XOR, xor, rAX, Iz, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    874874    IEMOP_VERIFICATION_UNDEFINED_EFLAGS(X86_EFL_AF);
    875875    return FNIEMOP_CALL_1(iemOpHlpBinaryOperator_rAX_Iz, &g_iemAImpl_xor);
    … …  
    19111911    if (pVCpu->iem.s.enmCpuMode != IEMMODE_64BIT)
    19121912    {
    1913         IEMOP_MNEMONIC2(RM_MEM, BOUND, bound, Gv_RO, Ma, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1913        IEMOP_MNEMONIC2(RM_MEM, BOUND, bound, Gv_RO, Ma, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    19141914        IEMOP_HLP_MIN_186();
    19151915        IEM_OPCODE_GET_NEXT_U8(&bRm);

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

    r66991 r67003  
    214214    # ModR/M.rm
    215215    'Eb':           ( 'IDX_UseModRM',       'rm',     '%Eb',  'Eb',      ),
     216    'Ed':           ( 'IDX_UseModRM',       'rm',     '%Ed',  'Ed',      ),
     217    'Eq':           ( 'IDX_UseModRM',       'rm',     '%Eq',  'Eq',      ),
    216218    'Ew':           ( 'IDX_UseModRM',       'rm',     '%Ew',  'Ew',      ),
    217219    'Ev':           ( 'IDX_UseModRM',       'rm',     '%Ev',  'Ev',      ),
    … …  
    257259    'Gv':           ( 'IDX_UseModRM',       'reg',    '%Gv',  'Gv',      ),
    258260    'Gv_RO':        ( 'IDX_UseModRM',       'reg',    '%Gv',  'Gv',      ),
     261    'Pd':           ( 'IDX_UseModRM',       'reg',    '%Pd',  'Pd',      ),
     262    'PdZx_WO':      ( 'IDX_UseModRM',       'reg',    '%Pd',  'PdZx',    ),
     263    'Pq':           ( 'IDX_UseModRM',       'reg',    '%Pq',  'Pq',      ),
    259264    'Pq_WO':        ( 'IDX_UseModRM',       'reg',    '%Pq',  'Pq',      ),
    260265    'Vss':          ( 'IDX_UseModRM',       'reg',    '%Vss', 'Vss',     ),
    … …  
    380385    '!11 mr/reg':   [ '!11 mr/reg', ],
    381386    '!11':          [ '!11 mr/reg', ],      ##< alias
     387    'rex.w=0':      [ 'rex.w=0',    ],
     388    'w=0':          [ 'rex.w=0',    ],      ##< alias
     389    'rex.w=1':      [ 'rex.w=1',    ],
     390    'w=1':          [ 'rex.w=1',    ],      ##< alias
    382391};
    383392
    … …  
    485494    'mmx':                   'DISOPTYPE_MMX',                   ##< MMX,MMXExt,3DNow,++ instruction. Not implemented yet!
    486495    'fpu':                   'DISOPTYPE_FPU',                   ##< FPU instruction. Not implemented yet!
    487     'ignores_op_size':       '',                                ##< Ignores both operand size prefixes (66h + REX.W).
     496    'ignores_oz_pfx':        '',                                ##< Ignores operand size prefix 66h.
     497    'ignores_rexw':          '',                                ##< Ignores REX.W.
     498    'ignores_op_sizes':      '',                                ##< Shorthand for "ignores_oz_pfx | ignores_op_sizes".
    488499    'ignores_vex_l':         '',                                ##< Ignores VEX.L.
    489500    'vex_l_zero':            '',                                ##< VEX.L must be 0.
    … …  
    12081219        'user':         'ring==3',
    12091220        'supervisor':   'ring==0..2',
     1221        '16-bit':       'codebits==16',
     1222        '32-bit':       'codebits==32',
     1223        '64-bit':       'codebits==64',
    12101224        'real':         'mode==real',
    12111225        'prot':         'mode==prot',

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

    r66991 r67003  
    10011001FNIEMOP_DEF(iemOp_movups_Vps_Wps)
    10021002{
    1003     IEMOP_MNEMONIC2(RM, MOVUPS, movups, Vps_WO, Wps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1003    IEMOP_MNEMONIC2(RM, MOVUPS, movups, Vps_WO, Wps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    10041004    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    10051005    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    10531053FNIEMOP_DEF(iemOp_movupd_Vpd_Wpd)
    10541054{
    1055     IEMOP_MNEMONIC2(RM, MOVUPD, movupd, Vpd_WO, Wpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1055    IEMOP_MNEMONIC2(RM, MOVUPD, movupd, Vpd_WO, Wpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    10561056    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    10571057    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    11041104FNIEMOP_DEF(iemOp_movss_Vss_Wss)
    11051105{
    1106     IEMOP_MNEMONIC2(RM, MOVSS, movss, VssZx_WO, Wss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1106    IEMOP_MNEMONIC2(RM, MOVSS, movss, VssZx_WO, Wss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    11071107    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    11081108    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    11581158FNIEMOP_DEF(iemOp_movsd_Vsd_Wsd)
    11591159{
    1160     IEMOP_MNEMONIC2(RM, MOVSD, movsd, VsdZx_WO, Wsd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1160    IEMOP_MNEMONIC2(RM, MOVSD, movsd, VsdZx_WO, Wsd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    11611161    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    11621162    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    12121212FNIEMOP_DEF(iemOp_movups_Wps_Vps)
    12131213{
    1214     IEMOP_MNEMONIC2(MR, MOVUPS, movups, Wps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1214    IEMOP_MNEMONIC2(MR, MOVUPS, movups, Wps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    12151215    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    12161216    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    12631263FNIEMOP_DEF(iemOp_movupd_Wpd_Vpd)
    12641264{
    1265     IEMOP_MNEMONIC2(MR, MOVUPD, movupd, Wpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1265    IEMOP_MNEMONIC2(MR, MOVUPD, movupd, Wpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    12661266    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    12671267    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    13141314FNIEMOP_DEF(iemOp_movss_Wss_Vss)
    13151315{
    1316     IEMOP_MNEMONIC2(MR, MOVSS, movss, Wss_WO, Vss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1316    IEMOP_MNEMONIC2(MR, MOVSS, movss, Wss_WO, Vss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    13171317    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    13181318    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    13681368FNIEMOP_DEF(iemOp_movsd_Wsd_Vsd)
    13691369{
    1370     IEMOP_MNEMONIC2(MR, MOVSD, movsd, Wsd_WO, Vsd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1370    IEMOP_MNEMONIC2(MR, MOVSD, movsd, Wsd_WO, Vsd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    13711371    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    13721372    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    14261426         * @optest      op1=0 op2=-42 -> op1=-42
    14271427         */
    1428         IEMOP_MNEMONIC2(RM_REG, MOVHLPS, movhlps, Vq_WO, UqHi, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1428        IEMOP_MNEMONIC2(RM_REG, MOVHLPS, movhlps, Vq_WO, UqHi, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    14291429
    14301430        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    … …  
    14541454         * @opfunction  iemOp_movlps_Vq_Mq__vmovhlps
    14551455         */
    1456         IEMOP_MNEMONIC2(RM_MEM, MOVLPS, movlps, Vq_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1456        IEMOP_MNEMONIC2(RM_MEM, MOVLPS, movlps, Vq_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    14571457
    14581458        IEM_MC_BEGIN(0, 2);
    … …  
    14901490    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    14911491    {
    1492         IEMOP_MNEMONIC2(RM_MEM, MOVLPD, movlpd, Vq_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1492        IEMOP_MNEMONIC2(RM_MEM, MOVLPD, movlpd, Vq_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    14931493
    14941494        IEM_MC_BEGIN(0, 2);
    … …  
    15341534FNIEMOP_DEF(iemOp_movsldup_Vdq_Wdq)
    15351535{
    1536     IEMOP_MNEMONIC2(RM, MOVSLDUP, movsldup, Vdq_WO, Wdq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1536    IEMOP_MNEMONIC2(RM, MOVSLDUP, movsldup, Vdq_WO, Wdq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    15371537    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    15381538    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    15941594FNIEMOP_DEF(iemOp_movddup_Vdq_Wdq)
    15951595{
    1596     IEMOP_MNEMONIC2(RM, MOVDDUP, movddup, Vdq_WO, Wdq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1596    IEMOP_MNEMONIC2(RM, MOVDDUP, movddup, Vdq_WO, Wdq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    15971597    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    15981598    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    16571657    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    16581658    {
    1659         IEMOP_MNEMONIC2(MR_MEM, MOVLPS, movlps, Mq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1659        IEMOP_MNEMONIC2(MR_MEM, MOVLPS, movlps, Mq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    16601660
    16611661        IEM_MC_BEGIN(0, 2);
    … …  
    17051705    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    17061706    {
    1707         IEMOP_MNEMONIC2(MR_MEM, MOVLPD, movlpd, Mq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1707        IEMOP_MNEMONIC2(MR_MEM, MOVLPD, movlpd, Mq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    17081708        IEM_MC_BEGIN(0, 2);
    17091709        IEM_MC_LOCAL(uint64_t,                  uSrc);
    … …  
    18261826         * @optest      op1=0 op2=-42 -> op1=-42
    18271827         */
    1828         IEMOP_MNEMONIC2(RM_REG, MOVLHPS, movlhps, VqHi_WO, Uq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1828        IEMOP_MNEMONIC2(RM_REG, MOVLHPS, movlhps, VqHi_WO, Uq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    18291829
    18301830        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    … …  
    18541854         * @opfunction  iemOp_movhps_Vdq_Mq__movlhps_Vdq_Uq
    18551855         */
    1856         IEMOP_MNEMONIC2(RM_MEM, MOVHPS, movhps, VqHi_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1856        IEMOP_MNEMONIC2(RM_MEM, MOVHPS, movhps, VqHi_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    18571857
    18581858        IEM_MC_BEGIN(0, 2);
    … …  
    18901890    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    18911891    {
    1892         IEMOP_MNEMONIC2(RM_MEM, MOVHPD, movhpd, VqHi_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1892        IEMOP_MNEMONIC2(RM_MEM, MOVHPD, movhpd, VqHi_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    18931893        IEM_MC_BEGIN(0, 2);
    18941894        IEM_MC_LOCAL(uint64_t,                  uSrc);
    … …  
    19331933FNIEMOP_DEF(iemOp_movshdup_Vdq_Wdq)
    19341934{
    1935     IEMOP_MNEMONIC2(RM, MOVSHDUP, movshdup, Vdq_WO, Wdq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1935    IEMOP_MNEMONIC2(RM, MOVSHDUP, movshdup, Vdq_WO, Wdq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    19361936    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    19371937    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    20082008    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    20092009    {
    2010         IEMOP_MNEMONIC2(MR_MEM, MOVHPS, movhps, Mq_WO, VqHi, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     2010        IEMOP_MNEMONIC2(MR_MEM, MOVHPS, movhps, Mq_WO, VqHi, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    20112011
    20122012        IEM_MC_BEGIN(0, 2);
    … …  
    20562056    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    20572057    {
    2058         IEMOP_MNEMONIC2(MR_MEM, MOVHPD, movhpd, Mq_WO, VqHi, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     2058        IEMOP_MNEMONIC2(MR_MEM, MOVHPD, movhpd, Mq_WO, VqHi, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    20592059
    20602060        IEM_MC_BEGIN(0, 2);
    … …  
    22992299FNIEMOP_DEF(iemOp_movaps_Vps_Wps)
    23002300{
    2301     IEMOP_MNEMONIC2(RM, MOVAPS, movaps, Vps_WO, Wps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     2301    IEMOP_MNEMONIC2(RM, MOVAPS, movaps, Vps_WO, Wps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    23022302    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    23032303    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    23492349FNIEMOP_DEF(iemOp_movapd_Vpd_Wpd)
    23502350{
    2351     IEMOP_MNEMONIC2(RM, MOVAPD, movapd, Vpd_WO, Wpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     2351    IEMOP_MNEMONIC2(RM, MOVAPD, movapd, Vpd_WO, Wpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    23522352    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    23532353    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    24022402FNIEMOP_DEF(iemOp_movaps_Wps_Vps)
    24032403{
    2404     IEMOP_MNEMONIC2(MR, MOVAPS, movaps, Wps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     2404    IEMOP_MNEMONIC2(MR, MOVAPS, movaps, Wps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    24052405    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    24062406    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    24522452FNIEMOP_DEF(iemOp_movapd_Wpd_Vpd)
    24532453{
    2454     IEMOP_MNEMONIC2(MR, MOVAPD, movapd, Wpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     2454    IEMOP_MNEMONIC2(MR, MOVAPD, movapd, Wpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    24552455    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    24562456    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    25172517FNIEMOP_DEF(iemOp_movntps_Mps_Vps)
    25182518{
    2519     IEMOP_MNEMONIC2(MR_MEM, MOVNTPS, movntps, Mps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     2519    IEMOP_MNEMONIC2(MR_MEM, MOVNTPS, movntps, Mps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    25202520    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    25212521    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    … …  
    25572557FNIEMOP_DEF(iemOp_movntpd_Mpd_Vpd)
    25582558{
    2559     IEMOP_MNEMONIC2(MR_MEM, MOVNTPD, movntpd, Mpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     2559    IEMOP_MNEMONIC2(MR_MEM, MOVNTPD, movntpd, Mpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    25602560    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    25612561    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    … …  
    34503450
    34513451
    3452 /** Opcode      0x0f 0x6e - movd/q Pd, Ey */
    34533452FNIEMOP_DEF(iemOp_movd_q_Pd_Ey)
    34543453{
    34553454    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    34563455    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    3457         IEMOP_MNEMONIC(movq_Pq_Eq, "movq Pq,Eq");
    3458     else
    3459         IEMOP_MNEMONIC(movd_Pd_Ed, "movd Pd,Ed");
    3460     if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    3461     {
    3462         /* MMX, greg */
    3463         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    3464         IEM_MC_BEGIN(0, 1);
    3465         IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    3466         IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    3467         IEM_MC_LOCAL(uint64_t, u64Tmp);
    3468         if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
     3456    {
     3457        /**
     3458         * @opcode      0x6e
     3459         * @opcodesub   rex.w=1
     3460         * @oppfx       none
     3461         * @opcpuid     mmx
     3462         * @opgroup     og_mmx_datamove
     3463         * @opxcpttype  5
     3464         * @optest      64-bit / op1=1 op2=2   -> op1=2   ftw=0xff
     3465         * @optest      64-bit / op1=0 op2=-42 -> op1=-42 ftw=0xff
     3466         */
     3467        IEMOP_MNEMONIC2(RM, MOVQ, movq, Pq_WO, Eq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
     3468        if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     3469        {
     3470            /* MMX, greg64 */
     3471            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     3472            IEM_MC_BEGIN(0, 1);
     3473            IEM_MC_LOCAL(uint64_t, u64Tmp);
     3474
     3475            IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     3476            IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
     3477
    34693478            IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    3470         else
    3471             IEM_MC_FETCH_GREG_U32_ZX_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    3472         IEM_MC_STORE_MREG_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u64Tmp);
    3473         IEM_MC_ADVANCE_RIP();
    3474         IEM_MC_END();
    3475     }
    3476     else
    3477     {
    3478         /* MMX, [mem] */
    3479         IEM_MC_BEGIN(0, 2);
    3480         IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    3481         IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
    3482         IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
    3483         IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    3484         IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
    3485         if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    3486         {
    3487             IEM_MC_LOCAL(uint64_t, u64Tmp);
    3488             IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    34893479            IEM_MC_STORE_MREG_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u64Tmp);
     3480            IEM_MC_FPU_TO_MMX_MODE();
     3481
     3482            IEM_MC_ADVANCE_RIP();
     3483            IEM_MC_END();
    34903484        }
    34913485        else
    34923486        {
     3487            /* MMX, [mem64] */
     3488            IEM_MC_BEGIN(0, 2);
     3489            IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
     3490            IEM_MC_LOCAL(uint64_t, u64Tmp);
     3491
     3492            IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     3493            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     3494            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     3495            IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
     3496
     3497            IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
     3498            IEM_MC_STORE_MREG_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u64Tmp);
     3499            IEM_MC_FPU_TO_MMX_MODE();
     3500
     3501            IEM_MC_ADVANCE_RIP();
     3502            IEM_MC_END();
     3503        }
     3504    }
     3505    else
     3506    {
     3507        /**
     3508         * @opdone
     3509         * @opcode      0x6e
     3510         * @opcodesub   rex.w=0
     3511         * @oppfx       none
     3512         * @opcpuid     mmx
     3513         * @opgroup     og_mmx_datamove
     3514         * @opxcpttype  5
     3515         * @opfunction  iemOp_movd_q_Pd_Ey
     3516         * @optest      op1=1 op2=2   -> op1=2   ftw=0xff
     3517         * @optest      op1=0 op2=-42 -> op1=-42 ftw=0xff
     3518         */
     3519        IEMOP_MNEMONIC2(RM, MOVD, movd, PdZx_WO, Ed, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
     3520        if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
     3521        {
     3522            /* MMX, greg */
     3523            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     3524            IEM_MC_BEGIN(0, 1);
     3525            IEM_MC_LOCAL(uint64_t, u64Tmp);
     3526
     3527            IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     3528            IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
     3529
     3530            IEM_MC_FETCH_GREG_U32_ZX_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
     3531            IEM_MC_STORE_MREG_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u64Tmp);
     3532            IEM_MC_FPU_TO_MMX_MODE();
     3533
     3534            IEM_MC_ADVANCE_RIP();
     3535            IEM_MC_END();
     3536        }
     3537        else
     3538        {
     3539            /* MMX, [mem] */
     3540            IEM_MC_BEGIN(0, 2);
     3541            IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    34933542            IEM_MC_LOCAL(uint32_t, u32Tmp);
     3543
     3544            IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
     3545            IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
     3546            IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
     3547            IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE();
     3548
    34943549            IEM_MC_FETCH_MEM_U32(u32Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    34953550            IEM_MC_STORE_MREG_U32_ZX_U64((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK, u32Tmp);
     3551            IEM_MC_FPU_TO_MMX_MODE();
     3552
     3553            IEM_MC_ADVANCE_RIP();
     3554            IEM_MC_END();
    34963555        }
    3497         IEM_MC_ADVANCE_RIP();
    3498         IEM_MC_END();
    34993556    }
    35003557    return VINF_SUCCESS;
    … …  
    43754432FNIEMOP_DEF(iemOp_movq_Vq_Wq)
    43764433{
    4377     IEMOP_MNEMONIC2(RM, MOVQ, movq, VqZx_WO, Wq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     4434    IEMOP_MNEMONIC2(RM, MOVQ, movq, VqZx_WO, Wq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    43784435    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    43794436    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    65036560FNIEMOP_DEF_1(iemOp_Grp15_ldmxcsr, uint8_t, bRm)
    65046561{
    6505     IEMOP_MNEMONIC1(M_MEM, LDMXCSR, ldmxcsr, Md_RO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     6562    IEMOP_MNEMONIC1(M_MEM, LDMXCSR, ldmxcsr, Md_RO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    65066563    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSse)
    65076564        return IEMOP_RAISE_INVALID_OPCODE();
    … …  
    65406597FNIEMOP_DEF_1(iemOp_Grp15_stmxcsr,  uint8_t, bRm)
    65416598{
    6542     IEMOP_MNEMONIC1(M_MEM, STMXCSR, stmxcsr, Md_WO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     6599    IEMOP_MNEMONIC1(M_MEM, STMXCSR, stmxcsr, Md_WO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    65436600    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSse)
    65446601        return IEMOP_RAISE_INVALID_OPCODE();
    … …  
    66256682FNIEMOP_DEF_1(iemOp_Grp15_clflush,  uint8_t, bRm)
    66266683{
    6627     IEMOP_MNEMONIC1(M_MEM, CLFLUSH, clflush, Mb_RO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     6684    IEMOP_MNEMONIC1(M_MEM, CLFLUSH, clflush, Mb_RO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    66286685    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fClFlush)
    66296686        return FNIEMOP_CALL_1(iemOp_InvalidWithRMAllNeeded, bRm);
    … …  
    66506707FNIEMOP_DEF_1(iemOp_Grp15_clflushopt,  uint8_t, bRm)
    66516708{
    6652     IEMOP_MNEMONIC1(M_MEM, CLFLUSHOPT, clflushopt, Mb_RO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     6709    IEMOP_MNEMONIC1(M_MEM, CLFLUSHOPT, clflushopt, Mb_RO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    66536710    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fClFlushOpt)
    66546711        return FNIEMOP_CALL_1(iemOp_InvalidWithRMAllNeeded, bRm);
    … …  
    73437400     */
    73447401    Log(("iemOp_Grp10 aka UD1 -> #UD\n"));
    7345     IEMOP_MNEMONIC2EX(ud1, "ud1", RM, UD1, ud1, Gb, Eb, DISOPTYPE_INVALID, IEMOPHINT_IGNORES_OP_SIZE); /* just picked Gb,Eb here. */
     7402    IEMOP_MNEMONIC2EX(ud1, "ud1", RM, UD1, ud1, Gb, Eb, DISOPTYPE_INVALID, IEMOPHINT_IGNORES_OP_SIZES); /* just picked Gb,Eb here. */
    73467403    return FNIEMOP_CALL(iemOp_InvalidNeedRM);
    73477404}
    … …  
    83918448FNIEMOP_DEF(iemOp_movq_Wq_Vq)
    83928449{
    8393     IEMOP_MNEMONIC2(MR, MOVQ, movq, WqZxReg_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     8450    IEMOP_MNEMONIC2(MR, MOVQ, movq, WqZxReg_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    83948451    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    83958452    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    84528509         * Register, register.
    84538510         */
    8454         IEMOP_MNEMONIC2(RM_REG, MOVQ2DQ, movq2dq, VqZx_WO, Nq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     8511        IEMOP_MNEMONIC2(RM_REG, MOVQ2DQ, movq2dq, VqZx_WO, Nq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    84558512        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    84568513        IEM_MC_BEGIN(0, 1);
    … …  
    85048561         * Register, register.
    85058562         */
    8506         IEMOP_MNEMONIC2(RM_REG, MOVDQ2Q, movdq2q, Pq_WO, Uq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     8563        IEMOP_MNEMONIC2(RM_REG, MOVDQ2Q, movdq2q, Pq_WO, Uq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    85078564        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    85088565        IEM_MC_BEGIN(0, 1);

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

    r66992 r67003  
    6161FNIEMOP_DEF(iemOp_vmovups_Vps_Wps)
    6262{
    63     IEMOP_MNEMONIC2(VEX_RM, VMOVUPS, vmovups, Vps_WO, Wps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     63    IEMOP_MNEMONIC2(VEX_RM, VMOVUPS, vmovups, Vps_WO, Wps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    6464    Assert(pVCpu->iem.s.uVexLength <= 1);
    6565    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    … …  
    137137FNIEMOP_DEF(iemOp_vmovupd_Vpd_Wpd)
    138138{
    139     IEMOP_MNEMONIC2(VEX_RM, VMOVUPD, vmovupd, Vpd_WO, Wpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     139    IEMOP_MNEMONIC2(VEX_RM, VMOVUPD, vmovupd, Vpd_WO, Wpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    140140    Assert(pVCpu->iem.s.uVexLength <= 1);
    141141    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    … …  
    221221         * @note        HssHi refers to bits 127:32.
    222222         */
    223         IEMOP_MNEMONIC3(VEX_RVM, VMOVSS, vmovss, Vss_WO, HssHi, Uss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_IGNORES_VEX_L);
     223        IEMOP_MNEMONIC3(VEX_RVM, VMOVSS, vmovss, Vss_WO, HssHi, Uss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_IGNORES_VEX_L);
    224224        IEMOP_HLP_DONE_VEX_DECODING();
    225225        IEM_MC_BEGIN(0, 0);
    … …  
    247247         * @optest      op1=0 op2=-22 -> op1=-22
    248248         */
    249         IEMOP_MNEMONIC2(VEX_XM, VMOVSS, vmovss, VssZx_WO, Md, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_IGNORES_VEX_L);
     249        IEMOP_MNEMONIC2(VEX_XM, VMOVSS, vmovss, VssZx_WO, Md, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_IGNORES_VEX_L);
    250250        IEM_MC_BEGIN(0, 2);
    251251        IEM_MC_LOCAL(uint32_t,                  uSrc);
    … …  
    287287         * @optest      op1=3 op2=0x42 op3=0x77 -> op1=0x420000000000000077
    288288         */
    289         IEMOP_MNEMONIC3(VEX_RVM, VMOVSD, vmovsd, Vsd_WO, HsdHi, Usd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_IGNORES_VEX_L);
     289        IEMOP_MNEMONIC3(VEX_RVM, VMOVSD, vmovsd, Vsd_WO, HsdHi, Usd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_IGNORES_VEX_L);
    290290        IEMOP_HLP_DONE_VEX_DECODING();
    291291        IEM_MC_BEGIN(0, 0);
    … …  
    313313         * @optest      op1=0 op2=-22 -> op1=-22
    314314         */
    315         IEMOP_MNEMONIC2(VEX_XM, VMOVSD, vmovsd, VsdZx_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_IGNORES_VEX_L);
     315        IEMOP_MNEMONIC2(VEX_XM, VMOVSD, vmovsd, VsdZx_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_IGNORES_VEX_L);
    316316        IEM_MC_BEGIN(0, 2);
    317317        IEM_MC_LOCAL(uint64_t,                  uSrc);
    … …  
    345345FNIEMOP_DEF(iemOp_vmovups_Wps_Vps)
    346346{
    347     IEMOP_MNEMONIC2(VEX_MR, VMOVUPS, vmovups, Wps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     347    IEMOP_MNEMONIC2(VEX_MR, VMOVUPS, vmovups, Wps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    348348    Assert(pVCpu->iem.s.uVexLength <= 1);
    349349    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    … …  
    421421FNIEMOP_DEF(iemOp_vmovupd_Wpd_Vpd)
    422422{
    423     IEMOP_MNEMONIC2(VEX_MR, VMOVUPD, vmovupd, Wpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     423    IEMOP_MNEMONIC2(VEX_MR, VMOVUPD, vmovupd, Wpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    424424    Assert(pVCpu->iem.s.uVexLength <= 1);
    425425    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    … …  
    504504         * @optest      op1=3 op2=0x42 op3=0x77 -> op1=0x4200000077
    505505         */
    506         IEMOP_MNEMONIC3(VEX_MVR, VMOVSS, vmovss, Uss_WO, HssHi, Vss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_IGNORES_VEX_L);
     506        IEMOP_MNEMONIC3(VEX_MVR, VMOVSS, vmovss, Uss_WO, HssHi, Vss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_IGNORES_VEX_L);
    507507        IEMOP_HLP_DONE_VEX_DECODING();
    508508        IEM_MC_BEGIN(0, 0);
    … …  
    530530         * @optest      op1=0 op2=-22 -> op1=-22
    531531         */
    532         IEMOP_MNEMONIC2(VEX_MR, VMOVSS, vmovss, Md_WO, Vss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_IGNORES_VEX_L);
     532        IEMOP_MNEMONIC2(VEX_MR, VMOVSS, vmovss, Md_WO, Vss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_IGNORES_VEX_L);
    533533        IEM_MC_BEGIN(0, 2);
    534534        IEM_MC_LOCAL(uint32_t,                  uSrc);
    … …  
    570570         * @optest      op2=0x42 op3=0x77 -> op1=0x420000000000000077
    571571         */
    572         IEMOP_MNEMONIC3(VEX_MVR, VMOVSD, vmovsd, Usd_WO, HsdHi, Vsd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_IGNORES_VEX_L);
     572        IEMOP_MNEMONIC3(VEX_MVR, VMOVSD, vmovsd, Usd_WO, HsdHi, Vsd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_IGNORES_VEX_L);
    573573        IEMOP_HLP_DONE_VEX_DECODING();
    574574        IEM_MC_BEGIN(0, 0);
    … …  
    596596         * @optest      op1=0 op2=-22 -> op1=-22
    597597         */
    598         IEMOP_MNEMONIC2(VEX_MR, VMOVSD, vmovsd, Mq_WO, Vsd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_IGNORES_VEX_L);
     598        IEMOP_MNEMONIC2(VEX_MR, VMOVSD, vmovsd, Mq_WO, Vsd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_IGNORES_VEX_L);
    599599        IEM_MC_BEGIN(0, 2);
    600600        IEM_MC_LOCAL(uint64_t,                  uSrc);
    … …  
    635635         * @note        op3 and op2 are only the 8-byte high XMM register halfs.
    636636         */
    637         IEMOP_MNEMONIC3(VEX_RVM, VMOVHLPS, vmovhlps, Vq_WO, HqHi, UqHi, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_VEX_L_ZERO);
     637        IEMOP_MNEMONIC3(VEX_RVM, VMOVHLPS, vmovhlps, Vq_WO, HqHi, UqHi, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
    638638
    639639        IEMOP_HLP_DONE_VEX_DECODING_L0();
    … …  
    665665         * @optest      op2=-1 op3=0x42 -> op1=0xffffffffffffffff0000000000000042
    666666         */
    667         IEMOP_MNEMONIC3(VEX_RVM_MEM, VMOVLPS, vmovlps, Vq_WO, HqHi, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_VEX_L_ZERO);
     667        IEMOP_MNEMONIC3(VEX_RVM_MEM, VMOVLPS, vmovlps, Vq_WO, HqHi, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
    668668
    669669        IEM_MC_BEGIN(0, 2);
    … …  
    705705    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    706706    {
    707         IEMOP_MNEMONIC3(VEX_RVM_MEM, VMOVLPD, vmovlpd, Vq_WO, HqHi, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_VEX_L_ZERO);
     707        IEMOP_MNEMONIC3(VEX_RVM_MEM, VMOVLPD, vmovlpd, Vq_WO, HqHi, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
    708708
    709709        IEM_MC_BEGIN(0, 2);
    … …  
    754754FNIEMOP_DEF(iemOp_vmovsldup_Vx_Wx)
    755755{
    756     IEMOP_MNEMONIC2(VEX_RM, VMOVSLDUP, vmovsldup, Vx_WO, Wx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     756    IEMOP_MNEMONIC2(VEX_RM, VMOVSLDUP, vmovsldup, Vx_WO, Wx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    757757    Assert(pVCpu->iem.s.uVexLength <= 1);
    758758    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    … …  
    859859FNIEMOP_DEF(iemOp_vmovddup_Vx_Wx)
    860860{
    861     IEMOP_MNEMONIC2(VEX_RM, VMOVDDUP, vmovddup, Vx_WO, Wx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     861    IEMOP_MNEMONIC2(VEX_RM, VMOVDDUP, vmovddup, Vx_WO, Wx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    862862    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    863863    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    … …  
    964964    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    965965    {
    966         IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVLPS, vmovlps, Mq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_VEX_L_ZERO);
     966        IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVLPS, vmovlps, Mq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
    967967
    968968        IEM_MC_BEGIN(0, 2);
    … …  
    10121012    if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
    10131013    {
    1014         IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVLPD, vmovlpd, Mq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE | IEMOPHINT_VEX_L_ZERO);
     1014        IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVLPD, vmovlpd, Mq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
    10151015        IEM_MC_BEGIN(0, 2);
    10161016        IEM_MC_LOCAL(uint64_t,                  uSrc);
    … …  
    11031103FNIEMOP_DEF(iemOp_vmovaps_Vps_Wps)
    11041104{
    1105     IEMOP_MNEMONIC2(VEX_RM, VMOVAPS, vmovaps, Vps_WO, Wps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1105    IEMOP_MNEMONIC2(VEX_RM, VMOVAPS, vmovaps, Vps_WO, Wps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    11061106    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    11071107    Assert(pVCpu->iem.s.uVexLength <= 1);
    … …  
    11811181FNIEMOP_DEF(iemOp_vmovapd_Vpd_Wpd)
    11821182{
    1183     IEMOP_MNEMONIC2(VEX_RM, VMOVAPD, vmovapd, Vpd_WO, Wpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1183    IEMOP_MNEMONIC2(VEX_RM, VMOVAPD, vmovapd, Vpd_WO, Wpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    11841184    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    11851185    Assert(pVCpu->iem.s.uVexLength <= 1);
    … …  
    12781278FNIEMOP_DEF(iemOp_vmovaps_Wps_Vps)
    12791279{
    1280     IEMOP_MNEMONIC2(VEX_MR, VMOVAPS, vmovaps, Wps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1280    IEMOP_MNEMONIC2(VEX_MR, VMOVAPS, vmovaps, Wps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    12811281    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    12821282    Assert(pVCpu->iem.s.uVexLength <= 1);
    … …  
    13551355FNIEMOP_DEF(iemOp_vmovapd_Wpd_Vpd)
    13561356{
    1357     IEMOP_MNEMONIC2(VEX_MR, VMOVAPD, vmovapd, Wpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1357    IEMOP_MNEMONIC2(VEX_MR, VMOVAPD, vmovapd, Wpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    13581358    Assert(pVCpu->iem.s.uVexLength <= 1);
    13591359    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    … …  
    14591459 * @optest      op1=1 op2=2 -> op1=2
    14601460 * @optest      op1=0 op2=-42 -> op1=-42
    1461  * @oponly
    14621461 * @note        Identical implementation to vmovntpd
    14631462 */
    14641463FNIEMOP_DEF(iemOp_vmovntps_Mps_Vps)
    14651464{
    1466     IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVNTPS, vmovntps, Mps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1465    IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVNTPS, vmovntps, Mps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    14671466    Assert(pVCpu->iem.s.uVexLength <= 1);
    14681467    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    … …  
    15221521 * @optest      op1=1 op2=2 -> op1=2
    15231522 * @optest      op1=0 op2=-42 -> op1=-42
    1524  * @oponly
    15251523 * @note        Identical implementation to vmovntps
    15261524 */
    15271525FNIEMOP_DEF(iemOp_vmovntpd_Mpd_Vpd)
    15281526{
    1529     IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVNTPD, vmovntpd, Mpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     1527    IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVNTPD, vmovntpd, Mpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    15301528    Assert(pVCpu->iem.s.uVexLength <= 1);
    15311529    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    … …  
    15831581 * @opcpuid     avx
    15841582 * @optest      ->
    1585  * @oponly
    15861583 * @opdone
    15871584 */
    … …  
    15941591 * @opcpuid     avx
    15951592 * @optest      ->
    1596  * @oponly
    15971593 * @opdone
    15981594 */
    … …  
    20482044/** Opcode VEX.66.0F 0x6e - vmovd/q Vy, Ey */
    20492045FNIEMOP_STUB(iemOp_vmovd_q_Vy_Ey);
    2050 //FNIEMOP_DEF(iemOp_vmovd_q_Vy_Ey)
    2051 //{
    2052 //    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    2053 //    if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    2054 //        IEMOP_MNEMONIC(vmovdq_Wq_Eq, "vmovq Wq,Eq");
    2055 //    else
    2056 //        IEMOP_MNEMONIC(vmovdq_Wd_Ed, "vmovd Wd,Ed");
    2057 //    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
    2058 //    {
    2059 //        /* XMM, greg*/
    2060 //        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    2061 //        IEM_MC_BEGIN(0, 1);
    2062 //        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
    2063 //        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    2064 //        if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    2065 //        {
    2066 //            IEM_MC_LOCAL(uint64_t, u64Tmp);
    2067 //            IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    2068 //            IEM_MC_STORE_XREG_U64_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp);
    2069 //        }
    2070 //        else
    2071 //        {
    2072 //            IEM_MC_LOCAL(uint32_t, u32Tmp);
    2073 //            IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    2074 //            IEM_MC_STORE_XREG_U32_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp);
    2075 //        }
    2076 //        IEM_MC_ADVANCE_RIP();
    2077 //        IEM_MC_END();
    2078 //    }
    2079 //    else
    2080 //    {
    2081 //        /* XMM, [mem] */
    2082 //        IEM_MC_BEGIN(0, 2);
    2083 //        IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
    2084 //        IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT(); /** @todo order */
    2085 //        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 1);
    2086 //        IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    2087 //        IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE();
    2088 //        if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
    2089 //        {
    2090 //            IEM_MC_LOCAL(uint64_t, u64Tmp);
    2091 //            IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    2092 //            IEM_MC_STORE_XREG_U64_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp);
    2093 //        }
    2094 //        else
    2095 //        {
    2096 //            IEM_MC_LOCAL(uint32_t, u32Tmp);
    2097 //            IEM_MC_FETCH_MEM_U32(u32Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    2098 //            IEM_MC_STORE_XREG_U32_ZX_U128(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp);
    2099 //        }
    2100 //        IEM_MC_ADVANCE_RIP();
    2101 //        IEM_MC_END();
    2102 //    }
    2103 //    return VINF_SUCCESS;
    2104 //}
    21052046
    21062047/*  Opcode VEX.F3.0F 0x6e - invalid */
    … …  
    28512792//FNIEMOP_DEF_1(iemOp_VGrp15_vldmxcsr, uint8_t, bRm)
    28522793//{
    2853 //    IEMOP_MNEMONIC1(M_MEM, VLDMXCSR, vldmxcsr, MdRO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     2794//    IEMOP_MNEMONIC1(M_MEM, VLDMXCSR, vldmxcsr, MdRO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    28542795//    if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSse)
    28552796//        return IEMOP_RAISE_INVALID_OPCODE();
    … …  
    29082849FNIEMOP_DEF_1(iemOp_VGrp15_vstmxcsr,  uint8_t, bRm)
    29092850{
    2910     IEMOP_MNEMONIC1(VEX_M_MEM, VSTMXCSR, vstmxcsr, Md_WO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     2851    IEMOP_MNEMONIC1(VEX_M_MEM, VSTMXCSR, vstmxcsr, Md_WO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    29112852    IEM_MC_BEGIN(2, 0);
    29122853    IEM_MC_ARG(uint8_t,         iEffSeg,                                 0);
    … …  
    30953036//FNIEMOP_DEF(iemOp_vmovq_Wq_Vq)
    30963037//{
    3097 //    IEMOP_MNEMONIC2(MR, VMOVQ, vmovq, WqZxReg, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZE);
     3038//    IEMOP_MNEMONIC2(MR, VMOVQ, vmovq, WqZxReg, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
    30983039//    uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
    30993040//    if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))

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

    r66966 r67003  
    954954 * @note These are ORed together with IEMOPFORM_XXX.
    955955 * @{ */
    956 /** Both the operand size prefixes are ignored. */
    957 #define IEMOPHINT_IGNORES_OP_SIZE   RT_BIT_32(10)
     956/** Ignores the operand size prefix (66h). */
     957#define IEMOPHINT_IGNORES_OZ_PFX    RT_BIT_32(10)
     958/** Ignores REX.W. */
     959#define IEMOPHINT_IGNORES_REXW      RT_BIT_32(11)
     960/** Both the operand size prefixes (66h + REX.W) are ignored. */
     961#define IEMOPHINT_IGNORES_OP_SIZES  (IEMOPHINT_IGNORES_OZ_PFX | IEMOPHINT_IGNORES_REXW)
    958962/** Allowed with the lock prefix. */
    959963#define IEMOPHINT_LOCK_ALLOWED      RT_BIT_32(11)

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-generated-1-data.py

    r66976 r67003  
    305305        for oOp in oInstr.aoOperands:
    306306            self.sEncoding     += '_' + oOp.sType;
     307        if oInstr.sSubOpcode == 'rex.w=1':      self.sEncoding += '_WNZ';
     308        elif oInstr.sSubOpcode == 'rex.w=0':    self.sEncoding += '_WZ';
     309
    307310        if oInstr.fUnused:
    308311            if oInstr.sInvalidStyle == 'immediate' and oInstr.sSubOpcode:

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-generated-1-template.c

    r66992 r67003  
    471471    /* [BS3CG1DST_MM6] = */         8,
    472472    /* [BS3CG1DST_MM7] = */         8,
     473    /* [BS3CG1DST_MM0_LO_ZX] = */   4,
     474    /* [BS3CG1DST_MM1_LO_ZX] = */   4,
     475    /* [BS3CG1DST_MM2_LO_ZX] = */   4,
     476    /* [BS3CG1DST_MM3_LO_ZX] = */   4,
     477    /* [BS3CG1DST_MM4_LO_ZX] = */   4,
     478    /* [BS3CG1DST_MM5_LO_ZX] = */   4,
     479    /* [BS3CG1DST_MM6_LO_ZX] = */   4,
     480    /* [BS3CG1DST_MM7_LO_ZX] = */   4,
    473481    /* [BS3CG1DST_XMM0] = */        16,
    474482    /* [BS3CG1DST_XMM1] = */        16,
    … …  
    734742    /* [BS3CG1DST_MM6] = */         sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[6]),
    735743    /* [BS3CG1DST_MM7] = */         sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[7]),
     744    /* [BS3CG1DST_MM0_LO_ZX] = */   sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[0]),
     745    /* [BS3CG1DST_MM1_LO_ZX] = */   sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[1]),
     746    /* [BS3CG1DST_MM2_LO_ZX] = */   sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[2]),
     747    /* [BS3CG1DST_MM3_LO_ZX] = */   sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[3]),
     748    /* [BS3CG1DST_MM4_LO_ZX] = */   sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[4]),
     749    /* [BS3CG1DST_MM5_LO_ZX] = */   sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[5]),
     750    /* [BS3CG1DST_MM6_LO_ZX] = */   sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[6]),
     751    /* [BS3CG1DST_MM7_LO_ZX] = */   sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[7]),
    736752
    737753    /* [BS3CG1DST_XMM0] = */        sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[0]),
    … …  
    9991015    { "MM6" },
    10001016    { "MM7" },
     1017    { "MM0_LO_ZX" },
     1018    { "MM1_LO_ZX" },
     1019    { "MM2_LO_ZX" },
     1020    { "MM3_LO_ZX" },
     1021    { "MM4_LO_ZX" },
     1022    { "MM5_LO_ZX" },
     1023    { "MM6_LO_ZX" },
     1024    { "MM7_LO_ZX" },
    10011025    { "XMM0" },
    10021026    { "XMM1" },
    … …  
    12931317
    12941318static unsigned BS3_NEAR_CODE Bs3Cfg1EncodeMemMod0Disp(PBS3CG1STATE pThis, bool fAddrOverride, unsigned off, uint8_t iReg,
    1295                                                        uint8_t cbOp, uint8_t cbMissalign, BS3CG1OPLOC enmLocation)
     1319                                                       uint8_t cbOp, uint8_t cbMisalign, BS3CG1OPLOC enmLocation)
    12961320{
    12971321    pThis->aOperands[pThis->iRmOp].idxField     = BS3CG1DST_INVALID;
    12981322    pThis->aOperands[pThis->iRmOp].enmLocation  = enmLocation;
    12991323    pThis->aOperands[pThis->iRmOp].cbOp         = cbOp;
    1300     pThis->aOperands[pThis->iRmOp].off          = cbOp + cbMissalign;
     1324    pThis->aOperands[pThis->iRmOp].off          = cbOp + cbMisalign;
    13011325
    13021326    if (   BS3_MODE_IS_16BIT_CODE(pThis->bMode)
    … …  
    13171341        {
    13181342            pThis->abCurInstr[off++] = X86_MODRM_MAKE(0, iReg, 6 /*disp16*/);
    1319             *(uint16_t *)&pThis->abCurInstr[off] = pThis->DataPgFar.off + X86_PAGE_SIZE - cbOp - cbMissalign;
     1343            *(uint16_t *)&pThis->abCurInstr[off] = pThis->DataPgFar.off + X86_PAGE_SIZE - cbOp - cbMisalign;
    13201344            off += 2;
    13211345        }
    … …  
    13231347        {
    13241348            pThis->abCurInstr[off++] = X86_MODRM_MAKE(0, iReg, 5 /*disp32*/);
    1325             *(uint32_t *)&pThis->abCurInstr[off] = pThis->DataPgFar.off + X86_PAGE_SIZE - cbOp - cbMissalign;
     1349            *(uint32_t *)&pThis->abCurInstr[off] = pThis->DataPgFar.off + X86_PAGE_SIZE - cbOp - cbMisalign;
    13261350            off += 4;
    13271351        }
    … …  
    13341358         */
    13351359        pThis->abCurInstr[off++] = X86_MODRM_MAKE(0, iReg, 5 /*disp32*/);
    1336         *(uint32_t *)&pThis->abCurInstr[off] = BS3_FP_OFF(pThis->pbDataPg) + X86_PAGE_SIZE - cbOp - cbMissalign;
     1360        *(uint32_t *)&pThis->abCurInstr[off] = BS3_FP_OFF(pThis->pbDataPg) + X86_PAGE_SIZE - cbOp - cbMisalign;
    13371361
    13381362#if ARCH_BITS == 64
    … …  
    13471371     * Fill the memory with 0xcc.
    13481372     */
    1349     switch (cbOp + cbMissalign)
     1373    switch (cbOp + cbMisalign)
    13501374    {
    13511375        case 8: pThis->pbDataPg[X86_PAGE_SIZE - 8] = 0xcc;  /* fall thru */
    … …  
    13601384        default:
    13611385        {
    1362             BS3CG1_DPRINTF(("Bs3MemSet(%p,%#x,%#x)\n", &pThis->pbDataPg[X86_PAGE_SIZE - cbOp - cbMissalign], 0xcc, cbOp - cbMissalign));
    1363             Bs3MemSet(&pThis->pbDataPg[X86_PAGE_SIZE - cbOp - cbMissalign], 0xcc, cbOp - cbMissalign);
     1386            BS3CG1_DPRINTF(("Bs3MemSet(%p,%#x,%#x)\n", &pThis->pbDataPg[X86_PAGE_SIZE - cbOp - cbMisalign], 0xcc, cbOp - cbMisalign));
     1387            Bs3MemSet(&pThis->pbDataPg[X86_PAGE_SIZE - cbOp - cbMisalign], 0xcc, cbOp - cbMisalign);
    13641388            break;
    13651389        }
    … …  
    13741398static unsigned BS3_NEAR_CODE
    13751399Bs3Cfg1EncodeMemMod0DispWithRegField(PBS3CG1STATE pThis, bool fAddrOverride, unsigned off, uint8_t iReg,
    1376                                      uint8_t cbOp, uint8_t cbMissalign, BS3CG1OPLOC enmLocation)
     1400                                     uint8_t cbOp, uint8_t cbMisalign, BS3CG1OPLOC enmLocation)
    13771401{
    13781402    pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + iReg;
    1379     return Bs3Cfg1EncodeMemMod0Disp(pThis, fAddrOverride, off, iReg & 7, cbOp, cbMissalign, enmLocation);
     1403    return Bs3Cfg1EncodeMemMod0Disp(pThis, fAddrOverride, off, iReg & 7, cbOp, cbMisalign, enmLocation);
    13801404}
    13811405#endif
    … …  
    13841408static unsigned BS3_NEAR_CODE
    13851409Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(PBS3CG1STATE pThis, bool fAddrOverride, unsigned off,
    1386                                                 uint8_t iReg, uint8_t cbMissalign)
     1410                                                uint8_t iReg, uint8_t cbMisalign)
    13871411{
    13881412    pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + iReg;
    1389     return Bs3Cfg1EncodeMemMod0Disp(pThis, fAddrOverride, off, iReg & 7, pThis->aOperands[pThis->iRmOp].cbOp, cbMissalign,
     1413    return Bs3Cfg1EncodeMemMod0Disp(pThis, fAddrOverride, off, iReg & 7, pThis->aOperands[pThis->iRmOp].cbOp, cbMisalign,
    13901414                                    pThis->aOperands[pThis->iRmOp].enmLocation);
    13911415}
    … …  
    15551579        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3_DW0;
    15561580        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    1557         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 4, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM_WO);
     1581        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 4, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM_WO);
    15581582    }
    15591583    else
    … …  
    15841608        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3_LO;
    15851609        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    1586         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM_WO);
     1610        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM_WO);
    15871611    }
    15881612    else
    … …  
    16131637        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3;
    16141638        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    1615         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 16, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM_WO);
     1639        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 16, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM_WO);
    16161640        if (!Bs3Cg1XcptTypeIsUnaligned(pThis->enmXcptType))
    16171641            pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    16441668        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3_LO;
    16451669        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    1646         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM_WO);
     1670        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM_WO);
    16471671    }
    16481672    else
    … …  
    16771701
    16781702
     1703static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_PdZx_WO_Ed_WZ(PBS3CG1STATE pThis, unsigned iEncoding)
     1704{
     1705    unsigned off;
     1706    switch (iEncoding)
     1707    {
     1708        case 0:
     1709            pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
     1710            off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
     1711            pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, 1, 0);
     1712            pThis->aOperands[pThis->iRmOp ].idxField = pThis->aOperands[pThis->iRmOp ].idxFieldBase + 0;
     1713            pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + 1;
     1714            break;
     1715        case 1:
     1716            off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
     1717            pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, 6, 2);
     1718            pThis->aOperands[pThis->iRmOp ].idxField = pThis->aOperands[pThis->iRmOp ].idxFieldBase + 2;
     1719            pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + 6;
     1720            break;
     1721        case 2:
     1722            pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
     1723            off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
     1724            off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 4 /*iReg*/, 0 /*cbMisalign*/);
     1725            break;
     1726        case 3:
     1727            off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
     1728            off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 7 /*iReg*/, 1 /*cbMisalign*/);
     1729            break;
     1730
     1731        default:
     1732            return 0;
     1733    }
     1734    pThis->cbCurInstr = off;
     1735    return iEncoding + 1;
     1736}
     1737
     1738
     1739static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Pq_WO_Eq_WNZ(PBS3CG1STATE pThis, unsigned iEncoding)
     1740{
     1741#if ARCH_BITS == 64
     1742    if (BS3CG1_IS_64BIT_TARGET(pThis))
     1743    {
     1744        unsigned off;
     1745        switch (iEncoding)
     1746        {
     1747            case 0:
     1748                pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
     1749                off = Bs3Cg1InsertReqPrefix(pThis, 0);
     1750                pThis->abCurInstr[off++] = REX_W___;
     1751                off = Bs3Cg1InsertOpcodes(pThis, off);
     1752                pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, 1, 0);
     1753                pThis->aOperands[pThis->iRmOp ].idxField = pThis->aOperands[pThis->iRmOp ].idxFieldBase + 0;
     1754                pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + 1;
     1755                break;
     1756            case 1:
     1757                off = Bs3Cg1InsertReqPrefix(pThis, 0);
     1758                pThis->abCurInstr[off++] = REX_W___;
     1759                off = Bs3Cg1InsertOpcodes(pThis, off);
     1760                pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, 6, 2);
     1761                pThis->aOperands[pThis->iRmOp ].idxField = pThis->aOperands[pThis->iRmOp ].idxFieldBase + 2;
     1762                pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + 6;
     1763                break;
     1764            case 2:
     1765                pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
     1766                off = Bs3Cg1InsertReqPrefix(pThis, 0);
     1767                pThis->abCurInstr[off++] = REX_W___;
     1768                off = Bs3Cg1InsertOpcodes(pThis, off);
     1769                off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 4 /*iReg*/, 0 /*cbMisalign*/);
     1770                break;
     1771            case 3:
     1772                off = Bs3Cg1InsertReqPrefix(pThis, 0);
     1773                pThis->abCurInstr[off++] = REX_W___;
     1774                off = Bs3Cg1InsertOpcodes(pThis, off);
     1775                off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 7 /*iReg*/, 1 /*cbMisalign*/);
     1776                break;
     1777
     1778            default:
     1779                return 0;
     1780        }
     1781        pThis->cbCurInstr = off;
     1782        return iEncoding + 1;
     1783    }
     1784#endif
     1785    return 0;
     1786}
     1787
     1788
    16791789static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Vq_WO_UqHi(PBS3CG1STATE pThis, unsigned iEncoding)
    16801790{
    … …  
    17141824        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3_LO;
    17151825        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    1716         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM);
     1826        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM);
    17171827    }
    17181828    else
    … …  
    17601870        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3_HI;
    17611871        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    1762         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM);
     1872        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM);
    17631873    }
    17641874    else
    … …  
    17891899        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3;
    17901900        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    1791         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 16, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM);
     1901        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 16, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM);
    17921902        if (!Bs3Cg1XcptTypeIsUnaligned(pThis->enmXcptType))
    17931903            pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    18211931        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3;
    18221932        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    1823         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 16, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM);
     1933        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 16, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM);
    18241934        if (!Bs3Cg1XcptTypeIsUnaligned(pThis->enmXcptType))
    18251935            pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    18521962        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3_DW0_ZX;
    18531963        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    1854         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 4, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM);
     1964        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 4, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM);
    18551965    }
    18561966    else
    … …  
    18821992        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3_LO_ZX;
    18831993        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    1884         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM);
     1994        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM);
    18851995    }
    18861996    else
    … …  
    20222132        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3_LO;
    20232133        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    2024         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM_WO);
     2134        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM_WO);
    20252135    }
    20262136    else
    … …  
    20442154        pThis->aOperands[pThis->iRegOp].idxField = BS3CG1DST_XMM3_HI;
    20452155        off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    2046         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM_WO);
     2156        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 8, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM_WO);
    20472157    }
    20482158    else
    … …  
    20642174        case 1:
    20652175            off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
    2066             off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 2 /*iReg*/, 1 /*cbMissalign*/ );
     2176            off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 2 /*iReg*/, 1 /*cbMisalign*/ );
    20672177            if (!Bs3Cg1XcptTypeIsUnaligned(pThis->enmXcptType))
    20682178                pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    23682478        off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
    23692479        off = Bs3Cg1InsertOpcodes(pThis, off);
    2370         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 16, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM);
     2480        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 16, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM);
    23712481        if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
    23722482            pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    23772487        off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
    23782488        off = Bs3Cg1InsertOpcodes(pThis, off);
    2379         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 16, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM);
     2489        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 16, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM);
    23802490        if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
    23812491            pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    24532563        off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L*/, 1 /*~R*/);
    24542564        off = Bs3Cg1InsertOpcodes(pThis, off);
    2455         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 32, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM);
     2565        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 32, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM);
    24562566        if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
    24572567            pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    24622572        off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
    24632573        off = Bs3Cg1InsertOpcodes(pThis, off);
    2464         off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 32, 1 /*cbMissalign*/, BS3CG1OPLOC_MEM);
     2574        off = Bs3Cfg1EncodeMemMod0Disp(pThis, false, off, 3 /*iReg*/, 32, 1 /*cbMisalign*/, BS3CG1OPLOC_MEM);
    24652575        if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
    24662576            pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    32483358            off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
    32493359            off = Bs3Cg1InsertOpcodes(pThis, off);
    3250             off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 3 /*iReg*/, 1 /*cbMissalign*/);
     3360            off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 3 /*iReg*/, 1 /*cbMisalign*/);
    32513361            if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
    32523362                pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    32553365            off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
    32563366            off = Bs3Cg1InsertOpcodes(pThis, off);
    3257             off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 3 /*iReg*/, 1 /*cbMissalign*/);
     3367            off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 3 /*iReg*/, 1 /*cbMisalign*/);
    32583368            if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
    32593369                pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    33303440            off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L*/, 1 /*~R*/);
    33313441            off = Bs3Cg1InsertOpcodes(pThis, off);
    3332             off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 3 /*iReg*/, 1 /*cbMissalign*/);
     3442            off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 3 /*iReg*/, 1 /*cbMisalign*/);
    33333443            if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
    33343444                pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    33373447            off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
    33383448            off = Bs3Cg1InsertOpcodes(pThis, off);
    3339             off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 3 /*iReg*/, 1 /*cbMissalign*/);
     3449            off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, false, off, 3 /*iReg*/, 1 /*cbMisalign*/);
    33403450            if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
    33413451                pThis->bAlignmentXcpt = X86_XCPT_GP;
    … …  
    35683678        case BS3CG1ENC_MODRM_WqZxReg_WO_Vq:
    35693679            return Bs3Cg1EncodeNext_MODRM_WqZxReg_WO_Vq(pThis, iEncoding);
    3570 
    3571         case BS3CG1ENC_MODRM_Pq_WO_Uq:
    3572             return Bs3Cg1EncodeNext_MODRM_Pq_WO_Uq(pThis, iEncoding);
    35733680
    35743681        case BS3CG1ENC_MODRM_Vq_WO_UqHi:
    … …  
    37643871
    37653872        case BS3CG1ENC_MODRM_Pq_WO_Uq:
     3873            pThis->pfnEncoder        = Bs3Cg1EncodeNext_MODRM_Pq_WO_Uq;
     3874            pThis->iRmOp             = 1;
     3875            pThis->iRegOp            = 0;
     3876            pThis->aOperands[0].cbOp = 8;
     3877            pThis->aOperands[1].cbOp = 8;
     3878            pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
     3879            pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
     3880            break;
     3881
     3882        case BS3CG1ENC_MODRM_PdZx_WO_Ed_WZ:
     3883            pThis->pfnEncoder        = Bs3Cg1EncodeNext_MODRM_PdZx_WO_Ed_WZ;
     3884            pThis->iRegOp            = 0;
     3885            pThis->iRmOp             = 1;
     3886            pThis->aOperands[0].cbOp = 4;
     3887            pThis->aOperands[1].cbOp = 4;
     3888            pThis->aOperands[0].idxFieldBase   = BS3CG1DST_MM0_LO_ZX;
     3889            pThis->aOperands[1].idxFieldBase   = BS3CG1DST_EAX;
     3890            pThis->aOperands[0].enmLocation    = BS3CG1OPLOC_CTX;
     3891            pThis->aOperands[1].enmLocation    = BS3CG1OPLOC_CTX;
     3892            pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
     3893            pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
     3894            break;
     3895
     3896        case BS3CG1ENC_MODRM_Pq_WO_Eq_WNZ:
     3897            pThis->pfnEncoder        = Bs3Cg1EncodeNext_MODRM_Pq_WO_Eq_WNZ;
     3898            pThis->iRegOp            = 0;
     3899            pThis->iRmOp             = 1;
     3900            pThis->aOperands[0].cbOp = 8;
     3901            pThis->aOperands[1].cbOp = 8;
     3902            pThis->aOperands[0].idxFieldBase   = BS3CG1DST_MM0;
     3903            pThis->aOperands[1].idxFieldBase   = BS3CG1DST_RAX;
     3904            pThis->aOperands[0].enmLocation    = BS3CG1OPLOC_CTX;
     3905            pThis->aOperands[1].enmLocation    = BS3CG1OPLOC_CTX;
     3906            pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
     3907            pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
     3908            break;
     3909
    37663910        case BS3CG1ENC_MODRM_Vq_WO_UqHi:
    37673911        case BS3CG1ENC_MODRM_VqHi_WO_Uq:
    … …  
    42094353            return false;
    42104354
     4355        case BS3CG1CPU_MMX:
     4356            return false;
     4357
    42114358        case BS3CG1CPU_SSE:
    42124359        case BS3CG1CPU_SSE2:
    … …  
    42774424            if ((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_Pentium)
    42784425                return true;
     4426            return false;
     4427
     4428        case BS3CG1CPU_MMX:
     4429            if (g_uBs3CpuDetected & BS3CPU_F_CPUID)
     4430            {
     4431                ASMCpuIdExSlow(1, 0, 0, 0, NULL, NULL, NULL, &fEdx);
     4432                if (fEdx & X86_CPUID_FEATURE_EDX_MMX)
     4433                    return Bs3Cg3SetupSseAndAvx(pThis); /** @todo only do FNSAVE/FXSAVE here? */
     4434            }
    42794435            return false;
    42804436
    … …  
    47104866                        PtrField.pu64[1] = 0;
    47114867                    }
    4712                     else if (offField <= RT_OFFSETOF(BS3REGCTX, r15)) /* Clear the top dword. */
     4868                    else if (offField <= RT_OFFSETOF(BS3REGCTX, r15) /* Clear the top dword. */)
    47134869                        PtrField.pu32[1] = 0;
     4870                    else if ((unsigned)(idxField - BS3CG1DST_MM0_LO_ZX) <= (unsigned)(BS3CG1DST_MM7_LO_ZX - BS3CG1DST_MM0_LO_ZX))
     4871                    {
     4872                        PtrField.pu32[1] = 0;
     4873                        PtrField.pu32[2] = 0xffff; /* observed on skylake */
     4874                    }
    47144875                    switch (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK)
    47154876                    {

  • trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-generated-1.h

    r66992 r67003  
    4343
    4444    BS3CG1OP_Eb,
     45    BS3CG1OP_Ed,
     46    BS3CG1OP_Eq,
    4547    BS3CG1OP_Ev,
    4648    BS3CG1OP_Wss,
    … …  
    6668    BS3CG1OP_HqHi,
    6769    BS3CG1OP_Nq,
     70    BS3CG1OP_Pd,
     71    BS3CG1OP_PdZx_WO,
     72    BS3CG1OP_Pq,
    6873    BS3CG1OP_Pq_WO,
    6974    BS3CG1OP_Uq,
    … …  
    136141    BS3CG1ENC_MODRM_Gv_RO_Ma, /**< bound instruction */
    137142    BS3CG1ENC_MODRM_Pq_WO_Uq,
     143    BS3CG1ENC_MODRM_PdZx_WO_Ed_WZ,
     144    BS3CG1ENC_MODRM_Pq_WO_Eq_WNZ,
    138145    BS3CG1ENC_MODRM_Vq_WO_UqHi,
    139146    BS3CG1ENC_MODRM_Vq_WO_Mq,
    … …  
    223230    BS3CG1CPU_GE_Pentium,
    224231
     232    BS3CG1CPU_MMX,
    225233    BS3CG1CPU_SSE,
    226234    BS3CG1CPU_SSE2,
    … …  
    525533    BS3CG1DST_MM6,
    526534    BS3CG1DST_MM7,
     535    BS3CG1DST_MM0_LO_ZX,
     536    BS3CG1DST_MM1_LO_ZX,
     537    BS3CG1DST_MM2_LO_ZX,
     538    BS3CG1DST_MM3_LO_ZX,
     539    BS3CG1DST_MM4_LO_ZX,
     540    BS3CG1DST_MM5_LO_ZX,
     541    BS3CG1DST_MM6_LO_ZX,
     542    BS3CG1DST_MM7_LO_ZX,
    527543    /* SSE registers. */
    528544    BS3CG1DST_XMM0,
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