VirtualBox

Changeset 98880 in vbox


Ignore:
Timestamp:
Mar 9, 2023 1:23:15 AM (21 months ago)
Author:
vboxsync
Message:

VMM/IEM: More work on processing MC blocks. bugref:10369

Location:
trunk/src/VBox/VMM/VMMAll
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed

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

    r98873 r98880  
    70997099    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    71007100    IEM_MC_PREPARE_FPU_USAGE();
    7101     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, IEM_GET_MODRM_RM_8(bRm))
     7101    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, IEM_GET_MODRM_RM_8(bRm)) {
    71027102        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pr80Value2);
    71037103        IEM_MC_STORE_FPU_RESULT(FpuRes, 0);
    7104     IEM_MC_ELSE()
     7104    } IEM_MC_ELSE() {
    71057105        IEM_MC_FPU_STACK_UNDERFLOW(0);
    7106     IEM_MC_ENDIF();
     7106    } IEM_MC_ENDIF();
    71077107    IEM_MC_ADVANCE_RIP_AND_FINISH();
    71087108
    … …  
    71317131    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    71327132    IEM_MC_PREPARE_FPU_USAGE();
    7133     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, IEM_GET_MODRM_RM_8(bRm))
     7133    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, IEM_GET_MODRM_RM_8(bRm)) {
    71347134        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pu16Fsw, pr80Value1, pr80Value2);
    71357135        IEM_MC_UPDATE_FSW(u16Fsw);
    7136     IEM_MC_ELSE()
     7136    } IEM_MC_ELSE() {
    71377137        IEM_MC_FPU_STACK_UNDERFLOW(UINT8_MAX);
    7138     IEM_MC_ENDIF();
     7138    } IEM_MC_ENDIF();
    71397139    IEM_MC_ADVANCE_RIP_AND_FINISH();
    71407140
    … …  
    71637163    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    71647164    IEM_MC_PREPARE_FPU_USAGE();
    7165     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, IEM_GET_MODRM_RM_8(bRm))
     7165    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, IEM_GET_MODRM_RM_8(bRm)) {
    71667166        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pu16Fsw, pr80Value1, pr80Value2);
    71677167        IEM_MC_UPDATE_FSW_THEN_POP(u16Fsw);
    7168     IEM_MC_ELSE()
     7168    } IEM_MC_ELSE() {
    71697169        IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP(UINT8_MAX);
    7170     IEM_MC_ENDIF();
     7170    } IEM_MC_ENDIF();
    71717171    IEM_MC_ADVANCE_RIP_AND_FINISH();
    71727172
    … …  
    72647264
    72657265    IEM_MC_PREPARE_FPU_USAGE();
    7266     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     7266    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    72677267        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pr32Val2);
    72687268        IEM_MC_STORE_FPU_RESULT(FpuRes, 0);
    7269     IEM_MC_ELSE()
     7269    } IEM_MC_ELSE() {
    72707270        IEM_MC_FPU_STACK_UNDERFLOW(0);
    7271     IEM_MC_ENDIF();
     7271    } IEM_MC_ENDIF();
    72727272    IEM_MC_ADVANCE_RIP_AND_FINISH();
    72737273
    … …  
    73137313
    73147314    IEM_MC_PREPARE_FPU_USAGE();
    7315     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     7315    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    73167316        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r32, pu16Fsw, pr80Value1, pr32Val2);
    73177317        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    7318     IEM_MC_ELSE()
     7318    } IEM_MC_ELSE() {
    73197319        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    7320     IEM_MC_ENDIF();
     7320    } IEM_MC_ENDIF();
    73217321    IEM_MC_ADVANCE_RIP_AND_FINISH();
    73227322
    … …  
    73467346
    73477347    IEM_MC_PREPARE_FPU_USAGE();
    7348     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     7348    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    73497349        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r32, pu16Fsw, pr80Value1, pr32Val2);
    73507350        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    7351     IEM_MC_ELSE()
     7351    } IEM_MC_ELSE() {
    73527352        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    7353     IEM_MC_ENDIF();
     7353    } IEM_MC_ENDIF();
    73547354    IEM_MC_ADVANCE_RIP_AND_FINISH();
    73557355
    … …  
    74527452
    74537453    IEM_MC_PREPARE_FPU_USAGE();
    7454     IEM_MC_IF_FPUREG_IS_EMPTY(7)
     7454    IEM_MC_IF_FPUREG_IS_EMPTY(7) {
    74557455        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r80_from_r32, pFpuRes, pr32Val);
    74567456        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    7457     IEM_MC_ELSE()
     7457    } IEM_MC_ELSE() {
    74587458        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    7459     IEM_MC_ENDIF();
     7459    } IEM_MC_ENDIF();
    74607460    IEM_MC_ADVANCE_RIP_AND_FINISH();
    74617461
    … …  
    74827482    IEM_MC_MEM_MAP(pr32Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    74837483    IEM_MC_PREPARE_FPU_USAGE();
    7484     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     7484    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    74857485        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r32, pu16Fsw, pr32Dst, pr80Value);
    74867486        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pr32Dst, IEM_ACCESS_DATA_W, u16Fsw);
    74877487        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    7488     IEM_MC_ELSE()
    7489         IEM_MC_IF_FCW_IM()
     7488    } IEM_MC_ELSE() {
     7489        IEM_MC_IF_FCW_IM() {
    74907490            IEM_MC_STORE_MEM_NEG_QNAN_R32_BY_REF(pr32Dst);
    74917491            IEM_MC_MEM_COMMIT_AND_UNMAP(pr32Dst, IEM_ACCESS_DATA_W);
    7492         IEM_MC_ENDIF();
     7492        } IEM_MC_ENDIF();
    74937493        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    7494     IEM_MC_ENDIF();
     7494    } IEM_MC_ENDIF();
    74957495    IEM_MC_ADVANCE_RIP_AND_FINISH();
    74967496
    … …  
    75177517    IEM_MC_MEM_MAP(pr32Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    75187518    IEM_MC_PREPARE_FPU_USAGE();
    7519     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     7519    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    75207520        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r32, pu16Fsw, pr32Dst, pr80Value);
    75217521        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pr32Dst, IEM_ACCESS_DATA_W, u16Fsw);
    75227522        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    7523     IEM_MC_ELSE()
    7524         IEM_MC_IF_FCW_IM()
     7523    } IEM_MC_ELSE() {
     7524        IEM_MC_IF_FCW_IM() {
    75257525            IEM_MC_STORE_MEM_NEG_QNAN_R32_BY_REF(pr32Dst);
    75267526            IEM_MC_MEM_COMMIT_AND_UNMAP(pr32Dst, IEM_ACCESS_DATA_W);
    7527         IEM_MC_ENDIF();
     7527        } IEM_MC_ENDIF();
    75287528        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    7529     IEM_MC_ENDIF();
     7529    } IEM_MC_ENDIF();
    75307530    IEM_MC_ADVANCE_RIP_AND_FINISH();
    75317531
    … …  
    76387638
    76397639    IEM_MC_PREPARE_FPU_USAGE();
    7640     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, IEM_GET_MODRM_RM_8(bRm))
     7640    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, IEM_GET_MODRM_RM_8(bRm)) {
    76417641        IEM_MC_SET_FPU_RESULT(FpuRes, 0 /*FSW*/, pr80Value);
    76427642        IEM_MC_PUSH_FPU_RESULT(FpuRes);
    7643     IEM_MC_ELSE()
     7643    } IEM_MC_ELSE() {
    76447644        IEM_MC_FPU_STACK_PUSH_UNDERFLOW();
    7645     IEM_MC_ENDIF();
     7645    } IEM_MC_ENDIF();
    76467646
    76477647    IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    76677667
    76687668    IEM_MC_PREPARE_FPU_USAGE();
    7669     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, IEM_GET_MODRM_RM_8(bRm))
     7669    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, IEM_GET_MODRM_RM_8(bRm)) {
    76707670        IEM_MC_SET_FPU_RESULT(FpuRes, X86_FSW_C1, pr80Value2);
    76717671        IEM_MC_STORE_FPUREG_R80_SRC_REF(IEM_GET_MODRM_RM_8(bRm), pr80Value1);
    76727672        IEM_MC_STORE_FPU_RESULT(FpuRes, 0);
    7673     IEM_MC_ELSE()
     7673    } IEM_MC_ELSE() {
    76747674        IEM_MC_CALL_CIMPL_1(iemCImpl_fxch_underflow, iStReg);
    7675     IEM_MC_ENDIF();
     7675    } IEM_MC_ENDIF();
    76767676
    76777677    IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    76967696
    76977697        IEM_MC_PREPARE_FPU_USAGE();
    7698         IEM_MC_IF_FPUREG_NOT_EMPTY(0)
     7698        IEM_MC_IF_FPUREG_NOT_EMPTY(0) {
    76997699            IEM_MC_UPDATE_FSW_THEN_POP(u16Fsw);
    7700         IEM_MC_ELSE()
     7700        } IEM_MC_ELSE() {
    77017701            IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP(0);
    7702         IEM_MC_ENDIF();
     7702        } IEM_MC_ENDIF();
    77037703
    77047704        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    77147714
    77157715        IEM_MC_PREPARE_FPU_USAGE();
    7716         IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     7716        IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    77177717            IEM_MC_SET_FPU_RESULT(FpuRes, 0 /*FSW*/, pr80Value);
    77187718            IEM_MC_STORE_FPU_RESULT_THEN_POP(FpuRes, iDstReg);
    7719         IEM_MC_ELSE()
     7719        } IEM_MC_ELSE() {
    77207720            IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP(iDstReg);
    7721         IEM_MC_ENDIF();
     7721        } IEM_MC_ENDIF();
    77227722
    77237723        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    77457745    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    77467746    IEM_MC_PREPARE_FPU_USAGE();
    7747     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     7747    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    77487748        IEM_MC_CALL_FPU_AIMPL_2(pfnAImpl, pFpuRes, pr80Value);
    77497749        IEM_MC_STORE_FPU_RESULT(FpuRes, 0);
    7750     IEM_MC_ELSE()
     7750    } IEM_MC_ELSE() {
    77517751        IEM_MC_FPU_STACK_UNDERFLOW(0);
    7752     IEM_MC_ENDIF();
     7752    } IEM_MC_ENDIF();
    77537753    IEM_MC_ADVANCE_RIP_AND_FINISH();
    77547754
    … …  
    77877787    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    77887788    IEM_MC_PREPARE_FPU_USAGE();
    7789     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     7789    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    77907790        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_ftst_r80, pu16Fsw, pr80Value);
    77917791        IEM_MC_UPDATE_FSW(u16Fsw);
    7792     IEM_MC_ELSE()
     7792    } IEM_MC_ELSE() {
    77937793        IEM_MC_FPU_STACK_UNDERFLOW(UINT8_MAX);
    7794     IEM_MC_ENDIF();
     7794    } IEM_MC_ENDIF();
    77957795    IEM_MC_ADVANCE_RIP_AND_FINISH();
    77967796
    … …  
    78387838    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    78397839    IEM_MC_PREPARE_FPU_USAGE();
    7840     IEM_MC_IF_FPUREG_IS_EMPTY(7)
     7840    IEM_MC_IF_FPUREG_IS_EMPTY(7) {
    78417841        IEM_MC_CALL_FPU_AIMPL_1(pfnAImpl, pFpuRes);
    78427842        IEM_MC_PUSH_FPU_RESULT(FpuRes);
    7843     IEM_MC_ELSE()
     7843    } IEM_MC_ELSE() {
    78447844        IEM_MC_FPU_STACK_PUSH_OVERFLOW();
    7845     IEM_MC_ENDIF();
     7845    } IEM_MC_ENDIF();
    78467846    IEM_MC_ADVANCE_RIP_AND_FINISH();
    78477847
    … …  
    79407940
    79417941    IEM_MC_PREPARE_FPU_USAGE();
    7942     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, IEM_GET_MODRM_RM_8(bRm), pr80Value2, 0)
     7942    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, IEM_GET_MODRM_RM_8(bRm), pr80Value2, 0) {
    79437943        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pr80Value2);
    79447944        IEM_MC_STORE_FPU_RESULT_THEN_POP(FpuRes, IEM_GET_MODRM_RM_8(bRm));
    7945     IEM_MC_ELSE()
     7945    } IEM_MC_ELSE() {
    79467946        IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP(IEM_GET_MODRM_RM_8(bRm));
    7947     IEM_MC_ENDIF();
     7947    } IEM_MC_ENDIF();
    79487948    IEM_MC_ADVANCE_RIP_AND_FINISH();
    79497949
    … …  
    79787978    IEM_MC_MAYBE_RAISE_FPU_XCPT();
    79797979    IEM_MC_PREPARE_FPU_USAGE();
    7980     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     7980    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    79817981        IEM_MC_CALL_FPU_AIMPL_2(pfnAImpl, pFpuResTwo, pr80Value);
    79827982        IEM_MC_PUSH_FPU_RESULT_TWO(FpuResTwo);
    7983     IEM_MC_ELSE()
     7983    } IEM_MC_ELSE() {
    79847984        IEM_MC_FPU_STACK_PUSH_UNDERFLOW_TWO();
    7985     IEM_MC_ENDIF();
     7985    } IEM_MC_ENDIF();
    79867986    IEM_MC_ADVANCE_RIP_AND_FINISH();
    79877987
    … …  
    82298229
    82308230    IEM_MC_PREPARE_FPU_USAGE();
    8231     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0)
    8232         IEM_MC_IF_EFL_BIT_SET(X86_EFL_CF)
     8231    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0) {
     8232        IEM_MC_IF_EFL_BIT_SET(X86_EFL_CF) {
    82338233            IEM_MC_STORE_FPUREG_R80_SRC_REF(0, pr80ValueN);
    8234         IEM_MC_ENDIF();
     8234        } IEM_MC_ENDIF();
    82358235        IEM_MC_UPDATE_FPU_OPCODE_IP();
    8236     IEM_MC_ELSE()
     8236    } IEM_MC_ELSE() {
    82378237        IEM_MC_FPU_STACK_UNDERFLOW(0);
    8238     IEM_MC_ENDIF();
     8238    } IEM_MC_ENDIF();
    82398239    IEM_MC_ADVANCE_RIP_AND_FINISH();
    82408240
    … …  
    82568256
    82578257    IEM_MC_PREPARE_FPU_USAGE();
    8258     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0)
    8259         IEM_MC_IF_EFL_BIT_SET(X86_EFL_ZF)
     8258    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0) {
     8259        IEM_MC_IF_EFL_BIT_SET(X86_EFL_ZF) {
    82608260            IEM_MC_STORE_FPUREG_R80_SRC_REF(0, pr80ValueN);
    8261         IEM_MC_ENDIF();
     8261        } IEM_MC_ENDIF();
    82628262        IEM_MC_UPDATE_FPU_OPCODE_IP();
    8263     IEM_MC_ELSE()
     8263    } IEM_MC_ELSE() {
    82648264        IEM_MC_FPU_STACK_UNDERFLOW(0);
    8265     IEM_MC_ENDIF();
     8265    } IEM_MC_ENDIF();
    82668266    IEM_MC_ADVANCE_RIP_AND_FINISH();
    82678267
    … …  
    82838283
    82848284    IEM_MC_PREPARE_FPU_USAGE();
    8285     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0)
    8286         IEM_MC_IF_EFL_ANY_BITS_SET(X86_EFL_CF | X86_EFL_ZF)
     8285    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0) {
     8286        IEM_MC_IF_EFL_ANY_BITS_SET(X86_EFL_CF | X86_EFL_ZF) {
    82878287            IEM_MC_STORE_FPUREG_R80_SRC_REF(0, pr80ValueN);
    8288         IEM_MC_ENDIF();
     8288        } IEM_MC_ENDIF();
    82898289        IEM_MC_UPDATE_FPU_OPCODE_IP();
    8290     IEM_MC_ELSE()
     8290    } IEM_MC_ELSE() {
    82918291        IEM_MC_FPU_STACK_UNDERFLOW(0);
    8292     IEM_MC_ENDIF();
     8292    } IEM_MC_ENDIF();
    82938293    IEM_MC_ADVANCE_RIP_AND_FINISH();
    82948294
    … …  
    83108310
    83118311    IEM_MC_PREPARE_FPU_USAGE();
    8312     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0)
    8313         IEM_MC_IF_EFL_BIT_SET(X86_EFL_PF)
     8312    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0) {
     8313        IEM_MC_IF_EFL_BIT_SET(X86_EFL_PF) {
    83148314            IEM_MC_STORE_FPUREG_R80_SRC_REF(0, pr80ValueN);
    8315         IEM_MC_ENDIF();
     8315        } IEM_MC_ENDIF();
    83168316        IEM_MC_UPDATE_FPU_OPCODE_IP();
    8317     IEM_MC_ELSE()
     8317    } IEM_MC_ELSE() {
    83188318        IEM_MC_FPU_STACK_UNDERFLOW(0);
    8319     IEM_MC_ENDIF();
     8319    } IEM_MC_ENDIF();
    83208320    IEM_MC_ADVANCE_RIP_AND_FINISH();
    83218321
    … …  
    83448344
    83458345    IEM_MC_PREPARE_FPU_USAGE();
    8346     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, 1)
     8346    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, 0, pr80Value2, 1) {
    83478347        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pu16Fsw, pr80Value1, pr80Value2);
    83488348        IEM_MC_UPDATE_FSW_THEN_POP_POP(u16Fsw);
    8349     IEM_MC_ELSE()
     8349    } IEM_MC_ELSE() {
    83508350        IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP_POP();
    8351     IEM_MC_ENDIF();
     8351    } IEM_MC_ENDIF();
    83528352    IEM_MC_ADVANCE_RIP_AND_FINISH();
    83538353
    … …  
    83898389
    83908390    IEM_MC_PREPARE_FPU_USAGE();
    8391     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     8391    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    83928392        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pi32Val2);
    83938393        IEM_MC_STORE_FPU_RESULT(FpuRes, 0);
    8394     IEM_MC_ELSE()
     8394    } IEM_MC_ELSE() {
    83958395        IEM_MC_FPU_STACK_UNDERFLOW(0);
    8396     IEM_MC_ENDIF();
     8396    } IEM_MC_ENDIF();
    83978397    IEM_MC_ADVANCE_RIP_AND_FINISH();
    83988398
    … …  
    84388438
    84398439    IEM_MC_PREPARE_FPU_USAGE();
    8440     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     8440    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    84418441        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i32, pu16Fsw, pr80Value1, pi32Val2);
    84428442        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    8443     IEM_MC_ELSE()
     8443    } IEM_MC_ELSE() {
    84448444        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    8445     IEM_MC_ENDIF();
     8445    } IEM_MC_ENDIF();
    84468446    IEM_MC_ADVANCE_RIP_AND_FINISH();
    84478447
    … …  
    84718471
    84728472    IEM_MC_PREPARE_FPU_USAGE();
    8473     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     8473    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    84748474        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i32, pu16Fsw, pr80Value1, pi32Val2);
    84758475        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    8476     IEM_MC_ELSE()
     8476    } IEM_MC_ELSE() {
    84778477        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    8478     IEM_MC_ENDIF();
     8478    } IEM_MC_ENDIF();
    84798479    IEM_MC_ADVANCE_RIP_AND_FINISH();
    84808480
    … …  
    85788578
    85798579    IEM_MC_PREPARE_FPU_USAGE();
    8580     IEM_MC_IF_FPUREG_IS_EMPTY(7)
     8580    IEM_MC_IF_FPUREG_IS_EMPTY(7) {
    85818581        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fild_r80_from_i32, pFpuRes, pi32Val);
    85828582        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    8583     IEM_MC_ELSE()
     8583    } IEM_MC_ELSE() {
    85848584        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    8585     IEM_MC_ENDIF();
     8585    } IEM_MC_ENDIF();
    85868586    IEM_MC_ADVANCE_RIP_AND_FINISH();
    85878587
    … …  
    86088608    IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    86098609    IEM_MC_PREPARE_FPU_USAGE();
    8610     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     8610    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    86118611        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fistt_r80_to_i32, pu16Fsw, pi32Dst, pr80Value);
    86128612        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi32Dst, IEM_ACCESS_DATA_W, u16Fsw);
    86138613        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    8614     IEM_MC_ELSE()
    8615         IEM_MC_IF_FCW_IM()
     8614    } IEM_MC_ELSE() {
     8615        IEM_MC_IF_FCW_IM() {
    86168616            IEM_MC_STORE_MEM_I32_CONST_BY_REF(pi32Dst, INT32_MIN /* (integer indefinite) */);
    86178617            IEM_MC_MEM_COMMIT_AND_UNMAP(pi32Dst, IEM_ACCESS_DATA_W);
    8618         IEM_MC_ENDIF();
     8618        } IEM_MC_ENDIF();
    86198619        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    8620     IEM_MC_ENDIF();
     8620    } IEM_MC_ENDIF();
    86218621    IEM_MC_ADVANCE_RIP_AND_FINISH();
    86228622
    … …  
    86438643    IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    86448644    IEM_MC_PREPARE_FPU_USAGE();
    8645     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     8645    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    86468646        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i32, pu16Fsw, pi32Dst, pr80Value);
    86478647        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi32Dst, IEM_ACCESS_DATA_W, u16Fsw);
    86488648        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    8649     IEM_MC_ELSE()
    8650         IEM_MC_IF_FCW_IM()
     8649    } IEM_MC_ELSE() {
     8650        IEM_MC_IF_FCW_IM() {
    86518651            IEM_MC_STORE_MEM_I32_CONST_BY_REF(pi32Dst, INT32_MIN /* (integer indefinite) */);
    86528652            IEM_MC_MEM_COMMIT_AND_UNMAP(pi32Dst, IEM_ACCESS_DATA_W);
    8653         IEM_MC_ENDIF();
     8653        } IEM_MC_ENDIF();
    86548654        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    8655     IEM_MC_ENDIF();
     8655    } IEM_MC_ENDIF();
    86568656    IEM_MC_ADVANCE_RIP_AND_FINISH();
    86578657
    … …  
    86788678    IEM_MC_MEM_MAP(pi32Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    86798679    IEM_MC_PREPARE_FPU_USAGE();
    8680     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     8680    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    86818681        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i32, pu16Fsw, pi32Dst, pr80Value);
    86828682        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi32Dst, IEM_ACCESS_DATA_W, u16Fsw);
    86838683        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    8684     IEM_MC_ELSE()
    8685         IEM_MC_IF_FCW_IM()
     8684    } IEM_MC_ELSE() {
     8685        IEM_MC_IF_FCW_IM() {
    86868686            IEM_MC_STORE_MEM_I32_CONST_BY_REF(pi32Dst, INT32_MIN /* (integer indefinite) */);
    86878687            IEM_MC_MEM_COMMIT_AND_UNMAP(pi32Dst, IEM_ACCESS_DATA_W);
    8688         IEM_MC_ENDIF();
     8688        } IEM_MC_ENDIF();
    86898689        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    8690     IEM_MC_ENDIF();
     8690    } IEM_MC_ENDIF();
    86918691    IEM_MC_ADVANCE_RIP_AND_FINISH();
    86928692
    … …  
    87158715
    87168716    IEM_MC_PREPARE_FPU_USAGE();
    8717     IEM_MC_IF_FPUREG_IS_EMPTY(7)
     8717    IEM_MC_IF_FPUREG_IS_EMPTY(7) {
    87188718        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r80_from_r80, pFpuRes, pr80Val);
    87198719        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    8720     IEM_MC_ELSE()
     8720    } IEM_MC_ELSE() {
    87218721        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    8722     IEM_MC_ENDIF();
     8722    } IEM_MC_ENDIF();
    87238723    IEM_MC_ADVANCE_RIP_AND_FINISH();
    87248724
    … …  
    87458745    IEM_MC_MEM_MAP_EX(pr80Dst, IEM_ACCESS_DATA_W, sizeof(*pr80Dst), pVCpu->iem.s.iEffSeg, GCPtrEffDst, 7 /*cbAlign*/, 1 /*arg*/);
    87468746    IEM_MC_PREPARE_FPU_USAGE();
    8747     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     8747    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    87488748        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r80, pu16Fsw, pr80Dst, pr80Value);
    87498749        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pr80Dst, IEM_ACCESS_DATA_W, u16Fsw);
    87508750        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    8751     IEM_MC_ELSE()
    8752         IEM_MC_IF_FCW_IM()
     8751    } IEM_MC_ELSE() {
     8752        IEM_MC_IF_FCW_IM() {
    87538753            IEM_MC_STORE_MEM_NEG_QNAN_R80_BY_REF(pr80Dst);
    87548754            IEM_MC_MEM_COMMIT_AND_UNMAP(pr80Dst, IEM_ACCESS_DATA_W);
    8755         IEM_MC_ENDIF();
     8755        } IEM_MC_ENDIF();
    87568756        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    8757     IEM_MC_ENDIF();
     8757    } IEM_MC_ENDIF();
    87588758    IEM_MC_ADVANCE_RIP_AND_FINISH();
    87598759
    … …  
    87758775
    87768776    IEM_MC_PREPARE_FPU_USAGE();
    8777     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0)
    8778         IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_CF)
     8777    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0) {
     8778        IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_CF) {
    87798779            IEM_MC_STORE_FPUREG_R80_SRC_REF(0, pr80ValueN);
    8780         IEM_MC_ENDIF();
     8780        } IEM_MC_ENDIF();
    87818781        IEM_MC_UPDATE_FPU_OPCODE_IP();
    8782     IEM_MC_ELSE()
     8782    } IEM_MC_ELSE() {
    87838783        IEM_MC_FPU_STACK_UNDERFLOW(0);
    8784     IEM_MC_ENDIF();
     8784    } IEM_MC_ENDIF();
    87858785    IEM_MC_ADVANCE_RIP_AND_FINISH();
    87868786
    … …  
    88028802
    88038803    IEM_MC_PREPARE_FPU_USAGE();
    8804     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0)
    8805         IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF)
     8804    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0) {
     8805        IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF) {
    88068806            IEM_MC_STORE_FPUREG_R80_SRC_REF(0, pr80ValueN);
    8807         IEM_MC_ENDIF();
     8807        } IEM_MC_ENDIF();
    88088808        IEM_MC_UPDATE_FPU_OPCODE_IP();
    8809     IEM_MC_ELSE()
     8809    } IEM_MC_ELSE() {
    88108810        IEM_MC_FPU_STACK_UNDERFLOW(0);
    8811     IEM_MC_ENDIF();
     8811    } IEM_MC_ENDIF();
    88128812    IEM_MC_ADVANCE_RIP_AND_FINISH();
    88138813
    … …  
    88298829
    88308830    IEM_MC_PREPARE_FPU_USAGE();
    8831     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0)
    8832         IEM_MC_IF_EFL_NO_BITS_SET(X86_EFL_CF | X86_EFL_ZF)
     8831    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0) {
     8832        IEM_MC_IF_EFL_NO_BITS_SET(X86_EFL_CF | X86_EFL_ZF) {
    88338833            IEM_MC_STORE_FPUREG_R80_SRC_REF(0, pr80ValueN);
    8834         IEM_MC_ENDIF();
     8834        } IEM_MC_ENDIF();
    88358835        IEM_MC_UPDATE_FPU_OPCODE_IP();
    8836     IEM_MC_ELSE()
     8836    } IEM_MC_ELSE() {
    88378837        IEM_MC_FPU_STACK_UNDERFLOW(0);
    8838     IEM_MC_ENDIF();
     8838    } IEM_MC_ENDIF();
    88398839    IEM_MC_ADVANCE_RIP_AND_FINISH();
    88408840
    … …  
    88568856
    88578857    IEM_MC_PREPARE_FPU_USAGE();
    8858     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0)
    8859         IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_PF)
     8858    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST(pr80ValueN, IEM_GET_MODRM_RM_8(bRm), 0) {
     8859        IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_PF) {
    88608860            IEM_MC_STORE_FPUREG_R80_SRC_REF(0, pr80ValueN);
    8861         IEM_MC_ENDIF();
     8861        } IEM_MC_ENDIF();
    88628862        IEM_MC_UPDATE_FPU_OPCODE_IP();
    8863     IEM_MC_ELSE()
     8863    } IEM_MC_ELSE() {
    88648864        IEM_MC_FPU_STACK_UNDERFLOW(0);
    8865     IEM_MC_ENDIF();
     8865    } IEM_MC_ENDIF();
    88668866    IEM_MC_ADVANCE_RIP_AND_FINISH();
    88678867
    … …  
    90379037
    90389038    IEM_MC_PREPARE_FPU_USAGE();
    9039     IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, IEM_GET_MODRM_RM_8(bRm), pr80Value2, 0)
     9039    IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80(pr80Value1, IEM_GET_MODRM_RM_8(bRm), pr80Value2, 0) {
    90409040        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pr80Value2);
    90419041        IEM_MC_STORE_FPU_RESULT(FpuRes, IEM_GET_MODRM_RM_8(bRm));
    9042     IEM_MC_ELSE()
     9042    } IEM_MC_ELSE() {
    90439043        IEM_MC_FPU_STACK_UNDERFLOW(IEM_GET_MODRM_RM_8(bRm));
    9044     IEM_MC_ENDIF();
     9044    } IEM_MC_ENDIF();
    90459045    IEM_MC_ADVANCE_RIP_AND_FINISH();
    90469046
    … …  
    91219121    IEM_MC_FETCH_MEM_R64(r64Factor2, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    91229122    IEM_MC_PREPARE_FPU_USAGE();
    9123     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Factor1, 0)
     9123    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Factor1, 0) {
    91249124        IEM_MC_CALL_FPU_AIMPL_3(pfnImpl, pFpuRes, pr80Factor1, pr64Factor2);
    91259125        IEM_MC_STORE_FPU_RESULT_MEM_OP(FpuRes, 0, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9126     IEM_MC_ELSE()
     9126    } IEM_MC_ELSE() {
    91279127        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(0, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9128     IEM_MC_ENDIF();
     9128    } IEM_MC_ENDIF();
    91299129    IEM_MC_ADVANCE_RIP_AND_FINISH();
    91309130
    … …  
    91709170
    91719171    IEM_MC_PREPARE_FPU_USAGE();
    9172     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     9172    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    91739173        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r64, pu16Fsw, pr80Value1, pr64Val2);
    91749174        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9175     IEM_MC_ELSE()
     9175    } IEM_MC_ELSE() {
    91769176        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9177     IEM_MC_ENDIF();
     9177    } IEM_MC_ENDIF();
    91789178    IEM_MC_ADVANCE_RIP_AND_FINISH();
    91799179
    … …  
    92039203
    92049204    IEM_MC_PREPARE_FPU_USAGE();
    9205     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     9205    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    92069206        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fcom_r80_by_r64, pu16Fsw, pr80Value1, pr64Val2);
    92079207        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9208     IEM_MC_ELSE()
     9208    } IEM_MC_ELSE() {
    92099209        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9210     IEM_MC_ENDIF();
     9210    } IEM_MC_ENDIF();
    92119211    IEM_MC_ADVANCE_RIP_AND_FINISH();
    92129212
    … …  
    93079307    IEM_MC_FETCH_MEM_R64(r64Val, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    93089308    IEM_MC_PREPARE_FPU_USAGE();
    9309     IEM_MC_IF_FPUREG_IS_EMPTY(7)
     9309    IEM_MC_IF_FPUREG_IS_EMPTY(7) {
    93109310        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r80_from_r64, pFpuRes, pr64Val);
    93119311        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9312     IEM_MC_ELSE()
     9312    } IEM_MC_ELSE() {
    93139313        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9314     IEM_MC_ENDIF();
     9314    } IEM_MC_ENDIF();
    93159315    IEM_MC_ADVANCE_RIP_AND_FINISH();
    93169316
    … …  
    93379337    IEM_MC_MEM_MAP(pi64Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    93389338    IEM_MC_PREPARE_FPU_USAGE();
    9339     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     9339    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    93409340        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fistt_r80_to_i64, pu16Fsw, pi64Dst, pr80Value);
    93419341        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi64Dst, IEM_ACCESS_DATA_W, u16Fsw);
    93429342        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    9343     IEM_MC_ELSE()
    9344         IEM_MC_IF_FCW_IM()
     9343    } IEM_MC_ELSE() {
     9344        IEM_MC_IF_FCW_IM() {
    93459345            IEM_MC_STORE_MEM_I64_CONST_BY_REF(pi64Dst, INT64_MIN /* (integer indefinite) */);
    93469346            IEM_MC_MEM_COMMIT_AND_UNMAP(pi64Dst, IEM_ACCESS_DATA_W);
    9347         IEM_MC_ENDIF();
     9347        } IEM_MC_ENDIF();
    93489348        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    9349     IEM_MC_ENDIF();
     9349    } IEM_MC_ENDIF();
    93509350    IEM_MC_ADVANCE_RIP_AND_FINISH();
    93519351
    … …  
    93729372    IEM_MC_MEM_MAP(pr64Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    93739373    IEM_MC_PREPARE_FPU_USAGE();
    9374     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     9374    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    93759375        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r64, pu16Fsw, pr64Dst, pr80Value);
    93769376        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pr64Dst, IEM_ACCESS_DATA_W, u16Fsw);
    93779377        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    9378     IEM_MC_ELSE()
    9379         IEM_MC_IF_FCW_IM()
     9378    } IEM_MC_ELSE() {
     9379        IEM_MC_IF_FCW_IM() {
    93809380            IEM_MC_STORE_MEM_NEG_QNAN_R64_BY_REF(pr64Dst);
    93819381            IEM_MC_MEM_COMMIT_AND_UNMAP(pr64Dst, IEM_ACCESS_DATA_W);
    9382         IEM_MC_ENDIF();
     9382        } IEM_MC_ENDIF();
    93839383        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    9384     IEM_MC_ENDIF();
     9384    } IEM_MC_ENDIF();
    93859385    IEM_MC_ADVANCE_RIP_AND_FINISH();
    93869386
    … …  
    94099409    IEM_MC_MEM_MAP(pr64Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    94109410    IEM_MC_PREPARE_FPU_USAGE();
    9411     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     9411    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    94129412        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_r64, pu16Fsw, pr64Dst, pr80Value);
    94139413        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pr64Dst, IEM_ACCESS_DATA_W, u16Fsw);
    94149414        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    9415     IEM_MC_ELSE()
    9416         IEM_MC_IF_FCW_IM()
     9415    } IEM_MC_ELSE() {
     9416        IEM_MC_IF_FCW_IM() {
    94179417            IEM_MC_STORE_MEM_NEG_QNAN_R64_BY_REF(pr64Dst);
    94189418            IEM_MC_MEM_COMMIT_AND_UNMAP(pr64Dst, IEM_ACCESS_DATA_W);
    9419         IEM_MC_ENDIF();
     9419        } IEM_MC_ENDIF();
    94209420        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    9421     IEM_MC_ENDIF();
     9421    } IEM_MC_ENDIF();
    94229422    IEM_MC_ADVANCE_RIP_AND_FINISH();
    94239423
    … …  
    95219521
    95229522    IEM_MC_PREPARE_FPU_USAGE();
    9523     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     9523    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    95249524        IEM_MC_SET_FPU_RESULT(FpuRes, 0 /*FSW*/, pr80Value);
    95259525        IEM_MC_STORE_FPU_RESULT(FpuRes, IEM_GET_MODRM_RM_8(bRm));
    9526     IEM_MC_ELSE()
     9526    } IEM_MC_ELSE() {
    95279527        IEM_MC_FPU_STACK_UNDERFLOW(IEM_GET_MODRM_RM_8(bRm));
    9528     IEM_MC_ENDIF();
     9528    } IEM_MC_ENDIF();
    95299529
    95309530    IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    96709670
    96719671    IEM_MC_PREPARE_FPU_USAGE();
    9672     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     9672    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    96739673        IEM_MC_CALL_FPU_AIMPL_3(pfnAImpl, pFpuRes, pr80Value1, pi16Val2);
    96749674        IEM_MC_STORE_FPU_RESULT(FpuRes, 0);
    9675     IEM_MC_ELSE()
     9675    } IEM_MC_ELSE() {
    96769676        IEM_MC_FPU_STACK_UNDERFLOW(0);
    9677     IEM_MC_ENDIF();
     9677    } IEM_MC_ENDIF();
    96789678    IEM_MC_ADVANCE_RIP_AND_FINISH();
    96799679
    … …  
    97199719
    97209720    IEM_MC_PREPARE_FPU_USAGE();
    9721     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     9721    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    97229722        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i16, pu16Fsw, pr80Value1, pi16Val2);
    97239723        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9724     IEM_MC_ELSE()
     9724    } IEM_MC_ELSE() {
    97259725        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9726     IEM_MC_ENDIF();
     9726    } IEM_MC_ENDIF();
    97279727    IEM_MC_ADVANCE_RIP_AND_FINISH();
    97289728
    … …  
    97529752
    97539753    IEM_MC_PREPARE_FPU_USAGE();
    9754     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0)
     9754    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value1, 0) {
    97559755        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_ficom_r80_by_i16, pu16Fsw, pr80Value1, pi16Val2);
    97569756        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9757     IEM_MC_ELSE()
     9757    } IEM_MC_ELSE() {
    97589758        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9759     IEM_MC_ENDIF();
     9759    } IEM_MC_ENDIF();
    97609760    IEM_MC_ADVANCE_RIP_AND_FINISH();
    97619761
    … …  
    99139913
    99149914    IEM_MC_PREPARE_FPU_USAGE();
    9915     IEM_MC_IF_FPUREG_IS_EMPTY(7)
     9915    IEM_MC_IF_FPUREG_IS_EMPTY(7) {
    99169916        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fild_r80_from_i16, pFpuRes, pi16Val);
    99179917        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9918     IEM_MC_ELSE()
     9918    } IEM_MC_ELSE() {
    99199919        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    9920     IEM_MC_ENDIF();
     9920    } IEM_MC_ENDIF();
    99219921    IEM_MC_ADVANCE_RIP_AND_FINISH();
    99229922
    … …  
    99439943    IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    99449944    IEM_MC_PREPARE_FPU_USAGE();
    9945     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     9945    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    99469946        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fistt_r80_to_i16, pu16Fsw, pi16Dst, pr80Value);
    99479947        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi16Dst, IEM_ACCESS_DATA_W, u16Fsw);
    99489948        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    9949     IEM_MC_ELSE()
    9950         IEM_MC_IF_FCW_IM()
     9949    } IEM_MC_ELSE() {
     9950        IEM_MC_IF_FCW_IM() {
    99519951            IEM_MC_STORE_MEM_I16_CONST_BY_REF(pi16Dst, INT16_MIN /* (integer indefinite) */);
    99529952            IEM_MC_MEM_COMMIT_AND_UNMAP(pi16Dst, IEM_ACCESS_DATA_W);
    9953         IEM_MC_ENDIF();
     9953        } IEM_MC_ENDIF();
    99549954        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    9955     IEM_MC_ENDIF();
     9955    } IEM_MC_ENDIF();
    99569956    IEM_MC_ADVANCE_RIP_AND_FINISH();
    99579957
    … …  
    99789978    IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    99799979    IEM_MC_PREPARE_FPU_USAGE();
    9980     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     9980    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    99819981        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i16, pu16Fsw, pi16Dst, pr80Value);
    99829982        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi16Dst, IEM_ACCESS_DATA_W, u16Fsw);
    99839983        IEM_MC_UPDATE_FSW_WITH_MEM_OP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    9984     IEM_MC_ELSE()
    9985         IEM_MC_IF_FCW_IM()
     9984    } IEM_MC_ELSE() {
     9985        IEM_MC_IF_FCW_IM() {
    99869986            IEM_MC_STORE_MEM_I16_CONST_BY_REF(pi16Dst, INT16_MIN /* (integer indefinite) */);
    99879987            IEM_MC_MEM_COMMIT_AND_UNMAP(pi16Dst, IEM_ACCESS_DATA_W);
    9988         IEM_MC_ENDIF();
     9988        } IEM_MC_ENDIF();
    99899989        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    9990     IEM_MC_ENDIF();
     9990    } IEM_MC_ENDIF();
    99919991    IEM_MC_ADVANCE_RIP_AND_FINISH();
    99929992
    … …  
    1001310013    IEM_MC_MEM_MAP(pi16Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1001410014    IEM_MC_PREPARE_FPU_USAGE();
    10015     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     10015    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    1001610016        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i16, pu16Fsw, pi16Dst, pr80Value);
    1001710017        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi16Dst, IEM_ACCESS_DATA_W, u16Fsw);
    1001810018        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    10019     IEM_MC_ELSE()
    10020         IEM_MC_IF_FCW_IM()
     10019    } IEM_MC_ELSE() {
     10020        IEM_MC_IF_FCW_IM() {
    1002110021            IEM_MC_STORE_MEM_I16_CONST_BY_REF(pi16Dst, INT16_MIN /* (integer indefinite) */);
    1002210022            IEM_MC_MEM_COMMIT_AND_UNMAP(pi16Dst, IEM_ACCESS_DATA_W);
    10023         IEM_MC_ENDIF();
     10023        } IEM_MC_ENDIF();
    1002410024        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    10025     IEM_MC_ENDIF();
     10025    } IEM_MC_ENDIF();
    1002610026    IEM_MC_ADVANCE_RIP_AND_FINISH();
    1002710027
    … …  
    1005010050
    1005110051    IEM_MC_PREPARE_FPU_USAGE();
    10052     IEM_MC_IF_FPUREG_IS_EMPTY(7)
     10052    IEM_MC_IF_FPUREG_IS_EMPTY(7) {
    1005310053        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fld_r80_from_d80, pFpuRes, pd80Val);
    1005410054        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    10055     IEM_MC_ELSE()
     10055    } IEM_MC_ELSE() {
    1005610056        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    10057     IEM_MC_ENDIF();
     10057    } IEM_MC_ENDIF();
    1005810058    IEM_MC_ADVANCE_RIP_AND_FINISH();
    1005910059
    … …  
    1008210082
    1008310083    IEM_MC_PREPARE_FPU_USAGE();
    10084     IEM_MC_IF_FPUREG_IS_EMPTY(7)
     10084    IEM_MC_IF_FPUREG_IS_EMPTY(7) {
    1008510085        IEM_MC_CALL_FPU_AIMPL_2(iemAImpl_fild_r80_from_i64, pFpuRes, pi64Val);
    1008610086        IEM_MC_PUSH_FPU_RESULT_MEM_OP(FpuRes, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    10087     IEM_MC_ELSE()
     10087    } IEM_MC_ELSE() {
    1008810088        IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP(pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
    10089     IEM_MC_ENDIF();
     10089    } IEM_MC_ENDIF();
    1009010090    IEM_MC_ADVANCE_RIP_AND_FINISH();
    1009110091
    … …  
    1011210112    IEM_MC_MEM_MAP_EX(pd80Dst, IEM_ACCESS_DATA_W, sizeof(*pd80Dst), pVCpu->iem.s.iEffSeg, GCPtrEffDst, 7 /*cbAlign*/, 1 /*arg*/);
    1011310113    IEM_MC_PREPARE_FPU_USAGE();
    10114     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     10114    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    1011510115        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fst_r80_to_d80, pu16Fsw, pd80Dst, pr80Value);
    1011610116        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pd80Dst, IEM_ACCESS_DATA_W, u16Fsw);
    1011710117        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    10118     IEM_MC_ELSE()
    10119         IEM_MC_IF_FCW_IM()
     10118    } IEM_MC_ELSE() {
     10119        IEM_MC_IF_FCW_IM() {
    1012010120            IEM_MC_STORE_MEM_INDEF_D80_BY_REF(pd80Dst);
    1012110121            IEM_MC_MEM_COMMIT_AND_UNMAP(pd80Dst, IEM_ACCESS_DATA_W);
    10122         IEM_MC_ENDIF();
     10122        } IEM_MC_ENDIF();
    1012310123        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    10124     IEM_MC_ENDIF();
     10124    } IEM_MC_ENDIF();
    1012510125    IEM_MC_ADVANCE_RIP_AND_FINISH();
    1012610126
    … …  
    1014710147    IEM_MC_MEM_MAP(pi64Dst, IEM_ACCESS_DATA_W, pVCpu->iem.s.iEffSeg, GCPtrEffDst, 1 /*arg*/);
    1014810148    IEM_MC_PREPARE_FPU_USAGE();
    10149     IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0)
     10149    IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80(pr80Value, 0) {
    1015010150        IEM_MC_CALL_FPU_AIMPL_3(iemAImpl_fist_r80_to_i64, pu16Fsw, pi64Dst, pr80Value);
    1015110151        IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE(pi64Dst, IEM_ACCESS_DATA_W, u16Fsw);
    1015210152        IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP(u16Fsw, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    10153     IEM_MC_ELSE()
    10154         IEM_MC_IF_FCW_IM()
     10153    } IEM_MC_ELSE() {
     10154        IEM_MC_IF_FCW_IM() {
    1015510155            IEM_MC_STORE_MEM_I64_CONST_BY_REF(pi64Dst, INT64_MIN /* (integer indefinite) */);
    1015610156            IEM_MC_MEM_COMMIT_AND_UNMAP(pi64Dst, IEM_ACCESS_DATA_W);
    10157         IEM_MC_ENDIF();
     10157        } IEM_MC_ENDIF();
    1015810158        IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP(UINT8_MAX, pVCpu->iem.s.iEffSeg, GCPtrEffDst);
    10159     IEM_MC_ENDIF();
     10159    } IEM_MC_ENDIF();
    1016010160    IEM_MC_ADVANCE_RIP_AND_FINISH();
    1016110161

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

    r98873 r98880  
    17401740
    17411741
     1742class McStmt(object):
     1743    """
     1744    Statement in a microcode block.
     1745    """
     1746
     1747    def __init__(self, sName, asParams):
     1748        self.sName    = sName;     ##< 'IEM_MC_XXX' or 'C++'.
     1749        self.asParams = asParams;
     1750        self.oUser    = None;
     1751
     1752    def renderCode(self, cchIndent = 0):
     1753        """
     1754        Renders the code for the statement.
     1755        """
     1756        return ' ' * cchIndent + self.sName + '(' + ', '.join(self.asParams) + ');';
     1757
     1758class McStmtCond(McStmt):
     1759    """ Base class for conditional statements (IEM_MC_IF_XXX). """
     1760
     1761    def __init__(self, sName, asParams):
     1762        McStmt.__init__(self, sName, asParams);
     1763        self.aoIfBranch     = [];
     1764        self.aoElseBranch   = [];
     1765
     1766    def renderCode(self, cchIndent = 0):
     1767        sRet  = ' ' * cchIndent + self.sName + '(' + ', '.join(self.asParams) + ') {\n';
     1768        for oStmt in self.aoIfBranch:
     1769            sRet += oStmt.renderCode(cchIndent + 4);
     1770        if self.aoElseBranch:
     1771            sRet += ' ' * cchIndent + '} IEM_MC_ELSE() {\n';
     1772            for oStmt in self.aoElseBranch:
     1773                sRet += oStmt.renderCode(cchIndent + 4);
     1774        sRet += ' ' * cchIndent + '} IEM_MC_ENDIF();';
     1775        return sRet;
     1776
     1777class McCppGeneric(McStmt):
     1778    """
     1779    Generic C++/C statement.
     1780    """
     1781
     1782    def __init__(self, sCode):
     1783        McStmt.__init__(self, 'C++', [sCode,]);
     1784
     1785    def renderCode(self, cchIndent = 0):
     1786        return ' ' * cchIndent + self.asParams[0];
     1787
     1788#class McLocalVar(McStmt):
     1789#
     1790#    def __init__(self, sRaw, , ):
     1791
    17421792
    17431793class McBlock(object):
    … …  
    17551805        self.iInFunction  = iInFunction;                        ##< The block number wihtin the function.
    17561806        self.asLines      = []              # type: list(str)   ##< The raw lines the block is made up of.
     1807        ## Decoded statements in the block.
     1808        self.aoStmts      = []              # type: list(McStmt)
    17571809
    17581810    def complete(self, iEndLine, offEndLine, asLines):
    … …  
    17651817        self.asLines      = asLines;
    17661818
     1819    def raiseDecodeError(self, sRawCode, off, sMessage):
     1820        """ Raises a decoding error. """
     1821        offStartOfLine = sRawCode.rfind('\n', 0, off) + 1;
     1822        iLine          = sRawCode.count('\n', 0, off);
     1823        raise ParserException('%s:%d:%d: parsing error: %s'
     1824                              % (self.sSrcFile, self.iBeginLine + iLine, off - offStartOfLine + 1, sMessage,));
     1825    @staticmethod
     1826    def parseMcGeneric(oSelf, sName, asParams):
     1827        """ Generic parser that returns a plain McStmt object. """
     1828        _ = oSelf;
     1829        return McStmt(sName, asParams);
     1830
     1831    @staticmethod
     1832    def parseMcGenericCond(oSelf, sName, asParams):
     1833        """ Generic parser that returns a plain McStmtCond object. """
     1834        _ = oSelf;
     1835        return McStmtCond(sName, asParams);
     1836
     1837    @staticmethod
     1838    def parseMcBegin(oSelf, sName, asParams):
     1839        """ IEM_MC_BEGIN """
     1840        return McBlock.parseMcGeneric(oSelf, sName, asParams);
     1841
     1842    @staticmethod
     1843    def stripComments(sCode):
     1844        """ Returns sCode with comments removed. """
     1845        off = 0;
     1846        while off < len(sCode):
     1847            off = sCode.find('/', off);
     1848            if off < 0 or off + 1 >= len(sCode):
     1849                break;
     1850
     1851            if sCode[off + 1] == '/':
     1852                # C++ comment.
     1853                offEnd = sCode.find('\n', off + 2);
     1854                if offEnd < 0:
     1855                    return sCode[:off].rstrip();
     1856                sCode = sCode[ : off] + sCode[offEnd : ];
     1857                off += 1;
     1858
     1859            elif sCode[off + 1] == '*':
     1860                # C comment
     1861                offEnd = sCode.find('*/', off + 2);
     1862                if offEnd < 0:
     1863                    return sCode[:off].rstrip();
     1864                sSep = ' ';
     1865                if (off > 0 and sCode[off - 1].isspace())  or  (offEnd + 2 < len(sCode) and sCode[offEnd + 2].isspace()):
     1866                    sSep = '';
     1867                sCode = sCode[ : off] + sSep + sCode[offEnd + 2 : ];
     1868                off += len(sSep);
     1869
     1870            else:
     1871                # Not a comment.
     1872                off += 1;
     1873        return sCode;
     1874
     1875    @staticmethod
     1876    def extractParam(sCode, offParam):
     1877        """
     1878        Extracts the parameter value at offParam in sCode.
     1879        Returns stripped value and the end offset of the terminating ',' or ')'.
     1880        """
     1881        # Extract it.
     1882        cNesting = 0;
     1883        offStart = offParam;
     1884        while offParam < len(sCode):
     1885            ch = sCode[offParam];
     1886            if ch == '(':
     1887                cNesting += 1;
     1888            elif ch == ')':
     1889                if cNesting == 0:
     1890                    break;
     1891                cNesting -= 1;
     1892            elif ch == ',' and cNesting == 0:
     1893                break;
     1894            offParam += 1;
     1895        return (sCode[offStart : offParam].strip(), offParam);
     1896
     1897    @staticmethod
     1898    def extractParams(sCode, offOpenParen):
     1899        """
     1900        Parses a parameter list.
     1901        Returns the list of parameter values and the offset of the closing parentheses.
     1902        Returns (None, len(sCode)) on if no closing parentheses was found.
     1903        """
     1904        assert sCode[offOpenParen] == '(';
     1905        asParams = [];
     1906        off      = offOpenParen + 1;
     1907        while off < len(sCode):
     1908            ch = sCode[off];
     1909            if ch.isspace():
     1910                off += 1;
     1911            elif ch != ')':
     1912                (sParam, off) = McBlock.extractParam(sCode, off);
     1913                asParams.append(sParam);
     1914                assert off < len(sCode), 'off=%s sCode=%s:"%s"' % (off, len(sCode), sCode,);
     1915                if sCode[off] == ',':
     1916                    off += 1;
     1917            else:
     1918                return (asParams, off);
     1919        return (None, off);
     1920
     1921    @staticmethod
     1922    def findClosingBraces(sCode, off, offStop):
     1923        """
     1924        Finds the matching '}' for the '{' at off in sCode.
     1925        Returns offset of the matching '}' on success, otherwise -1.
     1926
     1927        Note! Does not take comments into account.
     1928        """
     1929        cDepth = 1;
     1930        off   += 1;
     1931        while off < offStop:
     1932            offClose = sCode.find('}', off, offStop);
     1933            if offClose < 0:
     1934                break;
     1935            cDepth += sCode.count('{', off, offClose);
     1936            cDepth -= 1;
     1937            if cDepth == 0:
     1938                return offClose;
     1939            off = offClose + 1;
     1940        return -1;
     1941
     1942    @staticmethod
     1943    def countSpacesAt(sCode, off, offStop):
     1944        """ Returns the number of space characters at off in sCode. """
     1945        offStart = off;
     1946        while off < offStop and sCode[off].isspace():
     1947            off += 1;
     1948        return off - offStart;
     1949
     1950    @staticmethod
     1951    def skipSpacesAt(sCode, off, offStop):
     1952        """ Returns first offset at or after off for a non-space character. """
     1953        return off + McBlock.countSpacesAt(sCode, off, offStop);
     1954
     1955    @staticmethod
     1956    def isSubstrAt(sStr, off, sSubStr):
     1957        """ Returns true of sSubStr is found at off in sStr. """
     1958        return sStr[off : off + len(sSubStr)] == sSubStr;
     1959
     1960    def decodeCode(self, sRawCode, off = 0, offStop = -1, iLevel = 0):
     1961        """
     1962        Decodes sRawCode[off : offStop].
     1963
     1964        Returns list of McStmt instances.
     1965        Raises ParserException on failure.
     1966        """
     1967        if offStop < 0:
     1968            offStop = len(sRawCode);
     1969        aoStmts = [];
     1970        while off < offStop:
     1971            ch = sRawCode[off];
     1972
     1973            #
     1974            # Skip spaces and comments.
     1975            #
     1976            if ch.isspace():
     1977                off += 1;
     1978
     1979            elif ch == '/':
     1980                ch = sRawCode[off + 1];
     1981                if ch == '/': # C++ comment.
     1982                    off = sRawCode.find('\n', off + 2);
     1983                    if off < 0:
     1984                        break;
     1985                    off += 1;
     1986                elif ch == '*': # C comment.
     1987                    off = sRawCode.find('*/', off + 2);
     1988                    if off < 0:
     1989                        break;
     1990                    off += 2;
     1991                else:
     1992                    self.raiseDecodeError(sRawCode, off, 'Unexpected "/"');
     1993
     1994            #
     1995            # Is it a MC statement.
     1996            #
     1997            elif ch == 'I' and sRawCode[off : off + len('IEM_MC_')] == 'IEM_MC_':
     1998                # All MC statements ends with a semicolon, except for conditionals which ends with a '{'.
     1999                # Extract it and strip comments from it.
     2000                if not self.isSubstrAt(sRawCode, off, 'IEM_MC_IF_'):
     2001                    offEnd = sRawCode.find(';', off + len('IEM_MC_'));
     2002                    if offEnd <= off:
     2003                        self.raiseDecodeError(sRawCode, off, 'MC statement without a ";"');
     2004                else:
     2005                    offEnd = sRawCode.find('{', off + len('IEM_MC_IF_'));
     2006                    if offEnd <= off:
     2007                        self.raiseDecodeError(sRawCode, off, 'MC conditional statement without a "{"');
     2008                    if sRawCode.find(';', off + len('IEM_MC_IF_'), offEnd) > off:
     2009                        self.raiseDecodeError(sRawCode, off, 'MC conditional statement without an immediate "{"');
     2010                    offEnd -= 1;
     2011                    while offEnd > off and sRawCode[offEnd - 1].isspace():
     2012                        offEnd -= 1;
     2013
     2014                sRawStmt = self.stripComments(sRawCode[off : offEnd]);
     2015
     2016                # Isolate the statement name.
     2017                offOpenParen = sRawStmt.find('(');
     2018                if offOpenParen < 0:
     2019                    self.raiseDecodeError(sRawCode, off, 'MC statement without a "("');
     2020                sName = sRawStmt[: offOpenParen].strip();
     2021
     2022                # Extract the parameters.
     2023                (asParams, offCloseParen) = self.extractParams(sRawStmt, offOpenParen);
     2024                if asParams is None:
     2025                    self.raiseDecodeError(sRawCode, off, 'MC statement without a closing parenthesis');
     2026                if offCloseParen + 1 != len(sRawStmt):
     2027                    self.raiseDecodeError(sRawCode, off,
     2028                                          'Unexpected code following MC statement: %s' % (sRawStmt[offCloseParen + 1:]));
     2029
     2030                # Hand it to the handler.
     2031                fnParser = g_dMcStmtParsers.get(sName);
     2032                if not fnParser:
     2033                    self.raiseDecodeError(sRawCode, off, 'Unknown MC statement: %s' % (sName,));
     2034                oStmt = fnParser(self, sName, asParams);
     2035                aoStmts.append(oStmt);
     2036
     2037                #
     2038                # If conditional, we need to parse the whole statement.
     2039                #
     2040                # For reasons of simplicity, we assume the following structure
     2041                # and parse each branch in a recursive call:
     2042                #   IEM_MC_IF_XXX() {
     2043                #        IEM_MC_WHATEVER();
     2044                #   } IEM_MC_ELSE() {
     2045                #        IEM_MC_WHATEVER();
     2046                #   } IEM_MC_ENDIF();
     2047                #
     2048                if sName.startswith('IEM_MC_IF_'):
     2049                    if iLevel > 1:
     2050                        self.raiseDecodeError(sRawCode, off, 'Too deep nesting of conditionals.');
     2051
     2052                    # Find start of the IF block:
     2053                    offBlock1 = self.skipSpacesAt(sRawCode, offEnd, offStop);
     2054                    if sRawCode[offBlock1] != '{':
     2055                        self.raiseDecodeError(sRawCode, offBlock1, 'Expected "{" following %s' % (sName,));
     2056
     2057                    # Find the end of it.
     2058                    offBlock1End = self.findClosingBraces(sRawCode, offBlock1, offStop);
     2059                    if offBlock1End < 0:
     2060                        self.raiseDecodeError(sRawCode, offBlock1, 'No matching "}" closing IF block of %s' % (sName,));
     2061
     2062                    oStmt.aoIfBranch = self.decodeCode(sRawCode, offBlock1 + 1, offBlock1End, iLevel + 1);
     2063
     2064                    # Is there an else section?
     2065                    off = self.skipSpacesAt(sRawCode, offBlock1End + 1, offStop);
     2066                    if self.isSubstrAt(sRawCode, off, 'IEM_MC_ELSE'):
     2067                        off = self.skipSpacesAt(sRawCode, off + len('IEM_MC_ELSE'), offStop);
     2068                        if sRawCode[off] != '(':
     2069                            self.raiseDecodeError(sRawCode, off, 'Expected "(" following IEM_MC_ELSE"');
     2070                        off = self.skipSpacesAt(sRawCode, off + 1, offStop);
     2071                        if sRawCode[off] != ')':
     2072                            self.raiseDecodeError(sRawCode, off, 'Expected ")" following IEM_MC_ELSE("');
     2073
     2074                        # Find start of the ELSE block.
     2075                        offBlock2 = self.skipSpacesAt(sRawCode, off + 1, offStop);
     2076                        if sRawCode[offBlock2] != '{':
     2077                            self.raiseDecodeError(sRawCode, offBlock2, 'Expected "{" following IEM_MC_ELSE()"');
     2078
     2079                        # Find the end of it.
     2080                        offBlock2End = self.findClosingBraces(sRawCode, offBlock2, offStop);
     2081                        if offBlock2End < 0:
     2082                            self.raiseDecodeError(sRawCode, offBlock2, 'No matching "}" closing ELSE block of %s' % (sName,));
     2083
     2084                        oStmt.aoElseBranch = self.decodeCode(sRawCode, offBlock2 + 1, offBlock2End, iLevel + 1);
     2085                        off = self.skipSpacesAt(sRawCode, offBlock2End + 1, offStop);
     2086
     2087                    # Parse past the endif statement.
     2088                    if not self.isSubstrAt(sRawCode, off, 'IEM_MC_ENDIF'):
     2089                        self.raiseDecodeError(sRawCode, off, 'Expected IEM_MC_ENDIF for closing %s' % (sName,));
     2090                    off = self.skipSpacesAt(sRawCode, off + len('IEM_MC_ENDIF'), offStop);
     2091                    if sRawCode[off] != '(':
     2092                        self.raiseDecodeError(sRawCode, off, 'Expected "(" following IEM_MC_ENDIF"');
     2093                    off = self.skipSpacesAt(sRawCode, off + 1, offStop);
     2094                    if sRawCode[off] != ')':
     2095                        self.raiseDecodeError(sRawCode, off, 'Expected ")" following IEM_MC_ENDIF("');
     2096                    off = self.skipSpacesAt(sRawCode, off + 1, offStop);
     2097                    if sRawCode[off] != ';':
     2098                        self.raiseDecodeError(sRawCode, off, 'Expected ";" following IEM_MC_ENDIF()"');
     2099                    off += 1;
     2100
     2101                else:
     2102                    # Advance.
     2103                    off = offEnd + 1;
     2104
     2105            #
     2106            # Otherwise it must be a C/C++ statement of sorts.
     2107            #
     2108            else:
     2109                offEnd = sRawCode.find(';', off);
     2110                if offEnd < 0:
     2111                    self.raiseDecodeError(sRawCode, off, 'C++ statement without a ";"');
     2112                aoStmts.append(McCppGeneric(sRawCode[off : offEnd + 1]));
     2113                off = offEnd + 1;
     2114        return aoStmts;
     2115
     2116
     2117    def decode(self):
     2118        """
     2119        Decodes the block, populating self.aoStmts.
     2120        Returns the statement list.
     2121        Raises ParserException on failure.
     2122        """
     2123        self.aoStmts = self.decodeCode(''.join(self.asLines));
     2124        return self.aoStmts;
     2125
     2126
     2127## IEM_MC_XXX -> parser dictionary.
     2128# The raw table was generated via the following command
     2129#       sed -n -e "s/^# *define *\(IEM_MC_[A-Z_0-9]*\)[ (].*$/        '\1': McBlock.parseMcGeneric,/p" include/IEMMc.h \
     2130#       | sort | uniq | gawk "{printf """    %%-60s %%s\n""", $1, $2}"
     2131g_dMcStmtParsers = {
     2132    'IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE':                     McBlock.parseMcGeneric,
     2133    'IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ':                       McBlock.parseMcGeneric,
     2134    'IEM_MC_ACTUALIZE_FPU_STATE_FOR_CHANGE':                     McBlock.parseMcGeneric,
     2135    'IEM_MC_ACTUALIZE_FPU_STATE_FOR_READ':                       McBlock.parseMcGeneric,
     2136    'IEM_MC_ACTUALIZE_SSE_STATE_FOR_CHANGE':                     McBlock.parseMcGeneric,
     2137    'IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ':                       McBlock.parseMcGeneric,
     2138    'IEM_MC_ADD_GREG_U16':                                       McBlock.parseMcGeneric,
     2139    'IEM_MC_ADD_GREG_U16_TO_LOCAL':                              McBlock.parseMcGeneric,
     2140    'IEM_MC_ADD_GREG_U32':                                       McBlock.parseMcGeneric,
     2141    'IEM_MC_ADD_GREG_U32_TO_LOCAL':                              McBlock.parseMcGeneric,
     2142    'IEM_MC_ADD_GREG_U64':                                       McBlock.parseMcGeneric,
     2143    'IEM_MC_ADD_GREG_U64_TO_LOCAL':                              McBlock.parseMcGeneric,
     2144    'IEM_MC_ADD_GREG_U8':                                        McBlock.parseMcGeneric,
     2145    'IEM_MC_ADD_GREG_U8_TO_LOCAL':                               McBlock.parseMcGeneric,
     2146    'IEM_MC_ADD_LOCAL_S16_TO_EFF_ADDR':                          McBlock.parseMcGeneric,
     2147    'IEM_MC_ADD_LOCAL_S32_TO_EFF_ADDR':                          McBlock.parseMcGeneric,
     2148    'IEM_MC_ADD_LOCAL_S64_TO_EFF_ADDR':                          McBlock.parseMcGeneric,
     2149    'IEM_MC_ADVANCE_RIP_AND_FINISH':                             McBlock.parseMcGeneric,
     2150    'IEM_MC_AND_2LOCS_U32':                                      McBlock.parseMcGeneric,
     2151    'IEM_MC_AND_ARG_U16':                                        McBlock.parseMcGeneric,
     2152    'IEM_MC_AND_ARG_U32':                                        McBlock.parseMcGeneric,
     2153    'IEM_MC_AND_ARG_U64':                                        McBlock.parseMcGeneric,
     2154    'IEM_MC_AND_GREG_U16':                                       McBlock.parseMcGeneric,
     2155    'IEM_MC_AND_GREG_U32':                                       McBlock.parseMcGeneric,
     2156    'IEM_MC_AND_GREG_U64':                                       McBlock.parseMcGeneric,
     2157    'IEM_MC_AND_GREG_U8':                                        McBlock.parseMcGeneric,
     2158    'IEM_MC_AND_LOCAL_U16':                                      McBlock.parseMcGeneric,
     2159    'IEM_MC_AND_LOCAL_U32':                                      McBlock.parseMcGeneric,
     2160    'IEM_MC_AND_LOCAL_U64':                                      McBlock.parseMcGeneric,
     2161    'IEM_MC_AND_LOCAL_U8':                                       McBlock.parseMcGeneric,
     2162    'IEM_MC_ARG':                                                McBlock.parseMcGeneric,
     2163    'IEM_MC_ARG_CONST':                                          McBlock.parseMcGeneric,
     2164    'IEM_MC_ARG_LOCAL_EFLAGS':                                   McBlock.parseMcGeneric,
     2165    'IEM_MC_ARG_LOCAL_REF':                                      McBlock.parseMcGeneric,
     2166    'IEM_MC_ASSIGN':                                             McBlock.parseMcGeneric,
     2167    'IEM_MC_ASSIGN_TO_SMALLER':                                  McBlock.parseMcGeneric,
     2168    'IEM_MC_BEGIN':                                              McBlock.parseMcGeneric,
     2169    'IEM_MC_BSWAP_LOCAL_U16':                                    McBlock.parseMcGeneric,
     2170    'IEM_MC_BSWAP_LOCAL_U32':                                    McBlock.parseMcGeneric,
     2171    'IEM_MC_BSWAP_LOCAL_U64':                                    McBlock.parseMcGeneric,
     2172    'IEM_MC_CALC_RM_EFF_ADDR':                                   McBlock.parseMcGeneric,
     2173    'IEM_MC_CALL_AIMPL_3':                                       McBlock.parseMcGeneric,
     2174    'IEM_MC_CALL_AIMPL_4':                                       McBlock.parseMcGeneric,
     2175    'IEM_MC_CALL_AVX_AIMPL_2':                                   McBlock.parseMcGeneric,
     2176    'IEM_MC_CALL_AVX_AIMPL_3':                                   McBlock.parseMcGeneric,
     2177    'IEM_MC_CALL_CIMPL_0':                                       McBlock.parseMcGeneric,
     2178    'IEM_MC_CALL_CIMPL_1':                                       McBlock.parseMcGeneric,
     2179    'IEM_MC_CALL_CIMPL_2':                                       McBlock.parseMcGeneric,
     2180    'IEM_MC_CALL_CIMPL_3':                                       McBlock.parseMcGeneric,
     2181    'IEM_MC_CALL_CIMPL_4':                                       McBlock.parseMcGeneric,
     2182    'IEM_MC_CALL_CIMPL_5':                                       McBlock.parseMcGeneric,
     2183    'IEM_MC_CALL_FPU_AIMPL_1':                                   McBlock.parseMcGeneric,
     2184    'IEM_MC_CALL_FPU_AIMPL_2':                                   McBlock.parseMcGeneric,
     2185    'IEM_MC_CALL_FPU_AIMPL_3':                                   McBlock.parseMcGeneric,
     2186    'IEM_MC_CALL_MMX_AIMPL_2':                                   McBlock.parseMcGeneric,
     2187    'IEM_MC_CALL_MMX_AIMPL_3':                                   McBlock.parseMcGeneric,
     2188    'IEM_MC_CALL_SSE_AIMPL_2':                                   McBlock.parseMcGeneric,
     2189    'IEM_MC_CALL_SSE_AIMPL_3':                                   McBlock.parseMcGeneric,
     2190    'IEM_MC_CALL_VOID_AIMPL_0':                                  McBlock.parseMcGeneric,
     2191    'IEM_MC_CALL_VOID_AIMPL_1':                                  McBlock.parseMcGeneric,
     2192    'IEM_MC_CALL_VOID_AIMPL_2':                                  McBlock.parseMcGeneric,
     2193    'IEM_MC_CALL_VOID_AIMPL_3':                                  McBlock.parseMcGeneric,
     2194    'IEM_MC_CALL_VOID_AIMPL_4':                                  McBlock.parseMcGeneric,
     2195    'IEM_MC_CLEAR_EFL_BIT':                                      McBlock.parseMcGeneric,
     2196    'IEM_MC_CLEAR_FSW_EX':                                       McBlock.parseMcGeneric,
     2197    'IEM_MC_CLEAR_HIGH_GREG_U64':                                McBlock.parseMcGeneric,
     2198    'IEM_MC_CLEAR_HIGH_GREG_U64_BY_REF':                         McBlock.parseMcGeneric,
     2199    'IEM_MC_CLEAR_XREG_U32_MASK':                                McBlock.parseMcGeneric,
     2200    'IEM_MC_CLEAR_YREG_128_UP':                                  McBlock.parseMcGeneric,
     2201    'IEM_MC_COMMIT_EFLAGS':                                      McBlock.parseMcGeneric,
     2202    'IEM_MC_COPY_XREG_U128':                                     McBlock.parseMcGeneric,
     2203    'IEM_MC_COPY_YREG_U128_ZX_VLMAX':                            McBlock.parseMcGeneric,
     2204    'IEM_MC_COPY_YREG_U256_ZX_VLMAX':                            McBlock.parseMcGeneric,
     2205    'IEM_MC_COPY_YREG_U64_ZX_VLMAX':                             McBlock.parseMcGeneric,
     2206    'IEM_MC_DEFER_TO_CIMPL_0':                                   McBlock.parseMcGeneric,
     2207    'IEM_MC_DEFER_TO_CIMPL_1':                                   McBlock.parseMcGeneric,
     2208    'IEM_MC_DEFER_TO_CIMPL_2':                                   McBlock.parseMcGeneric,
     2209    'IEM_MC_DEFER_TO_CIMPL_3':                                   McBlock.parseMcGeneric,
     2210    'IEM_MC_END':                                                McBlock.parseMcGeneric,
     2211    'IEM_MC_FETCH_EFLAGS':                                       McBlock.parseMcGeneric,
     2212    'IEM_MC_FETCH_EFLAGS_U8':                                    McBlock.parseMcGeneric,
     2213    'IEM_MC_FETCH_FCW':                                          McBlock.parseMcGeneric,
     2214    'IEM_MC_FETCH_FSW':                                          McBlock.parseMcGeneric,
     2215    'IEM_MC_FETCH_GREG_U16':                                     McBlock.parseMcGeneric,
     2216    'IEM_MC_FETCH_GREG_U16_SX_U32':                              McBlock.parseMcGeneric,
     2217    'IEM_MC_FETCH_GREG_U16_SX_U64':                              McBlock.parseMcGeneric,
     2218    'IEM_MC_FETCH_GREG_U16_ZX_U32':                              McBlock.parseMcGeneric,
     2219    'IEM_MC_FETCH_GREG_U16_ZX_U64':                              McBlock.parseMcGeneric,
     2220    'IEM_MC_FETCH_GREG_U32':                                     McBlock.parseMcGeneric,
     2221    'IEM_MC_FETCH_GREG_U32_SX_U64':                              McBlock.parseMcGeneric,
     2222    'IEM_MC_FETCH_GREG_U32_ZX_U64':                              McBlock.parseMcGeneric,
     2223    'IEM_MC_FETCH_GREG_U64':                                     McBlock.parseMcGeneric,
     2224    'IEM_MC_FETCH_GREG_U64_ZX_U64':                              McBlock.parseMcGeneric,
     2225    'IEM_MC_FETCH_GREG_U8':                                      McBlock.parseMcGeneric,
     2226    'IEM_MC_FETCH_GREG_U8_SX_U16':                               McBlock.parseMcGeneric,
     2227    'IEM_MC_FETCH_GREG_U8_SX_U32':                               McBlock.parseMcGeneric,
     2228    'IEM_MC_FETCH_GREG_U8_SX_U64':                               McBlock.parseMcGeneric,
     2229    'IEM_MC_FETCH_GREG_U8_ZX_U16':                               McBlock.parseMcGeneric,
     2230    'IEM_MC_FETCH_GREG_U8_ZX_U32':                               McBlock.parseMcGeneric,
     2231    'IEM_MC_FETCH_GREG_U8_ZX_U64':                               McBlock.parseMcGeneric,
     2232    'IEM_MC_FETCH_MEM_D80':                                      McBlock.parseMcGeneric,
     2233    'IEM_MC_FETCH_MEM_I16':                                      McBlock.parseMcGeneric,
     2234    'IEM_MC_FETCH_MEM_I32':                                      McBlock.parseMcGeneric,
     2235    'IEM_MC_FETCH_MEM_I64':                                      McBlock.parseMcGeneric,
     2236    'IEM_MC_FETCH_MEM_R32':                                      McBlock.parseMcGeneric,
     2237    'IEM_MC_FETCH_MEM_R64':                                      McBlock.parseMcGeneric,
     2238    'IEM_MC_FETCH_MEM_R80':                                      McBlock.parseMcGeneric,
     2239    'IEM_MC_FETCH_MEM_S32_SX_U64':                               McBlock.parseMcGeneric,
     2240    'IEM_MC_FETCH_MEM_U128':                                     McBlock.parseMcGeneric,
     2241    'IEM_MC_FETCH_MEM_U128_ALIGN_SSE':                           McBlock.parseMcGeneric,
     2242    'IEM_MC_FETCH_MEM_U128_NO_AC':                               McBlock.parseMcGeneric,
     2243    'IEM_MC_FETCH_MEM_U16':                                      McBlock.parseMcGeneric,
     2244    'IEM_MC_FETCH_MEM_U16_DISP':                                 McBlock.parseMcGeneric,
     2245    'IEM_MC_FETCH_MEM_U16_SX_U32':                               McBlock.parseMcGeneric,
     2246    'IEM_MC_FETCH_MEM_U16_SX_U64':                               McBlock.parseMcGeneric,
     2247    'IEM_MC_FETCH_MEM_U16_ZX_U32':                               McBlock.parseMcGeneric,
     2248    'IEM_MC_FETCH_MEM_U16_ZX_U64':                               McBlock.parseMcGeneric,
     2249    'IEM_MC_FETCH_MEM_U256':                                     McBlock.parseMcGeneric,
     2250    'IEM_MC_FETCH_MEM_U256_ALIGN_AVX':                           McBlock.parseMcGeneric,
     2251    'IEM_MC_FETCH_MEM_U256_NO_AC':                               McBlock.parseMcGeneric,
     2252    'IEM_MC_FETCH_MEM_U32':                                      McBlock.parseMcGeneric,
     2253    'IEM_MC_FETCH_MEM_U32_DISP':                                 McBlock.parseMcGeneric,
     2254    'IEM_MC_FETCH_MEM_U32_SX_U64':                               McBlock.parseMcGeneric,
     2255    'IEM_MC_FETCH_MEM_U32_ZX_U64':                               McBlock.parseMcGeneric,
     2256    'IEM_MC_FETCH_MEM_U64':                                      McBlock.parseMcGeneric,
     2257    'IEM_MC_FETCH_MEM_U64_ALIGN_U128':                           McBlock.parseMcGeneric,
     2258    'IEM_MC_FETCH_MEM_U64_DISP':                                 McBlock.parseMcGeneric,
     2259    'IEM_MC_FETCH_MEM_U8':                                       McBlock.parseMcGeneric,
     2260    'IEM_MC_FETCH_MEM_U8_SX_U16':                                McBlock.parseMcGeneric,
     2261    'IEM_MC_FETCH_MEM_U8_SX_U32':                                McBlock.parseMcGeneric,
     2262    'IEM_MC_FETCH_MEM_U8_SX_U64':                                McBlock.parseMcGeneric,
     2263    'IEM_MC_FETCH_MEM_U8_ZX_U16':                                McBlock.parseMcGeneric,
     2264    'IEM_MC_FETCH_MEM_U8_ZX_U32':                                McBlock.parseMcGeneric,
     2265    'IEM_MC_FETCH_MEM_U8_ZX_U64':                                McBlock.parseMcGeneric,
     2266    'IEM_MC_FETCH_MEM_XMM':                                      McBlock.parseMcGeneric,
     2267    'IEM_MC_FETCH_MEM_XMM_ALIGN_SSE':                            McBlock.parseMcGeneric,
     2268    'IEM_MC_FETCH_MEM_XMM_NO_AC':                                McBlock.parseMcGeneric,
     2269    'IEM_MC_FETCH_MEM_XMM_U32':                                  McBlock.parseMcGeneric,
     2270    'IEM_MC_FETCH_MEM_XMM_U64':                                  McBlock.parseMcGeneric,
     2271    'IEM_MC_FETCH_MEM_YMM':                                      McBlock.parseMcGeneric,
     2272    'IEM_MC_FETCH_MEM_YMM_ALIGN_AVX':                            McBlock.parseMcGeneric,
     2273    'IEM_MC_FETCH_MEM_YMM_NO_AC':                                McBlock.parseMcGeneric,
     2274    'IEM_MC_FETCH_MEM16_U8':                                     McBlock.parseMcGeneric,
     2275    'IEM_MC_FETCH_MEM32_U8':                                     McBlock.parseMcGeneric,
     2276    'IEM_MC_FETCH_MREG_U32':                                     McBlock.parseMcGeneric,
     2277    'IEM_MC_FETCH_MREG_U64':                                     McBlock.parseMcGeneric,
     2278    'IEM_MC_FETCH_SREG_BASE_U32':                                McBlock.parseMcGeneric,
     2279    'IEM_MC_FETCH_SREG_BASE_U64':                                McBlock.parseMcGeneric,
     2280    'IEM_MC_FETCH_SREG_U16':                                     McBlock.parseMcGeneric,
     2281    'IEM_MC_FETCH_SREG_ZX_U32':                                  McBlock.parseMcGeneric,
     2282    'IEM_MC_FETCH_SREG_ZX_U64':                                  McBlock.parseMcGeneric,
     2283    'IEM_MC_FETCH_XREG_U128':                                    McBlock.parseMcGeneric,
     2284    'IEM_MC_FETCH_XREG_U16':                                     McBlock.parseMcGeneric,
     2285    'IEM_MC_FETCH_XREG_U32':                                     McBlock.parseMcGeneric,
     2286    'IEM_MC_FETCH_XREG_U64':                                     McBlock.parseMcGeneric,
     2287    'IEM_MC_FETCH_XREG_U8':                                      McBlock.parseMcGeneric,
     2288    'IEM_MC_FETCH_XREG_XMM':                                     McBlock.parseMcGeneric,
     2289    'IEM_MC_FETCH_YREG_2ND_U64':                                 McBlock.parseMcGeneric,
     2290    'IEM_MC_FETCH_YREG_U128':                                    McBlock.parseMcGeneric,
     2291    'IEM_MC_FETCH_YREG_U256':                                    McBlock.parseMcGeneric,
     2292    'IEM_MC_FETCH_YREG_U32':                                     McBlock.parseMcGeneric,
     2293    'IEM_MC_FETCH_YREG_U64':                                     McBlock.parseMcGeneric,
     2294    'IEM_MC_FLIP_EFL_BIT':                                       McBlock.parseMcGeneric,
     2295    'IEM_MC_FPU_FROM_MMX_MODE':                                  McBlock.parseMcGeneric,
     2296    'IEM_MC_FPU_STACK_DEC_TOP':                                  McBlock.parseMcGeneric,
     2297    'IEM_MC_FPU_STACK_FREE':                                     McBlock.parseMcGeneric,
     2298    'IEM_MC_FPU_STACK_INC_TOP':                                  McBlock.parseMcGeneric,
     2299    'IEM_MC_FPU_STACK_PUSH_OVERFLOW':                            McBlock.parseMcGeneric,
     2300    'IEM_MC_FPU_STACK_PUSH_OVERFLOW_MEM_OP':                     McBlock.parseMcGeneric,
     2301    'IEM_MC_FPU_STACK_PUSH_UNDERFLOW':                           McBlock.parseMcGeneric,
     2302    'IEM_MC_FPU_STACK_PUSH_UNDERFLOW_TWO':                       McBlock.parseMcGeneric,
     2303    'IEM_MC_FPU_STACK_UNDERFLOW':                                McBlock.parseMcGeneric,
     2304    'IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP':                         McBlock.parseMcGeneric,
     2305    'IEM_MC_FPU_STACK_UNDERFLOW_MEM_OP_THEN_POP':                McBlock.parseMcGeneric,
     2306    'IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP':                       McBlock.parseMcGeneric,
     2307    'IEM_MC_FPU_STACK_UNDERFLOW_THEN_POP_POP':                   McBlock.parseMcGeneric,
     2308    'IEM_MC_FPU_TO_MMX_MODE':                                    McBlock.parseMcGeneric,
     2309    'IEM_MC_IF_CX_IS_NZ':                                        McBlock.parseMcGenericCond,
     2310    'IEM_MC_IF_CX_IS_NZ_AND_EFL_BIT_NOT_SET':                    McBlock.parseMcGenericCond,
     2311    'IEM_MC_IF_CX_IS_NZ_AND_EFL_BIT_SET':                        McBlock.parseMcGenericCond,
     2312    'IEM_MC_IF_ECX_IS_NZ':                                       McBlock.parseMcGenericCond,
     2313    'IEM_MC_IF_ECX_IS_NZ_AND_EFL_BIT_NOT_SET':                   McBlock.parseMcGenericCond,
     2314    'IEM_MC_IF_ECX_IS_NZ_AND_EFL_BIT_SET':                       McBlock.parseMcGenericCond,
     2315    'IEM_MC_IF_EFL_ANY_BITS_SET':                                McBlock.parseMcGenericCond,
     2316    'IEM_MC_IF_EFL_BIT_NOT_SET':                                 McBlock.parseMcGenericCond,
     2317    'IEM_MC_IF_EFL_BIT_NOT_SET_AND_BITS_EQ':                     McBlock.parseMcGenericCond,
     2318    'IEM_MC_IF_EFL_BIT_SET':                                     McBlock.parseMcGenericCond,
     2319    'IEM_MC_IF_EFL_BIT_SET_OR_BITS_NE':                          McBlock.parseMcGenericCond,
     2320    'IEM_MC_IF_EFL_BITS_EQ':                                     McBlock.parseMcGenericCond,
     2321    'IEM_MC_IF_EFL_BITS_NE':                                     McBlock.parseMcGenericCond,
     2322    'IEM_MC_IF_EFL_NO_BITS_SET':                                 McBlock.parseMcGenericCond,
     2323    'IEM_MC_IF_FCW_IM':                                          McBlock.parseMcGenericCond,
     2324    'IEM_MC_IF_FPUREG_IS_EMPTY':                                 McBlock.parseMcGenericCond,
     2325    'IEM_MC_IF_FPUREG_NOT_EMPTY':                                McBlock.parseMcGenericCond,
     2326    'IEM_MC_IF_FPUREG_NOT_EMPTY_REF_R80':                        McBlock.parseMcGenericCond,
     2327    'IEM_MC_IF_GREG_BIT_SET':                                    McBlock.parseMcGenericCond,
     2328    'IEM_MC_IF_LOCAL_IS_Z':                                      McBlock.parseMcGenericCond,
     2329    'IEM_MC_IF_MXCSR_XCPT_PENDING':                              McBlock.parseMcGenericCond,
     2330    'IEM_MC_IF_RCX_IS_NZ':                                       McBlock.parseMcGenericCond,
     2331    'IEM_MC_IF_RCX_IS_NZ_AND_EFL_BIT_NOT_SET':                   McBlock.parseMcGenericCond,
     2332    'IEM_MC_IF_RCX_IS_NZ_AND_EFL_BIT_SET':                       McBlock.parseMcGenericCond,
     2333    'IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80':                   McBlock.parseMcGenericCond,
     2334    'IEM_MC_IF_TWO_FPUREGS_NOT_EMPTY_REF_R80_FIRST':             McBlock.parseMcGenericCond,
     2335    'IEM_MC_IMPLICIT_AVX_AIMPL_ARGS':                            McBlock.parseMcGeneric,
     2336    'IEM_MC_INT_CLEAR_ZMM_256_UP':                               McBlock.parseMcGeneric,
     2337    'IEM_MC_LOCAL':                                              McBlock.parseMcGeneric,
     2338    'IEM_MC_LOCAL_CONST':                                        McBlock.parseMcGeneric,
     2339    'IEM_MC_MAYBE_RAISE_AESNI_RELATED_XCPT':                     McBlock.parseMcGeneric,
     2340    'IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT':                       McBlock.parseMcGeneric,
     2341    'IEM_MC_MAYBE_RAISE_AVX2_RELATED_XCPT':                      McBlock.parseMcGeneric,
     2342    'IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE':                   McBlock.parseMcGeneric,
     2343    'IEM_MC_MAYBE_RAISE_FPU_XCPT':                               McBlock.parseMcGeneric,
     2344    'IEM_MC_MAYBE_RAISE_FSGSBASE_XCPT':                          McBlock.parseMcGeneric,
     2345    'IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT':                       McBlock.parseMcGeneric,
     2346    'IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT_CHECK_SSE_OR_MMXEXT':   McBlock.parseMcGeneric,
     2347    'IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT_EX':                    McBlock.parseMcGeneric,
     2348    'IEM_MC_MAYBE_RAISE_NON_CANONICAL_ADDR_GP0':                 McBlock.parseMcGeneric,
     2349    'IEM_MC_MAYBE_RAISE_PCLMUL_RELATED_XCPT':                    McBlock.parseMcGeneric,
     2350    'IEM_MC_MAYBE_RAISE_SHA_RELATED_XCPT':                       McBlock.parseMcGeneric,
     2351    'IEM_MC_MAYBE_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT':             McBlock.parseMcGeneric,
     2352    'IEM_MC_MAYBE_RAISE_SSE_RELATED_XCPT':                       McBlock.parseMcGeneric,
     2353    'IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT':                      McBlock.parseMcGeneric,
     2354    'IEM_MC_MAYBE_RAISE_SSE3_RELATED_XCPT':                      McBlock.parseMcGeneric,
     2355    'IEM_MC_MAYBE_RAISE_SSE41_RELATED_XCPT':                     McBlock.parseMcGeneric,
     2356    'IEM_MC_MAYBE_RAISE_SSE42_RELATED_XCPT':                     McBlock.parseMcGeneric,
     2357    'IEM_MC_MAYBE_RAISE_SSSE3_RELATED_XCPT':                     McBlock.parseMcGeneric,
     2358    'IEM_MC_MAYBE_RAISE_WAIT_DEVICE_NOT_AVAILABLE':              McBlock.parseMcGeneric,
     2359    'IEM_MC_MEM_COMMIT_AND_UNMAP':                               McBlock.parseMcGeneric,
     2360    'IEM_MC_MEM_COMMIT_AND_UNMAP_FOR_FPU_STORE':                 McBlock.parseMcGeneric,
     2361    'IEM_MC_MEM_MAP':                                            McBlock.parseMcGeneric,
     2362    'IEM_MC_MEM_MAP_EX':                                         McBlock.parseMcGeneric,
     2363    'IEM_MC_MERGE_YREG_U32_U96_ZX_VLMAX':                        McBlock.parseMcGeneric,
     2364    'IEM_MC_MERGE_YREG_U64_U64_ZX_VLMAX':                        McBlock.parseMcGeneric,
     2365    'IEM_MC_MERGE_YREG_U64HI_U64HI_ZX_VLMAX':                    McBlock.parseMcGeneric,
     2366    'IEM_MC_MERGE_YREG_U64LO_U64LO_ZX_VLMAX':                    McBlock.parseMcGeneric,
     2367    'IEM_MC_MERGE_YREG_U64LO_U64LOCAL_ZX_VLMAX':                 McBlock.parseMcGeneric,
     2368    'IEM_MC_MERGE_YREG_U64LOCAL_U64HI_ZX_VLMAX':                 McBlock.parseMcGeneric,
     2369    'IEM_MC_MODIFIED_MREG':                                      McBlock.parseMcGeneric,
     2370    'IEM_MC_MODIFIED_MREG_BY_REF':                               McBlock.parseMcGeneric,
     2371    'IEM_MC_OR_2LOCS_U32':                                       McBlock.parseMcGeneric,
     2372    'IEM_MC_OR_GREG_U16':                                        McBlock.parseMcGeneric,
     2373    'IEM_MC_OR_GREG_U32':                                        McBlock.parseMcGeneric,
     2374    'IEM_MC_OR_GREG_U64':                                        McBlock.parseMcGeneric,
     2375    'IEM_MC_OR_GREG_U8':                                         McBlock.parseMcGeneric,
     2376    'IEM_MC_OR_LOCAL_U16':                                       McBlock.parseMcGeneric,
     2377    'IEM_MC_OR_LOCAL_U32':                                       McBlock.parseMcGeneric,
     2378    'IEM_MC_OR_LOCAL_U8':                                        McBlock.parseMcGeneric,
     2379    'IEM_MC_POP_U16':                                            McBlock.parseMcGeneric,
     2380    'IEM_MC_POP_U32':                                            McBlock.parseMcGeneric,
     2381    'IEM_MC_POP_U64':                                            McBlock.parseMcGeneric,
     2382    'IEM_MC_PREPARE_AVX_USAGE':                                  McBlock.parseMcGeneric,
     2383    'IEM_MC_PREPARE_FPU_USAGE':                                  McBlock.parseMcGeneric,
     2384    'IEM_MC_PREPARE_SSE_USAGE':                                  McBlock.parseMcGeneric,
     2385    'IEM_MC_PUSH_FPU_RESULT':                                    McBlock.parseMcGeneric,
     2386    'IEM_MC_PUSH_FPU_RESULT_MEM_OP':                             McBlock.parseMcGeneric,
     2387    'IEM_MC_PUSH_FPU_RESULT_TWO':                                McBlock.parseMcGeneric,
     2388    'IEM_MC_PUSH_U16':                                           McBlock.parseMcGeneric,
     2389    'IEM_MC_PUSH_U32':                                           McBlock.parseMcGeneric,
     2390    'IEM_MC_PUSH_U32_SREG':                                      McBlock.parseMcGeneric,
     2391    'IEM_MC_PUSH_U64':                                           McBlock.parseMcGeneric,
     2392    'IEM_MC_RAISE_DIVIDE_ERROR':                                 McBlock.parseMcGeneric,
     2393    'IEM_MC_RAISE_GP0_IF_CPL_NOT_ZERO':                          McBlock.parseMcGeneric,
     2394    'IEM_MC_RAISE_GP0_IF_EFF_ADDR_UNALIGNED':                    McBlock.parseMcGeneric,
     2395    'IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT':                   McBlock.parseMcGeneric,
     2396    'IEM_MC_REF_EFLAGS':                                         McBlock.parseMcGeneric,
     2397    'IEM_MC_REF_FPUREG':                                         McBlock.parseMcGeneric,
     2398    'IEM_MC_REF_GREG_I32':                                       McBlock.parseMcGeneric,
     2399    'IEM_MC_REF_GREG_I32_CONST':                                 McBlock.parseMcGeneric,
     2400    'IEM_MC_REF_GREG_I64':                                       McBlock.parseMcGeneric,
     2401    'IEM_MC_REF_GREG_I64_CONST':                                 McBlock.parseMcGeneric,
     2402    'IEM_MC_REF_GREG_U16':                                       McBlock.parseMcGeneric,
     2403    'IEM_MC_REF_GREG_U32':                                       McBlock.parseMcGeneric,
     2404    'IEM_MC_REF_GREG_U64':                                       McBlock.parseMcGeneric,
     2405    'IEM_MC_REF_GREG_U8':                                        McBlock.parseMcGeneric,
     2406    'IEM_MC_REF_LOCAL':                                          McBlock.parseMcGeneric,
     2407    'IEM_MC_REF_MREG_U32_CONST':                                 McBlock.parseMcGeneric,
     2408    'IEM_MC_REF_MREG_U64':                                       McBlock.parseMcGeneric,
     2409    'IEM_MC_REF_MREG_U64_CONST':                                 McBlock.parseMcGeneric,
     2410    'IEM_MC_REF_MXCSR':                                          McBlock.parseMcGeneric,
     2411    'IEM_MC_REF_XREG_R32_CONST':                                 McBlock.parseMcGeneric,
     2412    'IEM_MC_REF_XREG_R64_CONST':                                 McBlock.parseMcGeneric,
     2413    'IEM_MC_REF_XREG_U128':                                      McBlock.parseMcGeneric,
     2414    'IEM_MC_REF_XREG_U128_CONST':                                McBlock.parseMcGeneric,
     2415    'IEM_MC_REF_XREG_U32_CONST':                                 McBlock.parseMcGeneric,
     2416    'IEM_MC_REF_XREG_U64_CONST':                                 McBlock.parseMcGeneric,
     2417    'IEM_MC_REF_XREG_XMM_CONST':                                 McBlock.parseMcGeneric,
     2418    'IEM_MC_REF_YREG_U128':                                      McBlock.parseMcGeneric,
     2419    'IEM_MC_REF_YREG_U128_CONST':                                McBlock.parseMcGeneric,
     2420    'IEM_MC_REF_YREG_U64_CONST':                                 McBlock.parseMcGeneric,
     2421    'IEM_MC_REL_JMP_S16_AND_FINISH':                             McBlock.parseMcGeneric,
     2422    'IEM_MC_REL_JMP_S32_AND_FINISH':                             McBlock.parseMcGeneric,
     2423    'IEM_MC_REL_JMP_S8_AND_FINISH':                              McBlock.parseMcGeneric,
     2424    'IEM_MC_RETURN_ON_FAILURE':                                  McBlock.parseMcGeneric,
     2425    'IEM_MC_SAR_LOCAL_S16':                                      McBlock.parseMcGeneric,
     2426    'IEM_MC_SAR_LOCAL_S32':                                      McBlock.parseMcGeneric,
     2427    'IEM_MC_SAR_LOCAL_S64':                                      McBlock.parseMcGeneric,
     2428    'IEM_MC_SET_EFL_BIT':                                        McBlock.parseMcGeneric,
     2429    'IEM_MC_SET_FPU_RESULT':                                     McBlock.parseMcGeneric,
     2430    'IEM_MC_SET_RIP_U16_AND_FINISH':                             McBlock.parseMcGeneric,
     2431    'IEM_MC_SET_RIP_U32_AND_FINISH':                             McBlock.parseMcGeneric,
     2432    'IEM_MC_SET_RIP_U64_AND_FINISH':                             McBlock.parseMcGeneric,
     2433    'IEM_MC_SHL_LOCAL_S16':                                      McBlock.parseMcGeneric,
     2434    'IEM_MC_SHL_LOCAL_S32':                                      McBlock.parseMcGeneric,
     2435    'IEM_MC_SHL_LOCAL_S64':                                      McBlock.parseMcGeneric,
     2436    'IEM_MC_SHR_LOCAL_U8':                                       McBlock.parseMcGeneric,
     2437    'IEM_MC_SSE_UPDATE_MXCSR':                                   McBlock.parseMcGeneric,
     2438    'IEM_MC_STORE_FPU_RESULT':                                   McBlock.parseMcGeneric,
     2439    'IEM_MC_STORE_FPU_RESULT_MEM_OP':                            McBlock.parseMcGeneric,
     2440    'IEM_MC_STORE_FPU_RESULT_THEN_POP':                          McBlock.parseMcGeneric,
     2441    'IEM_MC_STORE_FPU_RESULT_WITH_MEM_OP_THEN_POP':              McBlock.parseMcGeneric,
     2442    'IEM_MC_STORE_FPUREG_R80_SRC_REF':                           McBlock.parseMcGeneric,
     2443    'IEM_MC_STORE_GREG_I64':                                     McBlock.parseMcGeneric,
     2444    'IEM_MC_STORE_GREG_U16':                                     McBlock.parseMcGeneric,
     2445    'IEM_MC_STORE_GREG_U16_CONST':                               McBlock.parseMcGeneric,
     2446    'IEM_MC_STORE_GREG_U32':                                     McBlock.parseMcGeneric,
     2447    'IEM_MC_STORE_GREG_U32_CONST':                               McBlock.parseMcGeneric,
     2448    'IEM_MC_STORE_GREG_U64':                                     McBlock.parseMcGeneric,
     2449    'IEM_MC_STORE_GREG_U64_CONST':                               McBlock.parseMcGeneric,
     2450    'IEM_MC_STORE_GREG_U8':                                      McBlock.parseMcGeneric,
     2451    'IEM_MC_STORE_GREG_U8_CONST':                                McBlock.parseMcGeneric,
     2452    'IEM_MC_STORE_MEM_I16_CONST_BY_REF':                         McBlock.parseMcGeneric,
     2453    'IEM_MC_STORE_MEM_I32_CONST_BY_REF':                         McBlock.parseMcGeneric,
     2454    'IEM_MC_STORE_MEM_I64_CONST_BY_REF':                         McBlock.parseMcGeneric,
     2455    'IEM_MC_STORE_MEM_I8_CONST_BY_REF':                          McBlock.parseMcGeneric,
     2456    'IEM_MC_STORE_MEM_INDEF_D80_BY_REF':                         McBlock.parseMcGeneric,
     2457    'IEM_MC_STORE_MEM_NEG_QNAN_R32_BY_REF':                      McBlock.parseMcGeneric,
     2458    'IEM_MC_STORE_MEM_NEG_QNAN_R64_BY_REF':                      McBlock.parseMcGeneric,
     2459    'IEM_MC_STORE_MEM_NEG_QNAN_R80_BY_REF':                      McBlock.parseMcGeneric,
     2460    'IEM_MC_STORE_MEM_U128':                                     McBlock.parseMcGeneric,
     2461    'IEM_MC_STORE_MEM_U128_ALIGN_SSE':                           McBlock.parseMcGeneric,
     2462    'IEM_MC_STORE_MEM_U16':                                      McBlock.parseMcGeneric,
     2463    'IEM_MC_STORE_MEM_U16_CONST':                                McBlock.parseMcGeneric,
     2464    'IEM_MC_STORE_MEM_U256':                                     McBlock.parseMcGeneric,
     2465    'IEM_MC_STORE_MEM_U256_ALIGN_AVX':                           McBlock.parseMcGeneric,
     2466    'IEM_MC_STORE_MEM_U32':                                      McBlock.parseMcGeneric,
     2467    'IEM_MC_STORE_MEM_U32_CONST':                                McBlock.parseMcGeneric,
     2468    'IEM_MC_STORE_MEM_U64':                                      McBlock.parseMcGeneric,
     2469    'IEM_MC_STORE_MEM_U64_CONST':                                McBlock.parseMcGeneric,
     2470    'IEM_MC_STORE_MEM_U8':                                       McBlock.parseMcGeneric,
     2471    'IEM_MC_STORE_MEM_U8_CONST':                                 McBlock.parseMcGeneric,
     2472    'IEM_MC_STORE_MREG_U32_ZX_U64':                              McBlock.parseMcGeneric,
     2473    'IEM_MC_STORE_MREG_U64':                                     McBlock.parseMcGeneric,
     2474    'IEM_MC_STORE_SREG_BASE_U32':                                McBlock.parseMcGeneric,
     2475    'IEM_MC_STORE_SREG_BASE_U64':                                McBlock.parseMcGeneric,
     2476    'IEM_MC_STORE_SSE_RESULT':                                   McBlock.parseMcGeneric,
     2477    'IEM_MC_STORE_XREG_HI_U64':                                  McBlock.parseMcGeneric,
     2478    'IEM_MC_STORE_XREG_R32':                                     McBlock.parseMcGeneric,
     2479    'IEM_MC_STORE_XREG_R64':                                     McBlock.parseMcGeneric,
     2480    'IEM_MC_STORE_XREG_U128':                                    McBlock.parseMcGeneric,
     2481    'IEM_MC_STORE_XREG_U16':                                     McBlock.parseMcGeneric,
     2482    'IEM_MC_STORE_XREG_U32':                                     McBlock.parseMcGeneric,
     2483    'IEM_MC_STORE_XREG_U32_U128':                                McBlock.parseMcGeneric,
     2484    'IEM_MC_STORE_XREG_U32_ZX_U128':                             McBlock.parseMcGeneric,
     2485    'IEM_MC_STORE_XREG_U64':                                     McBlock.parseMcGeneric,
     2486    'IEM_MC_STORE_XREG_U64_ZX_U128':                             McBlock.parseMcGeneric,
     2487    'IEM_MC_STORE_XREG_U8':                                      McBlock.parseMcGeneric,
     2488    'IEM_MC_STORE_XREG_XMM':                                     McBlock.parseMcGeneric,
     2489    'IEM_MC_STORE_XREG_XMM_U32':                                 McBlock.parseMcGeneric,
     2490    'IEM_MC_STORE_XREG_XMM_U64':                                 McBlock.parseMcGeneric,
     2491    'IEM_MC_STORE_YREG_U128_ZX_VLMAX':                           McBlock.parseMcGeneric,
     2492    'IEM_MC_STORE_YREG_U256_ZX_VLMAX':                           McBlock.parseMcGeneric,
     2493    'IEM_MC_STORE_YREG_U32_ZX_VLMAX':                            McBlock.parseMcGeneric,
     2494    'IEM_MC_STORE_YREG_U64_ZX_VLMAX':                            McBlock.parseMcGeneric,
     2495    'IEM_MC_SUB_GREG_U16':                                       McBlock.parseMcGeneric,
     2496    'IEM_MC_SUB_GREG_U32':                                       McBlock.parseMcGeneric,
     2497    'IEM_MC_SUB_GREG_U64':                                       McBlock.parseMcGeneric,
     2498    'IEM_MC_SUB_GREG_U8':                                        McBlock.parseMcGeneric,
     2499    'IEM_MC_SUB_LOCAL_U16':                                      McBlock.parseMcGeneric,
     2500    'IEM_MC_UPDATE_FPU_OPCODE_IP':                               McBlock.parseMcGeneric,
     2501    'IEM_MC_UPDATE_FSW':                                         McBlock.parseMcGeneric,
     2502    'IEM_MC_UPDATE_FSW_CONST':                                   McBlock.parseMcGeneric,
     2503    'IEM_MC_UPDATE_FSW_THEN_POP':                                McBlock.parseMcGeneric,
     2504    'IEM_MC_UPDATE_FSW_THEN_POP_POP':                            McBlock.parseMcGeneric,
     2505    'IEM_MC_UPDATE_FSW_WITH_MEM_OP':                             McBlock.parseMcGeneric,
     2506    'IEM_MC_UPDATE_FSW_WITH_MEM_OP_THEN_POP':                    McBlock.parseMcGeneric,
     2507};
    17672508
    17682509## List of microcode blocks.

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

    r98797 r98880  
    36273627
    36283628        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpi2ps_u128, pfMxcsr, pDst, u64Src);
    3629         IEM_MC_IF_MXCSR_XCPT_PENDING()
     3629        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    36303630            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3631         IEM_MC_ELSE()
     3631        } IEM_MC_ELSE() {
    36323632            IEM_MC_STORE_XREG_XMM(IEM_GET_MODRM_REG(pVCpu, bRm), Dst);
    3633         IEM_MC_ENDIF();
     3633        } IEM_MC_ENDIF();
    36343634
    36353635        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    36593659
    36603660        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpi2ps_u128, pfMxcsr, pDst, u64Src);
    3661         IEM_MC_IF_MXCSR_XCPT_PENDING()
     3661        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    36623662            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3663         IEM_MC_ELSE()
     3663        } IEM_MC_ELSE() {
    36643664            IEM_MC_STORE_XREG_XMM(IEM_GET_MODRM_REG(pVCpu, bRm), Dst);
    3665         IEM_MC_ENDIF();
     3665        } IEM_MC_ENDIF();
    36663666
    36673667        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    36973697
    36983698        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpi2pd_u128, pfMxcsr, pDst, u64Src);
    3699         IEM_MC_IF_MXCSR_XCPT_PENDING()
     3699        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    37003700            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3701         IEM_MC_ELSE()
     3701        } IEM_MC_ELSE() {
    37023702            IEM_MC_STORE_XREG_XMM(IEM_GET_MODRM_REG(pVCpu, bRm), Dst);
    3703         IEM_MC_ENDIF();
     3703        } IEM_MC_ENDIF();
    37043704
    37053705        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    37293729
    37303730        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpi2pd_u128, pfMxcsr, pDst, u64Src);
    3731         IEM_MC_IF_MXCSR_XCPT_PENDING()
     3731        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    37323732            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3733         IEM_MC_ELSE()
     3733        } IEM_MC_ELSE() {
    37343734            IEM_MC_STORE_XREG_XMM(IEM_GET_MODRM_REG(pVCpu, bRm), Dst);
    3735         IEM_MC_ENDIF();
     3735        } IEM_MC_ENDIF();
    37363736
    37373737        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    37663766            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsi2ss_r32_i64, pfMxcsr, pr32Dst, pi64Src);
    37673767            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    3768             IEM_MC_IF_MXCSR_XCPT_PENDING()
     3768            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    37693769                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3770             IEM_MC_ELSE()
     3770            } IEM_MC_ELSE() {
    37713771                IEM_MC_STORE_XREG_R32(IEM_GET_MODRM_REG(pVCpu, bRm), r32Dst);
    3772             IEM_MC_ENDIF();
     3772            } IEM_MC_ENDIF();
    37733773
    37743774            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    37953795            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsi2ss_r32_i64, pfMxcsr, pr32Dst, pi64Src);
    37963796            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    3797             IEM_MC_IF_MXCSR_XCPT_PENDING()
     3797            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    37983798                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3799             IEM_MC_ELSE()
     3799            } IEM_MC_ELSE() {
    38003800                IEM_MC_STORE_XREG_R32(IEM_GET_MODRM_REG(pVCpu, bRm), r32Dst);
    3801             IEM_MC_ENDIF();
     3801            } IEM_MC_ENDIF();
    38023802
    38033803            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    38243824            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsi2ss_r32_i32, pfMxcsr, pr32Dst, pi32Src);
    38253825            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    3826             IEM_MC_IF_MXCSR_XCPT_PENDING()
     3826            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    38273827                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3828             IEM_MC_ELSE()
     3828            } IEM_MC_ELSE() {
    38293829                IEM_MC_STORE_XREG_R32(IEM_GET_MODRM_REG(pVCpu, bRm), r32Dst);
    3830             IEM_MC_ENDIF();
     3830            } IEM_MC_ENDIF();
    38313831
    38323832            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    38533853            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsi2ss_r32_i32, pfMxcsr, pr32Dst, pi32Src);
    38543854            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    3855             IEM_MC_IF_MXCSR_XCPT_PENDING()
     3855            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    38563856                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3857             IEM_MC_ELSE()
     3857            } IEM_MC_ELSE() {
    38583858                IEM_MC_STORE_XREG_R32(IEM_GET_MODRM_REG(pVCpu, bRm), r32Dst);
    3859             IEM_MC_ENDIF();
     3859            } IEM_MC_ENDIF();
    38603860
    38613861            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    38913891            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsi2sd_r64_i64, pfMxcsr, pr64Dst, pi64Src);
    38923892            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    3893             IEM_MC_IF_MXCSR_XCPT_PENDING()
     3893            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    38943894                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3895             IEM_MC_ELSE()
     3895            } IEM_MC_ELSE() {
    38963896                IEM_MC_STORE_XREG_R64(IEM_GET_MODRM_REG(pVCpu, bRm), r64Dst);
    3897             IEM_MC_ENDIF();
     3897            } IEM_MC_ENDIF();
    38983898
    38993899            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    39203920            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsi2sd_r64_i64, pfMxcsr, pr64Dst, pi64Src);
    39213921            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    3922             IEM_MC_IF_MXCSR_XCPT_PENDING()
     3922            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    39233923                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3924             IEM_MC_ELSE()
     3924            } IEM_MC_ELSE() {
    39253925                IEM_MC_STORE_XREG_R64(IEM_GET_MODRM_REG(pVCpu, bRm), r64Dst);
    3926             IEM_MC_ENDIF();
     3926            } IEM_MC_ENDIF();
    39273927
    39283928            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    39493949            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsi2sd_r64_i32, pfMxcsr, pr64Dst, pi32Src);
    39503950            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    3951             IEM_MC_IF_MXCSR_XCPT_PENDING()
     3951            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    39523952                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3953             IEM_MC_ELSE()
     3953            } IEM_MC_ELSE() {
    39543954                IEM_MC_STORE_XREG_R64(IEM_GET_MODRM_REG(pVCpu, bRm), r64Dst);
    3955             IEM_MC_ENDIF();
     3955            } IEM_MC_ENDIF();
    39563956
    39573957            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    39783978            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsi2sd_r64_i32, pfMxcsr, pr64Dst, pi32Src);
    39793979            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    3980             IEM_MC_IF_MXCSR_XCPT_PENDING()
     3980            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    39813981                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    3982             IEM_MC_ELSE()
     3982            } IEM_MC_ELSE() {
    39833983                IEM_MC_STORE_XREG_R64(IEM_GET_MODRM_REG(pVCpu, bRm), r64Dst);
    3984             IEM_MC_ENDIF();
     3984            } IEM_MC_ENDIF();
    39853985
    39863986            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    40974097
    40984098        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvttps2pi_u128, pfMxcsr, pu64Dst, u64Src);
    4099         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4099        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    41004100            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4101         IEM_MC_ELSE()
     4101        } IEM_MC_ELSE() {
    41024102            IEM_MC_STORE_MREG_U64(IEM_GET_MODRM_REG_8(bRm), u64Dst);
    4103         IEM_MC_ENDIF();
     4103        } IEM_MC_ENDIF();
    41044104
    41054105        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    41284128
    41294129        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvttps2pi_u128, pfMxcsr, pu64Dst, u64Src);
    4130         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4130        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    41314131            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4132         IEM_MC_ELSE()
     4132        } IEM_MC_ELSE() {
    41334133            IEM_MC_STORE_MREG_U64(IEM_GET_MODRM_REG_8(bRm), u64Dst);
    4134         IEM_MC_ENDIF();
     4134        } IEM_MC_ENDIF();
    41354135
    41364136        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    41654165
    41664166        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvttpd2pi_u128, pfMxcsr, pu64Dst, pSrc);
    4167         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4167        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    41684168            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4169         IEM_MC_ELSE()
     4169        } IEM_MC_ELSE() {
    41704170            IEM_MC_STORE_MREG_U64(IEM_GET_MODRM_REG_8(bRm), u64Dst);
    4171         IEM_MC_ENDIF();
     4171        } IEM_MC_ENDIF();
    41724172
    41734173        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    41984198
    41994199        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvttpd2pi_u128, pfMxcsr, pu64Dst, pSrc);
    4200         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4200        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    42014201            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4202         IEM_MC_ELSE()
     4202        } IEM_MC_ELSE() {
    42034203            IEM_MC_STORE_MREG_U64(IEM_GET_MODRM_REG_8(bRm), u64Dst);
    4204         IEM_MC_ENDIF();
     4204        } IEM_MC_ENDIF();
    42054205
    42064206        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    42354235            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvttss2si_i64_r32, pfMxcsr, pi64Dst, pu32Src);
    42364236            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4237             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4237            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    42384238                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4239             IEM_MC_ELSE()
     4239            } IEM_MC_ELSE() {
    42404240                IEM_MC_STORE_GREG_I64(IEM_GET_MODRM_REG(pVCpu, bRm), i64Dst);
    4241             IEM_MC_ENDIF();
     4241            } IEM_MC_ENDIF();
    42424242
    42434243            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    42644264            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvttss2si_i64_r32, pfMxcsr, pi64Dst, pu32Src);
    42654265            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4266             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4266            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    42674267                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4268             IEM_MC_ELSE()
     4268            } IEM_MC_ELSE() {
    42694269                IEM_MC_STORE_GREG_I64(IEM_GET_MODRM_REG(pVCpu, bRm), i64Dst);
    4270             IEM_MC_ENDIF();
     4270            } IEM_MC_ENDIF();
    42714271
    42724272            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    42934293            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvttss2si_i32_r32, pfMxcsr, pi32Dst, pu32Src);
    42944294            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4295             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4295            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    42964296                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4297             IEM_MC_ELSE()
     4297            } IEM_MC_ELSE() {
    42984298                IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), i32Dst);
    4299             IEM_MC_ENDIF();
     4299            } IEM_MC_ENDIF();
    43004300
    43014301            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    43224322            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvttss2si_i32_r32, pfMxcsr, pi32Dst, pu32Src);
    43234323            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4324             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4324            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    43254325                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4326             IEM_MC_ELSE()
     4326            } IEM_MC_ELSE() {
    43274327                IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), i32Dst);
    4328             IEM_MC_ENDIF();
     4328            } IEM_MC_ENDIF();
    43294329
    43304330            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    43604360            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvttsd2si_i64_r64, pfMxcsr, pi64Dst, pu64Src);
    43614361            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4362             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4362            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    43634363                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4364             IEM_MC_ELSE()
     4364            } IEM_MC_ELSE() {
    43654365                IEM_MC_STORE_GREG_I64(IEM_GET_MODRM_REG(pVCpu, bRm), i64Dst);
    4366             IEM_MC_ENDIF();
     4366            } IEM_MC_ENDIF();
    43674367
    43684368            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    43894389            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvttsd2si_i64_r64, pfMxcsr, pi64Dst, pu64Src);
    43904390            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4391             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4391            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    43924392                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4393             IEM_MC_ELSE()
     4393            } IEM_MC_ELSE() {
    43944394                IEM_MC_STORE_GREG_I64(IEM_GET_MODRM_REG(pVCpu, bRm), i64Dst);
    4395             IEM_MC_ENDIF();
     4395            } IEM_MC_ENDIF();
    43964396
    43974397            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    44184418            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvttsd2si_i32_r64, pfMxcsr, pi32Dst, pu64Src);
    44194419            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4420             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4420            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    44214421                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4422             IEM_MC_ELSE()
     4422            } IEM_MC_ELSE() {
    44234423                IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), i32Dst);
    4424             IEM_MC_ENDIF();
     4424            } IEM_MC_ENDIF();
    44254425
    44264426            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    44474447            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvttsd2si_i32_r64, pfMxcsr, pi32Dst, pu64Src);
    44484448            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4449             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4449            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    44504450                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4451             IEM_MC_ELSE()
     4451            } IEM_MC_ELSE() {
    44524452                IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), i32Dst);
    4453             IEM_MC_ENDIF();
     4453            } IEM_MC_ENDIF();
    44544454
    44554455            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    44854485
    44864486        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtps2pi_u128, pfMxcsr, pu64Dst, u64Src);
    4487         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4487        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    44884488            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4489         IEM_MC_ELSE()
     4489        } IEM_MC_ELSE() {
    44904490            IEM_MC_STORE_MREG_U64(IEM_GET_MODRM_REG_8(bRm), u64Dst);
    4491         IEM_MC_ENDIF();
     4491        } IEM_MC_ENDIF();
    44924492
    44934493        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    45164516
    45174517        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtps2pi_u128, pfMxcsr, pu64Dst, u64Src);
    4518         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4518        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    45194519            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4520         IEM_MC_ELSE()
     4520        } IEM_MC_ELSE() {
    45214521            IEM_MC_STORE_MREG_U64(IEM_GET_MODRM_REG_8(bRm), u64Dst);
    4522         IEM_MC_ENDIF();
     4522        } IEM_MC_ENDIF();
    45234523
    45244524        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    45534553
    45544554        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpd2pi_u128, pfMxcsr, pu64Dst, pSrc);
    4555         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4555        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    45564556            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4557         IEM_MC_ELSE()
     4557        } IEM_MC_ELSE() {
    45584558            IEM_MC_STORE_MREG_U64(IEM_GET_MODRM_REG_8(bRm), u64Dst);
    4559         IEM_MC_ENDIF();
     4559        } IEM_MC_ENDIF();
    45604560
    45614561        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    45864586
    45874587        IEM_MC_CALL_VOID_AIMPL_3(iemAImpl_cvtpd2pi_u128, pfMxcsr, pu64Dst, pSrc);
    4588         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4588        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    45894589            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4590         IEM_MC_ELSE()
     4590        } IEM_MC_ELSE() {
    45914591            IEM_MC_STORE_MREG_U64(IEM_GET_MODRM_REG_8(bRm), u64Dst);
    4592         IEM_MC_ENDIF();
     4592        } IEM_MC_ENDIF();
    45934593
    45944594        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    46234623            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtss2si_i64_r32, pfMxcsr, pi64Dst, pu32Src);
    46244624            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4625             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4625            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    46264626                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4627             IEM_MC_ELSE()
     4627            } IEM_MC_ELSE() {
    46284628                IEM_MC_STORE_GREG_I64(IEM_GET_MODRM_REG(pVCpu, bRm), i64Dst);
    4629             IEM_MC_ENDIF();
     4629            } IEM_MC_ENDIF();
    46304630
    46314631            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    46524652            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtss2si_i64_r32, pfMxcsr, pi64Dst, pu32Src);
    46534653            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4654             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4654            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    46554655                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4656             IEM_MC_ELSE()
     4656            } IEM_MC_ELSE() {
    46574657                IEM_MC_STORE_GREG_I64(IEM_GET_MODRM_REG(pVCpu, bRm), i64Dst);
    4658             IEM_MC_ENDIF();
     4658            } IEM_MC_ENDIF();
    46594659
    46604660            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    46814681            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtss2si_i32_r32, pfMxcsr, pi32Dst, pu32Src);
    46824682            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4683             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4683            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    46844684                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4685             IEM_MC_ELSE()
     4685            } IEM_MC_ELSE() {
    46864686                IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), i32Dst);
    4687             IEM_MC_ENDIF();
     4687            } IEM_MC_ENDIF();
    46884688
    46894689            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    47104710            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtss2si_i32_r32, pfMxcsr, pi32Dst, pu32Src);
    47114711            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4712             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4712            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    47134713                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4714             IEM_MC_ELSE()
     4714            } IEM_MC_ELSE() {
    47154715                IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), i32Dst);
    4716             IEM_MC_ENDIF();
     4716            } IEM_MC_ENDIF();
    47174717
    47184718            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    47484748            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsd2si_i64_r64, pfMxcsr, pi64Dst, pu64Src);
    47494749            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4750             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4750            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    47514751                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4752             IEM_MC_ELSE()
     4752            } IEM_MC_ELSE() {
    47534753                IEM_MC_STORE_GREG_I64(IEM_GET_MODRM_REG(pVCpu, bRm), i64Dst);
    4754             IEM_MC_ENDIF();
     4754            } IEM_MC_ENDIF();
    47554755
    47564756            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    47774777            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsd2si_i64_r64, pfMxcsr, pi64Dst, pu64Src);
    47784778            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4779             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4779            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    47804780                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4781             IEM_MC_ELSE()
     4781            } IEM_MC_ELSE() {
    47824782                IEM_MC_STORE_GREG_I64(IEM_GET_MODRM_REG(pVCpu, bRm), i64Dst);
    4783             IEM_MC_ENDIF();
     4783            } IEM_MC_ENDIF();
    47844784
    47854785            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    48064806            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsd2si_i32_r64, pfMxcsr, pi32Dst, pu64Src);
    48074807            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4808             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4808            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    48094809                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4810             IEM_MC_ELSE()
     4810            } IEM_MC_ELSE() {
    48114811                IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), i32Dst);
    4812             IEM_MC_ENDIF();
     4812            } IEM_MC_ENDIF();
    48134813
    48144814            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    48354835            IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_cvtsd2si_i32_r64, pfMxcsr, pi32Dst, pu64Src);
    48364836            IEM_MC_SSE_UPDATE_MXCSR(fMxcsr);
    4837             IEM_MC_IF_MXCSR_XCPT_PENDING()
     4837            IEM_MC_IF_MXCSR_XCPT_PENDING() {
    48384838                IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4839             IEM_MC_ELSE()
     4839            } IEM_MC_ELSE() {
    48404840                IEM_MC_STORE_GREG_U32(IEM_GET_MODRM_REG(pVCpu, bRm), i32Dst);
    4841             IEM_MC_ENDIF();
     4841            } IEM_MC_ENDIF();
    48424842
    48434843            IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    48724872        IEM_MC_REF_XREG_XMM_CONST(puSrc2,      IEM_GET_MODRM_RM(pVCpu, bRm));
    48734873        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_ucomiss_u128, pfMxcsr, pEFlags, puSrc1, puSrc2);
    4874         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4874        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    48754875            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4876         IEM_MC_ELSE()
     4876        } IEM_MC_ELSE() {
    48774877            IEM_MC_COMMIT_EFLAGS(fEFlags);
    4878         IEM_MC_ENDIF();
     4878        } IEM_MC_ENDIF();
    48794879
    48804880        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    49054905        IEM_MC_REF_XREG_XMM_CONST(puSrc1,       IEM_GET_MODRM_REG(pVCpu, bRm));
    49064906        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_ucomiss_u128, pfMxcsr, pEFlags, puSrc1, puSrc2);
    4907         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4907        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    49084908            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4909         IEM_MC_ELSE()
     4909        } IEM_MC_ELSE() {
    49104910            IEM_MC_COMMIT_EFLAGS(fEFlags);
    4911         IEM_MC_ENDIF();
     4911        } IEM_MC_ENDIF();
    49124912
    49134913        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    49414941        IEM_MC_REF_XREG_XMM_CONST(puSrc2,      IEM_GET_MODRM_RM(pVCpu, bRm));
    49424942        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_ucomisd_u128, pfMxcsr, pEFlags, puSrc1, puSrc2);
    4943         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4943        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    49444944            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4945         IEM_MC_ELSE()
     4945        } IEM_MC_ELSE() {
    49464946            IEM_MC_COMMIT_EFLAGS(fEFlags);
    4947         IEM_MC_ENDIF();
     4947        } IEM_MC_ENDIF();
    49484948
    49494949        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    49744974        IEM_MC_REF_XREG_XMM_CONST(puSrc1,       IEM_GET_MODRM_REG(pVCpu, bRm));
    49754975        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_ucomisd_u128, pfMxcsr, pEFlags, puSrc1, puSrc2);
    4976         IEM_MC_IF_MXCSR_XCPT_PENDING()
     4976        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    49774977            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    4978         IEM_MC_ELSE()
     4978        } IEM_MC_ELSE() {
    49794979            IEM_MC_COMMIT_EFLAGS(fEFlags);
    4980         IEM_MC_ENDIF();
     4980        } IEM_MC_ENDIF();
    49814981
    49824982        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    50145014        IEM_MC_REF_XREG_XMM_CONST(puSrc2,      IEM_GET_MODRM_RM(pVCpu, bRm));
    50155015        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_comiss_u128, pfMxcsr, pEFlags, puSrc1, puSrc2);
    5016         IEM_MC_IF_MXCSR_XCPT_PENDING()
     5016        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    50175017            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    5018         IEM_MC_ELSE()
     5018        } IEM_MC_ELSE() {
    50195019            IEM_MC_COMMIT_EFLAGS(fEFlags);
    5020         IEM_MC_ENDIF();
     5020        } IEM_MC_ENDIF();
    50215021
    50225022        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    50475047        IEM_MC_REF_XREG_XMM_CONST(puSrc1,       IEM_GET_MODRM_REG(pVCpu, bRm));
    50485048        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_comiss_u128, pfMxcsr, pEFlags, puSrc1, puSrc2);
    5049         IEM_MC_IF_MXCSR_XCPT_PENDING()
     5049        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    50505050            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    5051         IEM_MC_ELSE()
     5051        } IEM_MC_ELSE() {
    50525052            IEM_MC_COMMIT_EFLAGS(fEFlags);
    5053         IEM_MC_ENDIF();
     5053        } IEM_MC_ENDIF();
    50545054
    50555055        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    50835083        IEM_MC_REF_XREG_XMM_CONST(puSrc2,      IEM_GET_MODRM_RM(pVCpu, bRm));
    50845084        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_comisd_u128, pfMxcsr, pEFlags, puSrc1, puSrc2);
    5085         IEM_MC_IF_MXCSR_XCPT_PENDING()
     5085        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    50865086            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    5087         IEM_MC_ELSE()
     5087        } IEM_MC_ELSE() {
    50885088            IEM_MC_COMMIT_EFLAGS(fEFlags);
    5089         IEM_MC_ENDIF();
     5089        } IEM_MC_ENDIF();
    50905090
    50915091        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    51165116        IEM_MC_REF_XREG_XMM_CONST(puSrc1,       IEM_GET_MODRM_REG(pVCpu, bRm));
    51175117        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_comisd_u128, pfMxcsr, pEFlags, puSrc1, puSrc2);
    5118         IEM_MC_IF_MXCSR_XCPT_PENDING()
     5118        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    51195119            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    5120         IEM_MC_ELSE()
     5120        } IEM_MC_ELSE() {
    51215121            IEM_MC_COMMIT_EFLAGS(fEFlags);
    5122         IEM_MC_ENDIF();
     5122        } IEM_MC_ENDIF();
    51235123
    51245124        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1020710207                IEM_MC_COMMIT_EFLAGS(EFlags);
    1020810208
    10209                 IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF)
     10209                IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF) {
    1021010210                    IEM_MC_STORE_GREG_U32(X86_GREG_xAX, u32Eax);
    10211                 IEM_MC_ENDIF();
     10211                } IEM_MC_ENDIF();
    1021210212
    1021310213                IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1079710797                IEM_MC_REF_EFLAGS(pEFlags);
    1079810798                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    10799                 IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF)
     10799                IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF) {
    1080010800                    IEM_MC_CLEAR_HIGH_GREG_U64_BY_REF(pu32Dst);
    10801                 IEM_MC_ENDIF();
     10801                } IEM_MC_ENDIF();
    1080210802                IEM_MC_ADVANCE_RIP_AND_FINISH();
    1080310803                IEM_MC_END();
    … …  
    1086110861                IEM_MC_CALL_VOID_AIMPL_3(pImpl->pfnNormalU32, pu32Dst, u32Src, pEFlags);
    1086210862
    10863                 IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF)
     10863                IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF) {
    1086410864                    IEM_MC_CLEAR_HIGH_GREG_U64_BY_REF(pu32Dst);
    10865                 IEM_MC_ENDIF();
     10865                } IEM_MC_ENDIF();
    1086610866                IEM_MC_ADVANCE_RIP_AND_FINISH();
    1086710867                IEM_MC_END();
    … …  
    1136711367        IEM_MC_FETCH_XREG_XMM(Src.uSrc2, IEM_GET_MODRM_RM(pVCpu, bRm));
    1136811368        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpps_u128, pfMxcsr, pDst, pSrc, bImmArg);
    11369         IEM_MC_IF_MXCSR_XCPT_PENDING()
     11369        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    1137011370            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    11371         IEM_MC_ELSE()
     11371        } IEM_MC_ELSE() {
    1137211372            IEM_MC_STORE_XREG_XMM(IEM_GET_MODRM_REG(pVCpu, bRm), Dst);
    11373         IEM_MC_ENDIF();
     11373        } IEM_MC_ENDIF();
    1137411374
    1137511375        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1140011400        IEM_MC_FETCH_XREG_XMM(Src.uSrc1, IEM_GET_MODRM_REG(pVCpu, bRm));
    1140111401        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpps_u128, pfMxcsr, pDst, pSrc, bImmArg);
    11402         IEM_MC_IF_MXCSR_XCPT_PENDING()
     11402        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    1140311403            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    11404         IEM_MC_ELSE()
     11404        } IEM_MC_ELSE() {
    1140511405            IEM_MC_STORE_XREG_XMM(IEM_GET_MODRM_REG(pVCpu, bRm), Dst);
    11406         IEM_MC_ENDIF();
     11406        } IEM_MC_ENDIF();
    1140711407
    1140811408        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1143811438        IEM_MC_FETCH_XREG_XMM(Src.uSrc2, IEM_GET_MODRM_RM(pVCpu, bRm));
    1143911439        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmppd_u128, pfMxcsr, pDst, pSrc, bImmArg);
    11440         IEM_MC_IF_MXCSR_XCPT_PENDING()
     11440        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    1144111441            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    11442         IEM_MC_ELSE()
     11442        } IEM_MC_ELSE() {
    1144311443            IEM_MC_STORE_XREG_XMM(IEM_GET_MODRM_REG(pVCpu, bRm), Dst);
    11444         IEM_MC_ENDIF();
     11444        } IEM_MC_ENDIF();
    1144511445
    1144611446        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1147111471        IEM_MC_FETCH_XREG_XMM(Src.uSrc1, IEM_GET_MODRM_REG(pVCpu, bRm));
    1147211472        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmppd_u128, pfMxcsr, pDst, pSrc, bImmArg);
    11473         IEM_MC_IF_MXCSR_XCPT_PENDING()
     11473        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    1147411474            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    11475         IEM_MC_ELSE()
     11475        } IEM_MC_ELSE() {
    1147611476            IEM_MC_STORE_XREG_XMM(IEM_GET_MODRM_REG(pVCpu, bRm), Dst);
    11477         IEM_MC_ENDIF();
     11477        } IEM_MC_ENDIF();
    1147811478
    1147911479        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1150911509        IEM_MC_FETCH_XREG_XMM(Src.uSrc2, IEM_GET_MODRM_RM(pVCpu, bRm));
    1151011510        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpss_u128, pfMxcsr, pDst, pSrc, bImmArg);
    11511         IEM_MC_IF_MXCSR_XCPT_PENDING()
     11511        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    1151211512            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    11513         IEM_MC_ELSE()
     11513        } IEM_MC_ELSE() {
    1151411514            IEM_MC_STORE_XREG_XMM_U32(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /*a_iDword*/, Dst);
    11515         IEM_MC_ENDIF();
     11515        } IEM_MC_ENDIF();
    1151611516
    1151711517        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1154211542        IEM_MC_FETCH_XREG_XMM(Src.uSrc1, IEM_GET_MODRM_REG(pVCpu, bRm));
    1154311543        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpss_u128, pfMxcsr, pDst, pSrc, bImmArg);
    11544         IEM_MC_IF_MXCSR_XCPT_PENDING()
     11544        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    1154511545            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    11546         IEM_MC_ELSE()
     11546        } IEM_MC_ELSE() {
    1154711547            IEM_MC_STORE_XREG_XMM_U32(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /*a_iDword*/, Dst);
    11548         IEM_MC_ENDIF();
     11548        } IEM_MC_ENDIF();
    1154911549
    1155011550        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1158011580        IEM_MC_FETCH_XREG_XMM(Src.uSrc2, IEM_GET_MODRM_RM(pVCpu, bRm));
    1158111581        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpsd_u128, pfMxcsr, pDst, pSrc, bImmArg);
    11582         IEM_MC_IF_MXCSR_XCPT_PENDING()
     11582        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    1158311583            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    11584         IEM_MC_ELSE()
     11584        } IEM_MC_ELSE() {
    1158511585            IEM_MC_STORE_XREG_XMM_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /*a_iQword*/, Dst);
    11586         IEM_MC_ENDIF();
     11586        } IEM_MC_ENDIF();
    1158711587
    1158811588        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1161311613        IEM_MC_FETCH_XREG_XMM(Src.uSrc1, IEM_GET_MODRM_REG(pVCpu, bRm));
    1161411614        IEM_MC_CALL_VOID_AIMPL_4(iemAImpl_cmpsd_u128, pfMxcsr, pDst, pSrc, bImmArg);
    11615         IEM_MC_IF_MXCSR_XCPT_PENDING()
     11615        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    1161611616            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    11617         IEM_MC_ELSE()
     11617        } IEM_MC_ELSE() {
    1161811618            IEM_MC_STORE_XREG_XMM_U64(IEM_GET_MODRM_REG(pVCpu, bRm), 0 /*a_iQword*/, Dst);
    11619         IEM_MC_ENDIF();
     11619        } IEM_MC_ENDIF();
    1162011620
    1162111621        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    1200312003    IEM_MC_MEM_COMMIT_AND_UNMAP(pu64MemDst, IEM_ACCESS_DATA_RW);
    1200412004    IEM_MC_COMMIT_EFLAGS(EFlags);
    12005     IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF)
     12005    IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF) {
    1200612006        IEM_MC_STORE_GREG_U32(X86_GREG_xAX, u64EaxEdx.s.Lo);
    1200712007        IEM_MC_STORE_GREG_U32(X86_GREG_xDX, u64EaxEdx.s.Hi);
    12008     IEM_MC_ENDIF();
     12008    } IEM_MC_ENDIF();
    1200912009    IEM_MC_ADVANCE_RIP_AND_FINISH();
    1201012010
    … …  
    1207912079        IEM_MC_MEM_COMMIT_AND_UNMAP(pu128MemDst, IEM_ACCESS_DATA_RW);
    1208012080        IEM_MC_COMMIT_EFLAGS(EFlags);
    12081         IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF)
     12081        IEM_MC_IF_EFL_BIT_NOT_SET(X86_EFL_ZF) {
    1208212082            IEM_MC_STORE_GREG_U64(X86_GREG_xAX, u128RaxRdx.s.Lo);
    1208312083            IEM_MC_STORE_GREG_U64(X86_GREG_xDX, u128RaxRdx.s.Hi);
    12084         IEM_MC_ENDIF();
     12084        } IEM_MC_ENDIF();
    1208512085        IEM_MC_ADVANCE_RIP_AND_FINISH();
    1208612086

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

    r98843 r98880  
    23022302        IEM_MC_CALL_VOID_AIMPL_4(IEM_SELECT_HOST_OR_FALLBACK(fAvx, iemAImpl_vucomiss_u128, iemAImpl_vucomiss_u128_fallback),
    23032303                                 pfMxcsr, pEFlags, puSrc1, puSrc2);
    2304         IEM_MC_IF_MXCSR_XCPT_PENDING()
     2304        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    23052305            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    2306         IEM_MC_ELSE()
     2306        } IEM_MC_ELSE() {
    23072307            IEM_MC_COMMIT_EFLAGS(fEFlags);
    2308         IEM_MC_ENDIF();
     2308        } IEM_MC_ENDIF();
    23092309
    23102310        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    23362336        IEM_MC_CALL_VOID_AIMPL_4(IEM_SELECT_HOST_OR_FALLBACK(fAvx, iemAImpl_vucomiss_u128, iemAImpl_vucomiss_u128_fallback),
    23372337                                 pfMxcsr, pEFlags, puSrc1, puSrc2);
    2338         IEM_MC_IF_MXCSR_XCPT_PENDING()
     2338        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    23392339            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    2340         IEM_MC_ELSE()
     2340        } IEM_MC_ELSE() {
    23412341            IEM_MC_COMMIT_EFLAGS(fEFlags);
    2342         IEM_MC_ENDIF();
     2342        } IEM_MC_ENDIF();
    23432343
    23442344        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    23732373        IEM_MC_CALL_VOID_AIMPL_4(IEM_SELECT_HOST_OR_FALLBACK(fAvx, iemAImpl_vucomisd_u128, iemAImpl_vucomisd_u128_fallback),
    23742374                                 pfMxcsr, pEFlags, puSrc1, puSrc2);
    2375         IEM_MC_IF_MXCSR_XCPT_PENDING()
     2375        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    23762376            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    2377         IEM_MC_ELSE()
     2377        } IEM_MC_ELSE() {
    23782378            IEM_MC_COMMIT_EFLAGS(fEFlags);
    2379         IEM_MC_ENDIF();
     2379        } IEM_MC_ENDIF();
    23802380
    23812381        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    24072407        IEM_MC_CALL_VOID_AIMPL_4(IEM_SELECT_HOST_OR_FALLBACK(fAvx, iemAImpl_vucomisd_u128, iemAImpl_vucomisd_u128_fallback),
    24082408                                 pfMxcsr, pEFlags, puSrc1, puSrc2);
    2409         IEM_MC_IF_MXCSR_XCPT_PENDING()
     2409        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    24102410            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    2411         IEM_MC_ELSE()
     2411        } IEM_MC_ELSE() {
    24122412            IEM_MC_COMMIT_EFLAGS(fEFlags);
    2413         IEM_MC_ENDIF();
     2413        } IEM_MC_ENDIF();
    24142414
    24152415        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    24472447        IEM_MC_CALL_VOID_AIMPL_4(IEM_SELECT_HOST_OR_FALLBACK(fAvx, iemAImpl_vcomiss_u128, iemAImpl_vcomiss_u128_fallback),
    24482448                                 pfMxcsr, pEFlags, puSrc1, puSrc2);
    2449         IEM_MC_IF_MXCSR_XCPT_PENDING()
     2449        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    24502450            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    2451         IEM_MC_ELSE()
     2451        } IEM_MC_ELSE() {
    24522452            IEM_MC_COMMIT_EFLAGS(fEFlags);
    2453         IEM_MC_ENDIF();
     2453        } IEM_MC_ENDIF();
    24542454
    24552455        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    24812481        IEM_MC_CALL_VOID_AIMPL_4(IEM_SELECT_HOST_OR_FALLBACK(fAvx, iemAImpl_vcomiss_u128, iemAImpl_vcomiss_u128_fallback),
    24822482                                 pfMxcsr, pEFlags, puSrc1, puSrc2);
    2483         IEM_MC_IF_MXCSR_XCPT_PENDING()
     2483        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    24842484            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    2485         IEM_MC_ELSE()
     2485        } IEM_MC_ELSE() {
    24862486            IEM_MC_COMMIT_EFLAGS(fEFlags);
    2487         IEM_MC_ENDIF();
     2487        } IEM_MC_ENDIF();
    24882488
    24892489        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    25182518        IEM_MC_CALL_VOID_AIMPL_4(IEM_SELECT_HOST_OR_FALLBACK(fAvx, iemAImpl_vcomisd_u128, iemAImpl_vcomisd_u128_fallback),
    25192519                                 pfMxcsr, pEFlags, puSrc1, puSrc2);
    2520         IEM_MC_IF_MXCSR_XCPT_PENDING()
     2520        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    25212521            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    2522         IEM_MC_ELSE()
     2522        } IEM_MC_ELSE() {
    25232523            IEM_MC_COMMIT_EFLAGS(fEFlags);
    2524         IEM_MC_ENDIF();
     2524        } IEM_MC_ENDIF();
    25252525
    25262526        IEM_MC_ADVANCE_RIP_AND_FINISH();
    … …  
    25522552        IEM_MC_CALL_VOID_AIMPL_4(IEM_SELECT_HOST_OR_FALLBACK(fAvx, iemAImpl_vcomisd_u128, iemAImpl_vcomisd_u128_fallback),
    25532553                                 pfMxcsr, pEFlags, puSrc1, puSrc2);
    2554         IEM_MC_IF_MXCSR_XCPT_PENDING()
     2554        IEM_MC_IF_MXCSR_XCPT_PENDING() {
    25552555            IEM_MC_RAISE_SSE_AVX_SIMD_FP_OR_UD_XCPT();
    2556         IEM_MC_ELSE()
     2556        } IEM_MC_ELSE() {
    25572557            IEM_MC_COMMIT_EFLAGS(fEFlags);
    2558         IEM_MC_ENDIF();
     2558        } IEM_MC_ENDIF();
    25592559
    25602560        IEM_MC_ADVANCE_RIP_AND_FINISH();
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