VirtualBox

Changeset 99984 in vbox


Ignore:
Timestamp:
May 26, 2023 1:20:46 AM (17 months ago)
Author:
vboxsync
Message:

VMM/IEM: Fixed a few places in IEMAllCImpl.cpp and IEMAllCImplSvmInstr.cpp where decoder state was used directly instead of being passed as arguments. bugref:10369

Location:
trunk/src/VBox/VMM
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/VMM/VMMAll/IEMAll.cpp

    r99983 r99984  
    38153815             * Check and handle if the event being raised is intercepted.
    38163816             */
    3817             VBOXSTRICTRC rcStrict0 = iemHandleSvmEventIntercept(pVCpu, u8Vector, fFlags, uErr, uCr2);
     3817            VBOXSTRICTRC rcStrict0 = iemHandleSvmEventIntercept(pVCpu, cbInstr, u8Vector, fFlags, uErr, uCr2);
    38183818            if (rcStrict0 != VINF_SVM_INTERCEPT_NOT_ACTIVE)
    38193819                return rcStrict0;
     
    1122511225
    1122611226    iemInitExec(pVCpu, false /*fBypassHandlers*/);
    11227     VBOXSTRICTRC rcStrict = IEM_CIMPL_CALL_3(iemCImpl_out, u16Port, fImm, cbReg);
     11227    VBOXSTRICTRC rcStrict = IEM_CIMPL_CALL_3(iemCImpl_out, u16Port, cbReg,
     11228                                             ((uint8_t)fImm << 7) | 0xf /** @todo never worked with intercepts */);
    1122811229    Assert(!pVCpu->iem.s.cActiveMappings);
    1122911230    return iemUninitExecAndFiddleStatusAndMaybeReenter(pVCpu, rcStrict);
     
    1124811249
    1124911250    iemInitExec(pVCpu, false /*fBypassHandlers*/);
    11250     VBOXSTRICTRC rcStrict = IEM_CIMPL_CALL_3(iemCImpl_in, u16Port, fImm, cbReg);
     11251    VBOXSTRICTRC rcStrict = IEM_CIMPL_CALL_3(iemCImpl_in, u16Port, cbReg,
     11252                                             ((uint8_t)fImm << 7) | 0xf /** @todo never worked with intercepts */);
    1125111253    Assert(!pVCpu->iem.s.cActiveMappings);
    1125211254    return iemUninitExecAndFiddleStatusAndMaybeReenter(pVCpu, rcStrict);
  • trunk/src/VBox/VMM/VMMAll/IEMAllCImpl.cpp

    r99983 r99984  
    3232#define LOG_GROUP   LOG_GROUP_IEM
    3333#define VMCPU_INCL_CPUM_GST_CTX
     34///@todo #define IEM_WITH_OPAQUE_DECODER_STATE
    3435#include <VBox/vmm/iem.h>
    3536#include <VBox/vmm/cpum.h>
     
    622623    {
    623624        Log2(("pushf: Guest intercept -> #VMEXIT\n"));
    624         IEM_SVM_UPDATE_NRIP(pVCpu);
     625        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    625626        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_PUSHF, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    626627    }
     
    688689    {
    689690        Log2(("popf: Guest intercept -> #VMEXIT\n"));
    690         IEM_SVM_UPDATE_NRIP(pVCpu);
     691        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    691692        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_POPF, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    692693    }
     
    39653966    {
    39663967        Log(("iret: Guest intercept -> #VMEXIT\n"));
    3967         IEM_SVM_UPDATE_NRIP(pVCpu);
     3968        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    39683969        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_IRET, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    39693970    }
     
    42684269/**
    42694270 * Implements SYSRET (AMD and Intel64).
    4270  */
    4271 IEM_CIMPL_DEF_0(iemCImpl_sysret)
     4271 *
     4272 * @param   enmEffOpSize    The effective operand size.
     4273 */
     4274IEM_CIMPL_DEF_1(iemCImpl_sysret, IEMMODE, enmEffOpSize)
    42724275
    42734276{
     
    43074310    uint16_t uNewCs = (pVCpu->cpum.GstCtx.msrSTAR >> MSR_K6_STAR_SYSRET_CS_SS_SHIFT) & X86_SEL_MASK_OFF_RPL;
    43084311    uint16_t uNewSs = uNewCs + 8;
    4309     if (pVCpu->iem.s.enmEffOpSize == IEMMODE_64BIT)
     4312    if (enmEffOpSize == IEMMODE_64BIT)
    43104313        uNewCs += 16;
    43114314    if (uNewCs == 0 || uNewSs == 0)
     
    43204323    if (CPUMIsGuestInLongModeEx(IEM_GET_CTX(pVCpu)))
    43214324    {
    4322         if (pVCpu->iem.s.enmEffOpSize == IEMMODE_64BIT)
     4325        if (enmEffOpSize == IEMMODE_64BIT)
    43234326        {
    43244327            Log(("sysret: %04x:%016RX64 [efl=%#llx] -> %04x:%016RX64 [r11=%#llx]\n", pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rflags.u, uNewCs, pVCpu->cpum.GstCtx.rcx, pVCpu->cpum.GstCtx.r11));
     
    51325135    {
    51335136        Log(("lgdt: Guest intercept -> #VMEXIT\n"));
    5134         IEM_SVM_UPDATE_NRIP(pVCpu);
     5137        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    51355138        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_GDTR_WRITE, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    51365139    }
     
    51845187    {
    51855188        Log(("sgdt: Guest intercept -> #VMEXIT\n"));
    5186         IEM_SVM_UPDATE_NRIP(pVCpu);
     5189        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    51875190        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_GDTR_READ, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    51885191    }
     
    52125215    {
    52135216        Log(("lidt: Guest intercept -> #VMEXIT\n"));
    5214         IEM_SVM_UPDATE_NRIP(pVCpu);
     5217        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    52155218        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_IDTR_WRITE, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    52165219    }
     
    52565259    {
    52575260        Log(("sidt: Guest intercept -> #VMEXIT\n"));
    5258         IEM_SVM_UPDATE_NRIP(pVCpu);
     5261        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    52595262        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_IDTR_READ, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    52605263    }
     
    53105313        {
    53115314            Log(("lldt: Guest intercept -> #VMEXIT\n"));
    5312             IEM_SVM_UPDATE_NRIP(pVCpu);
     5315            IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    53135316            IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_LDTR_WRITE, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    53145317        }
     
    53855388    {
    53865389        Log(("lldt: Guest intercept -> #VMEXIT\n"));
    5387         IEM_SVM_UPDATE_NRIP(pVCpu);
     5390        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    53885391        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_LDTR_WRITE, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    53895392    }
     
    54195422    }
    54205423
    5421     IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_LDTR_READS, SVM_EXIT_LDTR_READ, 0, 0);
     5424    IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_LDTR_READS, SVM_EXIT_LDTR_READ, 0, 0, cbInstr);
    54225425
    54235426    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_LDTR);
     
    54415444IEM_CIMPL_DEF_2(iemCImpl_sldt_mem, uint8_t, iEffSeg, RTGCPTR, GCPtrEffDst)
    54425445{
    5443     IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_LDTR_READS, SVM_EXIT_LDTR_READ, 0, 0);
     5446    IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_LDTR_READS, SVM_EXIT_LDTR_READ, 0, 0, cbInstr);
    54445447
    54455448    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_LDTR);
     
    54905493    {
    54915494        Log(("ltr: Guest intercept -> #VMEXIT\n"));
    5492         IEM_SVM_UPDATE_NRIP(pVCpu);
     5495        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    54935496        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_TR_WRITE, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    54945497    }
     
    55955598    }
    55965599
    5597     IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_TR_READS, SVM_EXIT_TR_READ, 0, 0);
     5600    IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_TR_READS, SVM_EXIT_TR_READ, 0, 0, cbInstr);
    55985601
    55995602    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_TR);
     
    56245627    }
    56255628
    5626     IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_TR_READS, SVM_EXIT_TR_READ, 0, 0);
     5629    IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_TR_READS, SVM_EXIT_TR_READ, 0, 0, cbInstr);
    56275630
    56285631    IEM_CTX_IMPORT_RET(pVCpu, CPUMCTX_EXTRN_TR);
     
    56495652    {
    56505653        Log(("iemCImpl_mov_Rd_Cd: Guest intercept CR%u -> #VMEXIT\n", iCrReg));
    5651         IEM_SVM_UPDATE_NRIP(pVCpu);
     5654        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    56525655        IEM_SVM_CRX_VMEXIT_RET(pVCpu, SVM_EXIT_READ_CR0 + iCrReg, IEMACCESSCRX_MOV_CRX, iGReg);
    56535656    }
     
    57605763IEM_CIMPL_DEF_2(iemCImpl_smsw_reg, uint8_t, iGReg, uint8_t, enmEffOpSize)
    57615764{
    5762     IEM_SVM_CHECK_READ_CR0_INTERCEPT(pVCpu, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     5765    IEM_SVM_CHECK_READ_CR0_INTERCEPT(pVCpu, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */, cbInstr);
    57635766
    57645767#ifdef VBOX_WITH_NESTED_HWVIRT_VMX
     
    58075810IEM_CIMPL_DEF_2(iemCImpl_smsw_mem, uint8_t, iEffSeg, RTGCPTR, GCPtrEffDst)
    58085811{
    5809     IEM_SVM_CHECK_READ_CR0_INTERCEPT(pVCpu, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
     5812    IEM_SVM_CHECK_READ_CR0_INTERCEPT(pVCpu, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */, cbInstr);
    58105813
    58115814#ifdef VBOX_WITH_NESTED_HWVIRT_VMX
     
    59715974            {
    59725975                Log(("iemCImpl_load_Cr%#x: Guest intercept -> #VMEXIT\n", iCrReg));
    5973                 IEM_SVM_UPDATE_NRIP(pVCpu);
     5976                IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    59745977                IEM_SVM_CRX_VMEXIT_RET(pVCpu, SVM_EXIT_WRITE_CR0, enmAccessCrX, iGReg);
    59755978            }
     
    59825985                    Assert(enmAccessCrX != IEMACCESSCRX_CLTS);
    59835986                    Log(("iemCImpl_load_Cr%#x: lmsw or bits other than TS/MP changed: Guest intercept -> #VMEXIT\n", iCrReg));
    5984                     IEM_SVM_UPDATE_NRIP(pVCpu);
     5987                    IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    59855988                    IEM_SVM_CRX_VMEXIT_RET(pVCpu, SVM_EXIT_CR0_SEL_WRITE, enmAccessCrX, iGReg);
    59865989                }
     
    60456048            {
    60466049                Log(("iemCImpl_load_Cr%#x: Guest intercept -> #VMEXIT\n", iCrReg));
    6047                 IEM_SVM_UPDATE_NRIP(pVCpu);
     6050                IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    60486051                IEM_SVM_CRX_VMEXIT_RET(pVCpu, SVM_EXIT_WRITE_CR2, enmAccessCrX, iGReg);
    60496052            }
     
    61156118            {
    61166119                Log(("iemCImpl_load_Cr%#x: Guest intercept -> #VMEXIT\n", iCrReg));
    6117                 IEM_SVM_UPDATE_NRIP(pVCpu);
     6120                IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    61186121                IEM_SVM_CRX_VMEXIT_RET(pVCpu, SVM_EXIT_WRITE_CR3, enmAccessCrX, iGReg);
    61196122            }
     
    61846187            {
    61856188                Log(("iemCImpl_load_Cr%#x: Guest intercept -> #VMEXIT\n", iCrReg));
    6186                 IEM_SVM_UPDATE_NRIP(pVCpu);
     6189                IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    61876190                IEM_SVM_CRX_VMEXIT_RET(pVCpu, SVM_EXIT_WRITE_CR4, enmAccessCrX, iGReg);
    61886191            }
     
    62796282                {
    62806283                    Log(("iemCImpl_load_Cr%#x: Guest intercept -> #VMEXIT\n", iCrReg));
    6281                     IEM_SVM_UPDATE_NRIP(pVCpu);
     6284                    IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    62826285                    IEM_SVM_CRX_VMEXIT_RET(pVCpu, SVM_EXIT_WRITE_CR8, enmAccessCrX, iGReg);
    62836286                }
     
    65146517    {
    65156518        Log(("mov r%u,dr%u: Guest intercept -> #VMEXIT\n", iGReg, iDrReg));
    6516         IEM_SVM_UPDATE_NRIP(pVCpu);
     6519        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    65176520        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_READ_DR0 + (iDrReg & 0xf),
    65186521                           IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSvmDecodeAssists ? (iGReg & 7) : 0, 0 /* uExitInfo2 */);
     
    66316634    {
    66326635        Log2(("mov dr%u,r%u: Guest intercept -> #VMEXIT\n", iDrReg, iGReg));
    6633         IEM_SVM_UPDATE_NRIP(pVCpu);
     6636        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    66346637        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_WRITE_DR0 + (iDrReg & 0xf),
    66356638                              IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSvmDecodeAssists ? (iGReg & 7) : 0, 0 /* uExitInfo2 */);
     
    67836786    {
    67846787        Log(("invlpg: Guest intercept (%RGp) -> #VMEXIT\n", GCPtrPage));
    6785         IEM_SVM_UPDATE_NRIP(pVCpu);
     6788        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    67866789        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_INVLPG,
    67876790                              IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSvmDecodeAssists ? GCPtrPage : 0, 0 /* uExitInfo2 */);
     
    69496952        IEM_VMX_VMEXIT_INSTR_RET(pVCpu, VMX_EXIT_INVD, cbInstr);
    69506953
    6951     IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_INVD, SVM_EXIT_INVD, 0, 0);
     6954    IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_INVD, SVM_EXIT_INVD, 0, 0, cbInstr);
    69526955
    69536956    /* We currently take no action here. */
     
    69706973        IEM_VMX_VMEXIT_INSTR_RET(pVCpu, VMX_EXIT_WBINVD, cbInstr);
    69716974
    6972     IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_WBINVD, SVM_EXIT_WBINVD, 0, 0);
     6975    IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_WBINVD, SVM_EXIT_WBINVD, 0, 0, cbInstr);
    69736976
    69746977    /* We currently take no action here. */
     
    69806983IEM_CIMPL_DEF_0(iemCImpl_rsm)
    69816984{
    6982     IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_RSM, SVM_EXIT_RSM, 0, 0);
     6985    IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_RSM, SVM_EXIT_RSM, 0, 0, cbInstr);
    69836986    NOREF(cbInstr);
    69846987    return iemRaiseUndefinedOpcode(pVCpu);
     
    70177020    {
    70187021        Log(("rdtsc: Guest intercept -> #VMEXIT\n"));
    7019         IEM_SVM_UPDATE_NRIP(pVCpu);
     7022        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    70207023        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_RDTSC, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    70217024    }
     
    70727075    {
    70737076        Log(("rdtscp: Guest intercept -> #VMEXIT\n"));
    7074         IEM_SVM_UPDATE_NRIP(pVCpu);
     7077        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    70757078        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_RDTSCP, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    70767079    }
     
    71217124    {
    71227125        Log(("rdpmc: Guest intercept -> #VMEXIT\n"));
    7123         IEM_SVM_UPDATE_NRIP(pVCpu);
     7126        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    71247127        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_RDPMC, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    71257128    }
     
    71637166    if (IEM_SVM_IS_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_MSR_PROT))
    71647167    {
    7165         VBOXSTRICTRC rcStrict = iemSvmHandleMsrIntercept(pVCpu, pVCpu->cpum.GstCtx.ecx, false /* fWrite */);
     7168        VBOXSTRICTRC rcStrict = iemSvmHandleMsrIntercept(pVCpu, pVCpu->cpum.GstCtx.ecx, false /* fWrite */, cbInstr);
    71667169        if (rcStrict == VINF_SVM_VMEXIT)
    71677170            return VINF_SUCCESS;
     
    72497252    if (IEM_SVM_IS_CTRL_INTERCEPT_SET(pVCpu, SVM_CTRL_INTERCEPT_MSR_PROT))
    72507253    {
    7251         VBOXSTRICTRC rcStrict = iemSvmHandleMsrIntercept(pVCpu, idMsr, true /* fWrite */);
     7254        VBOXSTRICTRC rcStrict = iemSvmHandleMsrIntercept(pVCpu, idMsr, true /* fWrite */, cbInstr);
    72527255        if (rcStrict == VINF_SVM_VMEXIT)
    72537256            return VINF_SUCCESS;
     
    72927295 * Implements 'IN eAX, port'.
    72937296 *
    7294  * @param   u16Port     The source port.
    7295  * @param   fImm        Whether the port was specified through an immediate operand
    7296  *                      or the implicit DX register.
    7297  * @param   cbReg       The register size.
    7298  */
    7299 IEM_CIMPL_DEF_3(iemCImpl_in, uint16_t, u16Port, bool, fImm, uint8_t, cbReg)
     7297 * @param   u16Port             The source port.
     7298 * @param   cbReg               The register size.
     7299 * @param   bImmAndEffAddrMode  Bit 7: Whether the port was specified through an
     7300 *                              immediate operand or the implicit DX register.
     7301 *                              Bits 3-0: Effective address mode.
     7302 */
     7303IEM_CIMPL_DEF_3(iemCImpl_in, uint16_t, u16Port, uint8_t, cbReg, uint8_t, bImmAndEffAddrMode)
    73007304{
    73017305    /*
     
    73127316    if (IEM_VMX_IS_NON_ROOT_MODE(pVCpu))
    73137317    {
    7314         rcStrict = iemVmxVmexitInstrIo(pVCpu, VMXINSTRID_IO_IN, u16Port, fImm, cbReg, cbInstr);
     7318        rcStrict = iemVmxVmexitInstrIo(pVCpu, VMXINSTRID_IO_IN, u16Port, RT_BOOL(bImmAndEffAddrMode & 0x80), cbReg, cbInstr);
    73157319        if (rcStrict != VINF_VMX_INTERCEPT_NOT_ACTIVE)
    73167320            return rcStrict;
    73177321    }
    73187322#else
    7319     RT_NOREF(fImm);
     7323    RT_NOREF(bImmAndEffAddrMode);
    73207324#endif
    73217325
     
    73277331    {
    73287332        uint8_t cAddrSizeBits;
    7329         switch (pVCpu->iem.s.enmEffAddrMode)
     7333        switch (bImmAndEffAddrMode & 0xf)
    73307334        {
    73317335            case IEMMODE_16BIT: cAddrSizeBits = 16; break;
     
    73457349        }
    73467350    }
     7351#else
     7352    RT_NOREF(bImmAndEffAddrMode);
    73477353#endif
    73487354
     
    73927398 *
    73937399 * @param   cbReg       The register size.
    7394  */
    7395 IEM_CIMPL_DEF_1(iemCImpl_in_eAX_DX, uint8_t, cbReg)
    7396 {
    7397     return IEM_CIMPL_CALL_3(iemCImpl_in, pVCpu->cpum.GstCtx.dx, false /* fImm */, cbReg);
     7400 * @param   enmEffAddrMode  Effective address mode.
     7401 */
     7402IEM_CIMPL_DEF_2(iemCImpl_in_eAX_DX, uint8_t, cbReg, IEMMODE, enmEffAddrMode)
     7403{
     7404    return IEM_CIMPL_CALL_3(iemCImpl_in, pVCpu->cpum.GstCtx.dx, cbReg, 0 /* fImm */ | enmEffAddrMode);
    73987405}
    73997406
     
    74027409 * Implements 'OUT port, eAX'.
    74037410 *
    7404  * @param   u16Port     The destination port.
    7405  * @param   fImm        Whether the port was specified through an immediate operand
    7406  *                      or the implicit DX register.
    7407  * @param   cbReg       The register size.
    7408  */
    7409 IEM_CIMPL_DEF_3(iemCImpl_out, uint16_t, u16Port, bool, fImm, uint8_t, cbReg)
     7411 * @param   u16Port         The destination port.
     7412 * @param   cbReg           The register size.
     7413 * @param   bImmAndEffAddrMode  Bit 7: Whether the port was specified through an
     7414 *                              immediate operand or the implicit DX register.
     7415 *                              Bits 3-0: Effective address mode.
     7416 */
     7417IEM_CIMPL_DEF_3(iemCImpl_out, uint16_t, u16Port, uint8_t, cbReg, uint8_t, bImmAndEffAddrMode)
    74107418{
    74117419    /*
     
    74227430    if (IEM_VMX_IS_NON_ROOT_MODE(pVCpu))
    74237431    {
    7424         rcStrict = iemVmxVmexitInstrIo(pVCpu, VMXINSTRID_IO_OUT, u16Port, fImm, cbReg, cbInstr);
     7432        rcStrict = iemVmxVmexitInstrIo(pVCpu, VMXINSTRID_IO_OUT, u16Port, RT_BOOL(bImmAndEffAddrMode & 0x80), cbReg, cbInstr);
    74257433        if (rcStrict != VINF_VMX_INTERCEPT_NOT_ACTIVE)
    74267434            return rcStrict;
    74277435    }
    74287436#else
    7429     RT_NOREF(fImm);
     7437    RT_NOREF(bImmAndEffAddrMode);
    74307438#endif
    74317439
     
    74377445    {
    74387446        uint8_t cAddrSizeBits;
    7439         switch (pVCpu->iem.s.enmEffAddrMode)
     7447        switch (bImmAndEffAddrMode & 0xf)
    74407448        {
    74417449            case IEMMODE_16BIT: cAddrSizeBits = 16; break;
     
    74557463        }
    74567464    }
     7465#else
     7466    RT_NOREF(bImmAndEffAddrMode);
    74577467#endif
    74587468
     
    75007510 *
    75017511 * @param   cbReg       The register size.
    7502  */
    7503 IEM_CIMPL_DEF_1(iemCImpl_out_DX_eAX, uint8_t, cbReg)
    7504 {
    7505     return IEM_CIMPL_CALL_3(iemCImpl_out, pVCpu->cpum.GstCtx.dx, false /* fImm */, cbReg);
     7512 * @param   enmEffAddrMode  Effective address mode.
     7513 */
     7514IEM_CIMPL_DEF_2(iemCImpl_out_DX_eAX, uint8_t, cbReg, IEMMODE, enmEffAddrMode)
     7515{
     7516    return IEM_CIMPL_CALL_3(iemCImpl_out, pVCpu->cpum.GstCtx.dx, cbReg, 0 /* fImm */ | enmEffAddrMode);
    75067517}
    75077518
     
    76247635    {
    76257636        Log2(("hlt: Guest intercept -> #VMEXIT\n"));
    7626         IEM_SVM_UPDATE_NRIP(pVCpu);
     7637        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    76277638        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_HLT, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    76287639    }
     
    77147725    {
    77157726        Log2(("monitor: Guest intercept -> #VMEXIT\n"));
    7716         IEM_SVM_UPDATE_NRIP(pVCpu);
     7727        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    77177728        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_MONITOR, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    77187729    }
     
    78057816    {
    78067817        Log2(("mwait: Guest intercept (monitor hardware armed) -> #VMEXIT\n"));
    7807         IEM_SVM_UPDATE_NRIP(pVCpu);
     7818        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    78087819        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_MWAIT_ARMED, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    78097820    }
     
    78117822    {
    78127823        Log2(("mwait: Guest intercept -> #VMEXIT\n"));
    7813         IEM_SVM_UPDATE_NRIP(pVCpu);
     7824        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    78147825        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_MWAIT, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    78157826    }
     
    79717982    {
    79727983        Log2(("cpuid: Guest intercept -> #VMEXIT\n"));
    7973         IEM_SVM_UPDATE_NRIP(pVCpu);
     7984        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    79747985        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_CPUID, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    79757986    }
     
    83198330        {
    83208331            Log2(("xsetbv: Guest intercept -> #VMEXIT\n"));
    8321             IEM_SVM_UPDATE_NRIP(pVCpu);
     8332            IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    83228333            IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_XSETBV, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    83238334        }
     
    95769587 *
    95779588 * @param   iStReg              The other stack register.
    9578  */
    9579 IEM_CIMPL_DEF_1(iemCImpl_fxch_underflow, uint8_t, iStReg)
     9589 * @param   uFpuOpcode          The FPU opcode (for simplicity).
     9590 */
     9591IEM_CIMPL_DEF_2(iemCImpl_fxch_underflow, uint8_t, iStReg, uint16_t, uFpuOpcode)
    95809592{
    95819593    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_CR0 | CPUMCTX_EXTRN_X87);
     
    96169628    }
    96179629
    9618     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
     9630    iemFpuUpdateOpcodeAndIpWorkerEx(pVCpu, pFpuCtx, uFpuOpcode);
    96199631    iemHlpUsedFpu(pVCpu);
    96209632    return iemRegAddToRipAndFinishingClearingRF(pVCpu, cbInstr);
     
    96259637 * Implements 'FCOMI', 'FCOMIP', 'FUCOMI', and 'FUCOMIP'.
    96269638 *
    9627  * @param   iStReg          The other stack register.
    9628  * @param   pfnAImpl        The assembly comparison implementation.
    9629  * @param   fPop            Whether we should pop the stack when done or not.
    9630  */
    9631 IEM_CIMPL_DEF_3(iemCImpl_fcomi_fucomi, uint8_t, iStReg, PFNIEMAIMPLFPUR80EFL, pfnAImpl, bool, fPop)
     9639 * @param   iStReg              The other stack register.
     9640 * @param   pfnAImpl            The assembly comparison implementation.
     9641 * @param   uPopAndFpuOpcode    Bits 15-0: The FPU opcode.
     9642 *                              Bit  31: Whether we should pop the stack when
     9643 *                              done or not.
     9644 */
     9645IEM_CIMPL_DEF_3(iemCImpl_fcomi_fucomi, uint8_t, iStReg, PFNIEMAIMPLFPUR80EFL, pfnAImpl, uint32_t, uPopAndFpuOpcode)
    96329646{
    96339647    Assert(iStReg < 8);
     
    96489662     * Check if any of the register accesses causes #SF + #IA.
    96499663     */
     9664    bool           fPop  = RT_BOOL(uPopAndFpuOpcode & RT_BIT_32(31));
    96509665    unsigned const iReg1 = X86_FSW_TOP_GET(u16Fsw);
    96519666    unsigned const iReg2 = (iReg1 + iStReg) & X86_FSW_TOP_SMASK;
     
    96909705    }
    96919706
    9692     iemFpuUpdateOpcodeAndIpWorker(pVCpu, pFpuCtx);
     9707    iemFpuUpdateOpcodeAndIpWorkerEx(pVCpu, pFpuCtx, (uint16_t)uPopAndFpuOpcode);
    96939708    iemHlpUsedFpu(pVCpu);
    96949709    return iemRegAddToRipAndFinishingClearingRF(pVCpu, cbInstr);
  • trunk/src/VBox/VMM/VMMAll/IEMAllCImplSvmInstr.cpp

    r99220 r99984  
    949949 * @returns VBox strict status code.
    950950 * @param   pVCpu       The cross context virtual CPU structure of the calling thread.
     951 * @param   cbInstr     The length of the instruction in bytes triggering the
     952 *                      event.
    951953 * @param   u8Vector    The interrupt or exception vector.
    952954 * @param   fFlags      The exception flags (see IEM_XCPT_FLAGS_XXX).
     
    954956 * @param   uCr2        The CR2 value in case of a \#PF exception.
    955957 */
    956 VBOXSTRICTRC iemHandleSvmEventIntercept(PVMCPUCC pVCpu, uint8_t u8Vector, uint32_t fFlags, uint32_t uErr, uint64_t uCr2) RT_NOEXCEPT
     958VBOXSTRICTRC iemHandleSvmEventIntercept(PVMCPUCC pVCpu, uint8_t cbInstr, uint8_t u8Vector, uint32_t fFlags,
     959                                        uint32_t uErr, uint64_t uCr2) RT_NOEXCEPT
    957960{
    958961    Assert(CPUMIsGuestInSvmNestedHwVirtMode(IEM_GET_CTX(pVCpu)));
     
    981984    {
    982985        Log2(("iemHandleSvmNstGstEventIntercept: ICEBP intercept -> #VMEXIT\n"));
    983         IEM_SVM_UPDATE_NRIP(pVCpu);
     986        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    984987        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_ICEBP, 0 /* uExitInfo1 */, 0 /* uExitInfo2 */);
    985988    }
     
    10121015        }
    10131016        if (u8Vector == X86_XCPT_BR)
    1014             IEM_SVM_UPDATE_NRIP(pVCpu);
     1017            IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    10151018        Log2(("iemHandleSvmNstGstEventIntercept: Xcpt intercept u32InterceptXcpt=%#RX32 u8Vector=%#x "
    10161019              "uExitInfo1=%#RX64 uExitInfo2=%#RX64 -> #VMEXIT\n", pVCpu->cpum.GstCtx.hwvirt.svm.Vmcb.ctrl.u32InterceptXcpt,
     
    10281031        uint64_t const uExitInfo1 = IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSvmDecodeAssists ? u8Vector : 0;
    10291032        Log2(("iemHandleSvmNstGstEventIntercept: Software INT intercept (u8Vector=%#x) -> #VMEXIT\n", u8Vector));
    1030         IEM_SVM_UPDATE_NRIP(pVCpu);
     1033        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    10311034        IEM_SVM_VMEXIT_RET(pVCpu, SVM_EXIT_SWINT, uExitInfo1, 0 /* uExitInfo2 */);
    10321035    }
     
    10741077    {
    10751078        Log3(("iemSvmHandleIOIntercept: u16Port=%#x (%u) -> #VMEXIT\n", u16Port, u16Port));
    1076         IEM_SVM_UPDATE_NRIP(pVCpu);
     1079        IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    10771080        return iemSvmVmexit(pVCpu, SVM_EXIT_IOIO, IoExitInfo.u, pVCpu->cpum.GstCtx.rip + cbInstr);
    10781081    }
     
    11031106 * @param   cbInstr     The length of the MSR read/write instruction in bytes.
    11041107 */
    1105 VBOXSTRICTRC iemSvmHandleMsrIntercept(PVMCPUCC pVCpu, uint32_t idMsr, bool fWrite) RT_NOEXCEPT
     1108VBOXSTRICTRC iemSvmHandleMsrIntercept(PVMCPUCC pVCpu, uint32_t idMsr, bool fWrite, uint8_t cbInstr) RT_NOEXCEPT
    11061109{
    11071110    /*
     
    11311134        if (pVCpu->cpum.GstCtx.hwvirt.svm.abMsrBitmap[offMsrpm] & RT_BIT(uMsrpmBit))
    11321135        {
    1133             IEM_SVM_UPDATE_NRIP(pVCpu);
     1136            IEM_SVM_UPDATE_NRIP(pVCpu, cbInstr);
    11341137            return iemSvmVmexit(pVCpu, SVM_EXIT_MSR, uExitInfo1, 0 /* uExitInfo2 */);
    11351138        }
     
    15521555
    15531556    if (fCheckIntercept)
    1554         IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_PAUSE, SVM_EXIT_PAUSE, 0, 0);
     1557        IEM_SVM_CHECK_INSTR_INTERCEPT(pVCpu, SVM_CTRL_INTERCEPT_PAUSE, SVM_EXIT_PAUSE, 0, 0, cbInstr);
    15551558
    15561559    return iemRegAddToRipAndFinishingClearingRF(pVCpu, cbInstr);
  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsOneByte.cpp.h

    r99814 r99984  
    85668566    /** @todo Testcase: Check if this raises \#MF?  Intel mentioned it not. AMD
    85678567     *        indicates that it does. */
    8568     IEM_MC_BEGIN(1, 3);
     8568    IEM_MC_BEGIN(2, 3);
    85698569    IEM_MC_LOCAL(PCRTFLOAT80U,          pr80Value1);
    85708570    IEM_MC_LOCAL(PCRTFLOAT80U,          pr80Value2);
    85718571    IEM_MC_LOCAL(IEMFPURESULT,          FpuRes);
    85728572    IEM_MC_ARG_CONST(uint8_t,           iStReg, /*=*/ IEM_GET_MODRM_RM_8(bRm), 0);
     8573    IEM_MC_ARG_CONST(uint16_t,          uFpuOpcode, /*=*/ pVCpu->iem.s.uFpuOpcode, 1);
    85738574    IEM_MC_MAYBE_RAISE_DEVICE_NOT_AVAILABLE();
    85748575    IEM_MC_MAYBE_RAISE_FPU_XCPT();
     
    85808581        IEM_MC_STORE_FPU_RESULT(FpuRes, 0);
    85818582    } IEM_MC_ELSE() {
    8582         IEM_MC_CALL_CIMPL_1(iemCImpl_fxch_underflow, iStReg);
     8583        IEM_MC_CALL_CIMPL_2(iemCImpl_fxch_underflow, iStReg, uFpuOpcode);
    85838584    } IEM_MC_ENDIF();
    85848585
     
    98599860{
    98609861    IEMOP_MNEMONIC(fucomi_st0_stN, "fucomi st0,stN");
    9861     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_fcomi_fucomi, IEM_GET_MODRM_RM_8(bRm), iemAImpl_fucomi_r80_by_r80, false /*fPop*/);
     9862    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_fcomi_fucomi, IEM_GET_MODRM_RM_8(bRm), iemAImpl_fucomi_r80_by_r80,
     9863                                   0 /*fPop*/ | pVCpu->iem.s.uFpuOpcode);
    98629864}
    98639865
     
    98679869{
    98689870    IEMOP_MNEMONIC(fcomi_st0_stN, "fcomi st0,stN");
    9869     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_fcomi_fucomi, IEM_GET_MODRM_RM_8(bRm), iemAImpl_fcomi_r80_by_r80, false /*fPop*/);
     9871    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_fcomi_fucomi, IEM_GET_MODRM_RM_8(bRm), iemAImpl_fcomi_r80_by_r80,
     9872                                   false /*fPop*/ | pVCpu->iem.s.uFpuOpcode);
    98709873}
    98719874
     
    1078910792{
    1079010793    IEMOP_MNEMONIC(fucomip_st0_stN, "fucomip st0,stN");
    10791     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_fcomi_fucomi, IEM_GET_MODRM_RM_8(bRm), iemAImpl_fcomi_r80_by_r80, true /*fPop*/);
     10794    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_fcomi_fucomi, IEM_GET_MODRM_RM_8(bRm), iemAImpl_fcomi_r80_by_r80,
     10795                                   RT_BIT_32(31) /*fPop*/ | pVCpu->iem.s.uFpuOpcode);
    1079210796}
    1079310797
     
    1079710801{
    1079810802    IEMOP_MNEMONIC(fcomip_st0_stN, "fcomip st0,stN");
    10799     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_fcomi_fucomi, IEM_GET_MODRM_RM_8(bRm), iemAImpl_fcomi_r80_by_r80, true /*fPop*/);
     10803    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_fcomi_fucomi, IEM_GET_MODRM_RM_8(bRm), iemAImpl_fcomi_r80_by_r80,
     10804                                   RT_BIT_32(31) /*fPop*/ | pVCpu->iem.s.uFpuOpcode);
    1080010805}
    1080110806
     
    1135411359    uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1135511360    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    11356     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_in, u8Imm, true /* fImm */, 1);
     11361    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_in, u8Imm, 1, 0x80 /* fImm */ | pVCpu->iem.s.enmEffAddrMode);
    1135711362}
    1135811363
     
    1136411369    uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1136511370    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    11366     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_in, u8Imm, true /* fImm */, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
     11371    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_in, u8Imm, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4,
     11372                                   0x80 /* fImm */ | pVCpu->iem.s.enmEffAddrMode);
    1136711373}
    1136811374
     
    1137411380    uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1137511381    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    11376     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_out, u8Imm, true /* fImm */, 1);
     11382    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_out, u8Imm, 1, 0x80 /* fImm */ | pVCpu->iem.s.enmEffAddrMode);
    1137711383}
    1137811384
     
    1138411390    uint8_t u8Imm; IEM_OPCODE_GET_NEXT_U8(&u8Imm);
    1138511391    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    11386     return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_out, u8Imm, true /* fImm */, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
     11392    return IEM_MC_DEFER_TO_CIMPL_3(iemCImpl_out, u8Imm, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4,
     11393                                   0x80 /* fImm */ | pVCpu->iem.s.enmEffAddrMode);
    1138711394}
    1138811395
     
    1149411501    IEMOP_MNEMONIC(in_AL_DX, "in  AL,DX");
    1149511502    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    11496     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_in_eAX_DX, 1);
     11503    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_in_eAX_DX, 1, pVCpu->iem.s.enmEffAddrMode);
    1149711504}
    1149811505
     
    1150311510    IEMOP_MNEMONIC(in_eAX_DX, "in  eAX,DX");
    1150411511    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    11505     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_in_eAX_DX, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
     11512    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_in_eAX_DX, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4,
     11513                                   pVCpu->iem.s.enmEffAddrMode);
    1150611514}
    1150711515
     
    1151211520    IEMOP_MNEMONIC(out_DX_AL, "out DX,AL");
    1151311521    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    11514     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_out_DX_eAX, 1);
     11522    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_out_DX_eAX, 1, pVCpu->iem.s.enmEffAddrMode);
    1151511523}
    1151611524
     
    1152111529    IEMOP_MNEMONIC(out_DX_eAX, "out DX,eAX");
    1152211530    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    11523     return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_out_DX_eAX, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4);
     11531    return IEM_MC_DEFER_TO_CIMPL_2(iemCImpl_out_DX_eAX, pVCpu->iem.s.enmEffOpSize == IEMMODE_16BIT ? 2 : 4,
     11532                                   pVCpu->iem.s.enmEffAddrMode);
    1152411533}
    1152511534
  • trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsTwoByte0f.cpp.h

    r99337 r99984  
    19731973    IEMOP_MNEMONIC(sysret, "sysret");  /** @todo 386 LOADALL   */
    19741974    IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
    1975     return IEM_MC_DEFER_TO_CIMPL_0(iemCImpl_sysret);
     1975    return IEM_MC_DEFER_TO_CIMPL_1(iemCImpl_sysret, pVCpu->iem.s.enmEffOpSize);
    19761976}
    19771977
  • trunk/src/VBox/VMM/include/IEMInline.h

    r99983 r99984  
    23682368
    23692369
    2370 #ifndef IEM_WITH_OPAQUE_DECODER_STATE
    2371 /**
    2372  * Updates the FOP, FPU.CS and FPUIP registers.
     2370/**
     2371 * Updates the FOP, FPU.CS and FPUIP registers, extended version.
    23732372 *
    23742373 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
    23752374 * @param   pFpuCtx             The FPU context.
    2376  */
    2377 DECLINLINE(void) iemFpuUpdateOpcodeAndIpWorker(PVMCPUCC pVCpu, PX86FXSTATE pFpuCtx) RT_NOEXCEPT
    2378 {
    2379     Assert(pVCpu->iem.s.uFpuOpcode != UINT16_MAX);
    2380     pFpuCtx->FOP = pVCpu->iem.s.uFpuOpcode;
     2375 * @param   uFpuOpcode          The FPU opcode value (see IEMCPU::uFpuOpcode).
     2376 */
     2377DECLINLINE(void) iemFpuUpdateOpcodeAndIpWorkerEx(PVMCPUCC pVCpu, PX86FXSTATE pFpuCtx, uint16_t uFpuOpcode) RT_NOEXCEPT
     2378{
     2379    Assert(uFpuOpcode != UINT16_MAX);
     2380    pFpuCtx->FOP = uFpuOpcode;
    23812381    /** @todo x87.CS and FPUIP needs to be kept seperately. */
    23822382    if (IEM_IS_REAL_OR_V86_MODE(pVCpu))
     
    23952395        *(uint64_t *)&pFpuCtx->FPUIP = pVCpu->cpum.GstCtx.rip;
    23962396}
     2397
     2398
     2399#ifndef IEM_WITH_OPAQUE_DECODER_STATE
     2400/**
     2401 * Updates the FOP, FPU.CS and FPUIP registers.
     2402 *
     2403 * @param   pVCpu               The cross context virtual CPU structure of the calling thread.
     2404 * @param   pFpuCtx             The FPU context.
     2405 */
     2406DECLINLINE(void) iemFpuUpdateOpcodeAndIpWorker(PVMCPUCC pVCpu, PX86FXSTATE pFpuCtx) RT_NOEXCEPT
     2407{
     2408    Assert(pVCpu->iem.s.uFpuOpcode != UINT16_MAX);
     2409    iemFpuUpdateOpcodeAndIpWorkerEx(pVCpu, pFpuCtx, pVCpu->iem.s.uFpuOpcode);
     2410}
    23972411#endif /* !IEM_WITH_OPAQUE_DECODER_STATE */
    2398 
    2399 
    24002412
    24012413
  • trunk/src/VBox/VMM/include/IEMInternal.h

    r99982 r99984  
    38163816 *  NRIP if needed.
    38173817 */
    3818 # define IEM_SVM_CHECK_INSTR_INTERCEPT(a_pVCpu, a_Intercept, a_uExitCode, a_uExitInfo1, a_uExitInfo2) \
     3818# define IEM_SVM_CHECK_INSTR_INTERCEPT(a_pVCpu, a_Intercept, a_uExitCode, a_uExitInfo1, a_uExitInfo2, a_cbInstr) \
    38193819    do \
    38203820    { \
    38213821        if (IEM_SVM_IS_CTRL_INTERCEPT_SET(a_pVCpu, a_Intercept)) \
    38223822        { \
    3823             IEM_SVM_UPDATE_NRIP(a_pVCpu); \
     3823            IEM_SVM_UPDATE_NRIP(a_pVCpu, a_cbInstr); \
    38243824            IEM_SVM_VMEXIT_RET(a_pVCpu, a_uExitCode, a_uExitInfo1, a_uExitInfo2); \
    38253825        } \
     
    38273827
    38283828/** Checks and handles SVM nested-guest CR0 read intercept. */
    3829 # define IEM_SVM_CHECK_READ_CR0_INTERCEPT(a_pVCpu, a_uExitInfo1, a_uExitInfo2) \
     3829# define IEM_SVM_CHECK_READ_CR0_INTERCEPT(a_pVCpu, a_uExitInfo1, a_uExitInfo2, a_cbInstr) \
    38303830    do \
    38313831    { \
     
    38343834        else \
    38353835        { \
    3836             IEM_SVM_UPDATE_NRIP(a_pVCpu); \
     3836            IEM_SVM_UPDATE_NRIP(a_pVCpu, a_cbInstr); \
    38373837            IEM_SVM_VMEXIT_RET(a_pVCpu, SVM_EXIT_READ_CR0, a_uExitInfo1, a_uExitInfo2); \
    38383838        } \
     
    38423842 * Updates the NextRIP (NRI) field in the nested-guest VMCB.
    38433843 */
    3844 # define IEM_SVM_UPDATE_NRIP(a_pVCpu) \
     3844# define IEM_SVM_UPDATE_NRIP(a_pVCpu, a_cbInstr) \
    38453845    do { \
    38463846        if (IEM_GET_GUEST_CPU_FEATURES(a_pVCpu)->fSvmNextRipSave) \
    3847             CPUMGuestSvmUpdateNRip(a_pVCpu, IEM_GET_CTX(a_pVCpu), IEM_GET_INSTR_LEN(a_pVCpu)); \
     3847            CPUMGuestSvmUpdateNRip(a_pVCpu, IEM_GET_CTX(a_pVCpu), (a_cbInstr)); \
    38483848    } while (0)
    38493849
    38503850#else
    3851 # define IEM_SVM_IS_CTRL_INTERCEPT_SET(a_pVCpu, a_Intercept)                              (false)
    3852 # define IEM_SVM_IS_READ_CR_INTERCEPT_SET(a_pVCpu, a_uCr)                                 (false)
    3853 # define IEM_SVM_IS_WRITE_CR_INTERCEPT_SET(a_pVCpu, a_uCr)                                (false)
    3854 # define IEM_SVM_IS_READ_DR_INTERCEPT_SET(a_pVCpu, a_uDr)                                 (false)
    3855 # define IEM_SVM_IS_WRITE_DR_INTERCEPT_SET(a_pVCpu, a_uDr)                                (false)
    3856 # define IEM_SVM_IS_XCPT_INTERCEPT_SET(a_pVCpu, a_uVector)                                (false)
    3857 # define IEM_SVM_VMEXIT_RET(a_pVCpu, a_uExitCode, a_uExitInfo1, a_uExitInfo2)             do { return VERR_SVM_IPE_1; } while (0)
    3858 # define IEM_SVM_CRX_VMEXIT_RET(a_pVCpu, a_uExitCode, a_enmAccessCrX, a_iGReg)            do { return VERR_SVM_IPE_1; } while (0)
    3859 # define IEM_SVM_CHECK_INSTR_INTERCEPT(a_pVCpu, a_Intercept, a_uExitCode, a_uExitInfo1, a_uExitInfo2)   do { } while (0)
    3860 # define IEM_SVM_CHECK_READ_CR0_INTERCEPT(a_pVCpu, a_uExitInfo1, a_uExitInfo2)                          do { } while (0)
    3861 # define IEM_SVM_UPDATE_NRIP(a_pVCpu)                                                     do { } while (0)
     3851# define IEM_SVM_IS_CTRL_INTERCEPT_SET(a_pVCpu, a_Intercept)                                (false)
     3852# define IEM_SVM_IS_READ_CR_INTERCEPT_SET(a_pVCpu, a_uCr)                                   (false)
     3853# define IEM_SVM_IS_WRITE_CR_INTERCEPT_SET(a_pVCpu, a_uCr)                                  (false)
     3854# define IEM_SVM_IS_READ_DR_INTERCEPT_SET(a_pVCpu, a_uDr)                                   (false)
     3855# define IEM_SVM_IS_WRITE_DR_INTERCEPT_SET(a_pVCpu, a_uDr)                                  (false)
     3856# define IEM_SVM_IS_XCPT_INTERCEPT_SET(a_pVCpu, a_uVector)                                  (false)
     3857# define IEM_SVM_VMEXIT_RET(a_pVCpu, a_uExitCode, a_uExitInfo1, a_uExitInfo2)               do { return VERR_SVM_IPE_1; } while (0)
     3858# define IEM_SVM_CRX_VMEXIT_RET(a_pVCpu, a_uExitCode, a_enmAccessCrX, a_iGReg)              do { return VERR_SVM_IPE_1; } while (0)
     3859# define IEM_SVM_CHECK_INSTR_INTERCEPT(a_pVCpu, a_Intercept, a_uExitCode, \
     3860                                       a_uExitInfo1, a_uExitInfo2, a_cbInstr)               do { } while (0)
     3861# define IEM_SVM_CHECK_READ_CR0_INTERCEPT(a_pVCpu, a_uExitInfo1, a_uExitInfo2, a_cbInstr)   do { } while (0)
     3862# define IEM_SVM_UPDATE_NRIP(a_pVCpu, a_cbInstr)                                            do { } while (0)
    38623863
    38633864#endif
     
    41784179IEM_CIMPL_PROTO_0(iemCImpl_loadall286);
    41794180IEM_CIMPL_PROTO_0(iemCImpl_syscall);
    4180 IEM_CIMPL_PROTO_0(iemCImpl_sysret);
     4181IEM_CIMPL_PROTO_1(iemCImpl_sysret, IEMMODE, enmEffOpSize);
    41814182IEM_CIMPL_PROTO_0(iemCImpl_sysenter);
    41824183IEM_CIMPL_PROTO_1(iemCImpl_sysexit, IEMMODE, enmEffOpSize);
     
    42194220IEM_CIMPL_PROTO_0(iemCImpl_rdmsr);
    42204221IEM_CIMPL_PROTO_0(iemCImpl_wrmsr);
    4221 IEM_CIMPL_PROTO_3(iemCImpl_in, uint16_t, u16Port, bool, fImm, uint8_t, cbReg);
    4222 IEM_CIMPL_PROTO_1(iemCImpl_in_eAX_DX, uint8_t, cbReg);
    4223 IEM_CIMPL_PROTO_3(iemCImpl_out, uint16_t, u16Port, bool, fImm, uint8_t, cbReg);
    4224 IEM_CIMPL_PROTO_1(iemCImpl_out_DX_eAX, uint8_t, cbReg);
     4222IEM_CIMPL_PROTO_3(iemCImpl_in, uint16_t, u16Port, uint8_t, cbReg, uint8_t, bImmAndEffAddrMode);
     4223IEM_CIMPL_PROTO_2(iemCImpl_in_eAX_DX, uint8_t, cbReg, IEMMODE, enmEffAddrMode);
     4224IEM_CIMPL_PROTO_3(iemCImpl_out, uint16_t, u16Port, uint8_t, cbReg, uint8_t, bImmAndEffAddrMode);
     4225IEM_CIMPL_PROTO_2(iemCImpl_out_DX_eAX, uint8_t, cbReg, IEMMODE, enmEffAddrMode);
    42254226IEM_CIMPL_PROTO_0(iemCImpl_cli);
    42264227IEM_CIMPL_PROTO_0(iemCImpl_sti);
     
    42564257IEM_CIMPL_PROTO_3(iemCImpl_frstor, IEMMODE, enmEffOpSize, uint8_t, iEffSeg, RTGCPTR, GCPtrEffSrc);
    42574258IEM_CIMPL_PROTO_1(iemCImpl_fldcw, uint16_t, u16Fcw);
    4258 IEM_CIMPL_PROTO_1(iemCImpl_fxch_underflow, uint8_t, iStReg);
    4259 IEM_CIMPL_PROTO_3(iemCImpl_fcomi_fucomi, uint8_t, iStReg, PFNIEMAIMPLFPUR80EFL, pfnAImpl, bool, fPop);
     4259IEM_CIMPL_PROTO_2(iemCImpl_fxch_underflow, uint8_t, iStReg, uint16_t, uFpuOpcode);
     4260IEM_CIMPL_PROTO_3(iemCImpl_fcomi_fucomi, uint8_t, iStReg, PFNIEMAIMPLFPUR80EFL, pfnAImpl, uint32_t, uPopAndFpuOpcode);
    42604261/** @} */
    42614262
     
    44504451#ifdef VBOX_WITH_NESTED_HWVIRT_SVM
    44514452VBOXSTRICTRC    iemSvmVmexit(PVMCPUCC pVCpu, uint64_t uExitCode, uint64_t uExitInfo1, uint64_t uExitInfo2) RT_NOEXCEPT;
    4452 VBOXSTRICTRC    iemHandleSvmEventIntercept(PVMCPUCC pVCpu, uint8_t u8Vector, uint32_t fFlags, uint32_t uErr, uint64_t uCr2) RT_NOEXCEPT;
     4453VBOXSTRICTRC    iemHandleSvmEventIntercept(PVMCPUCC pVCpu, uint8_t cbInstr, uint8_t u8Vector, uint32_t fFlags, uint32_t uErr, uint64_t uCr2) RT_NOEXCEPT;
    44534454VBOXSTRICTRC    iemSvmHandleIOIntercept(PVMCPUCC pVCpu, uint16_t u16Port, SVMIOIOTYPE enmIoType, uint8_t cbReg,
    44544455                                        uint8_t cAddrSizeBits, uint8_t iEffSeg, bool fRep, bool fStrIo, uint8_t cbInstr) RT_NOEXCEPT;
    4455 VBOXSTRICTRC    iemSvmHandleMsrIntercept(PVMCPUCC pVCpu, uint32_t idMsr, bool fWrite) RT_NOEXCEPT;
     4456VBOXSTRICTRC    iemSvmHandleMsrIntercept(PVMCPUCC pVCpu, uint32_t idMsr, bool fWrite, uint8_t cbInstr) RT_NOEXCEPT;
    44564457IEM_CIMPL_PROTO_0(iemCImpl_vmrun);
    44574458IEM_CIMPL_PROTO_0(iemCImpl_vmload);
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