VirtualBox

Changeset 73959 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
Aug 29, 2018 3:24:49 PM (6 years ago)
Author:
vboxsync
Message:

VMM/IEM, HM: Nested VMX: bugref:9180 Use VMXEXITINFO to pass decoder info to IEM. Avoid unnecessarily constructing VM-exit info.
in IEM for VMX instructions.

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

Legend:

Unmodified
Added
Removed

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

    r73937 r73959  
    952952#endif
    953953
    954 #ifdef VBOX_WITH_NESTED_HWVIRT_VMX
    955 IEM_STATIC VBOXSTRICTRC     iemVmxVmxon(PVMCPU pVCpu, uint8_t cbInstr, RTGCPHYS GCPtrVmxon, PCVMXEXITINSTRINFO pExitInstrInfo,
    956                                         RTGCPTR GCPtrDisp);
    957 #endif
    958954
    959955/**
    … …  
    1554915545 * @param   pVCpu           The cross context virtual CPU structure of the calling EMT.
    1555015546 * @param   cbInstr         The instruction length in bytes.
    15551  * @param   GCPtrVmxon      The linear address of the VMCS pointer.
    15552  * @param   uExitInstrInfo  The VM-exit instruction information field.
    15553  * @param   GCPtrDisp       The displacement field for @a GCPtrVmcs if any.
     15547 * @param   iEffSeg         The effective segment register to use with @a GCPtrVmcs.
     15548 * @param   GCPtrVmcs       The linear address of the VMCS pointer.
     15549 * @param   pExitInfo       Pointer to the VM-exit information struct.
    1555415550 * @thread  EMT(pVCpu)
    1555515551 */
    15556 VMM_INT_DECL(VBOXSTRICTRC) IEMExecDecodedVmptrld(PVMCPU pVCpu, uint8_t cbInstr, RTGCPHYS GCPtrVmcs, uint32_t uExitInstrInfo,
    15557                                                  RTGCPTR GCPtrDisp)
     15552VMM_INT_DECL(VBOXSTRICTRC) IEMExecDecodedVmptrld(PVMCPU pVCpu, uint8_t cbInstr, uint8_t iEffSeg, RTGCPHYS GCPtrVmcs,
     15553                                                 PCVMXVEXITINFO pExitInfo)
    1555815554{
    1555915555    IEMEXEC_ASSERT_INSTR_LEN_RETURN(cbInstr, 3);
    1556015556    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_HWVIRT);
     15557    Assert(pExitInfo);
    1556115558
    1556215559    iemInitExec(pVCpu, false /*fBypassHandlers*/);
    15563     PCVMXEXITINSTRINFO pExitInstrInfo = (PCVMXEXITINSTRINFO)&uExitInstrInfo;
    15564     VBOXSTRICTRC rcStrict = iemVmxVmptrld(pVCpu, cbInstr, GCPtrVmcs, pExitInstrInfo, GCPtrDisp);
     15560    VBOXSTRICTRC rcStrict = iemVmxVmptrld(pVCpu, cbInstr, iEffSeg, GCPtrVmcs, pExitInfo);
    1556515561    if (pVCpu->iem.s.cActiveMappings)
    1556615562        iemMemRollback(pVCpu);
    … …  
    1557515571 * @param   pVCpu           The cross context virtual CPU structure of the calling EMT.
    1557615572 * @param   cbInstr         The instruction length in bytes.
    15577  * @param   GCPtrVmxon      The linear address of where to store the VMCS pointer.
    15578  * @param   uExitInstrInfo  The VM-exit instruction information field.
    15579  * @param   GCPtrDisp       The displacement field for @a GCPtrVmcs if any.
     15573 * @param   iEffSeg         The effective segment register to use with @a GCPtrVmcs.
     15574 * @param   GCPtrVmcs       The linear address of the VMCS pointer.
     15575 * @param   pExitInfo       Pointer to the VM-exit information struct.
    1558015576 * @thread  EMT(pVCpu)
    1558115577 */
    15582 VMM_INT_DECL(VBOXSTRICTRC) IEMExecDecodedVmptrst(PVMCPU pVCpu, uint8_t cbInstr, RTGCPHYS GCPtrVmcs, uint32_t uExitInstrInfo,
    15583                                                  RTGCPTR GCPtrDisp)
     15578VMM_INT_DECL(VBOXSTRICTRC) IEMExecDecodedVmptrst(PVMCPU pVCpu, uint8_t cbInstr, uint8_t iEffSeg, RTGCPHYS GCPtrVmcs,
     15579                                                 PCVMXVEXITINFO pExitInfo)
    1558415580{
    1558515581    IEMEXEC_ASSERT_INSTR_LEN_RETURN(cbInstr, 3);
    1558615582    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_HWVIRT);
     15583    Assert(pExitInfo);
    1558715584
    1558815585    iemInitExec(pVCpu, false /*fBypassHandlers*/);
    15589     PCVMXEXITINSTRINFO pExitInstrInfo = (PCVMXEXITINSTRINFO)&uExitInstrInfo;
    15590     VBOXSTRICTRC rcStrict = iemVmxVmptrst(pVCpu, cbInstr, GCPtrVmcs, pExitInstrInfo, GCPtrDisp);
     15586    VBOXSTRICTRC rcStrict = iemVmxVmptrst(pVCpu, cbInstr, iEffSeg, GCPtrVmcs, pExitInfo);
    1559115587    if (pVCpu->iem.s.cActiveMappings)
    1559215588        iemMemRollback(pVCpu);
    … …  
    1560115597 * @param   pVCpu           The cross context virtual CPU structure of the calling EMT.
    1560215598 * @param   cbInstr         The instruction length in bytes.
    15603  * @param   GCPtrVmxon      The linear address of the VMCS pointer.
    15604  * @param   uExitInstrInfo  The VM-exit instruction information field.
    15605  * @param   GCPtrDisp       The displacement field for @a GCPtrVmcs if any.
     15599 * @param   iEffSeg         The effective segment register to use with @a GCPtrVmcs.
     15600 * @param   GCPtrVmcs       The linear address of the VMCS pointer.
     15601 * @param   pExitInfo       Pointer to the VM-exit information struct.
    1560615602 * @thread  EMT(pVCpu)
    1560715603 */
    15608 VMM_INT_DECL(VBOXSTRICTRC) IEMExecDecodedVmclear(PVMCPU pVCpu, uint8_t cbInstr, RTGCPHYS GCPtrVmcs, uint32_t uExitInstrInfo,
    15609                                                  RTGCPTR GCPtrDisp)
     15604VMM_INT_DECL(VBOXSTRICTRC) IEMExecDecodedVmclear(PVMCPU pVCpu, uint8_t cbInstr, uint8_t iEffSeg, RTGCPHYS GCPtrVmcs,
     15605                                                 PCVMXVEXITINFO pExitInfo)
    1561015606{
    1561115607    IEMEXEC_ASSERT_INSTR_LEN_RETURN(cbInstr, 3);
    1561215608    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_HWVIRT);
     15609    Assert(pExitInfo);
    1561315610
    1561415611    iemInitExec(pVCpu, false /*fBypassHandlers*/);
    15615     PCVMXEXITINSTRINFO pExitInstrInfo = (PCVMXEXITINSTRINFO)&uExitInstrInfo;
    15616     VBOXSTRICTRC rcStrict = iemVmxVmclear(pVCpu, cbInstr, GCPtrVmcs, pExitInstrInfo, GCPtrDisp);
     15612    VBOXSTRICTRC rcStrict = iemVmxVmclear(pVCpu, cbInstr, iEffSeg, GCPtrVmcs, pExitInfo);
    1561715613    if (pVCpu->iem.s.cActiveMappings)
    1561815614        iemMemRollback(pVCpu);
    … …  
    1562715623 * @param   pVCpu           The cross context virtual CPU structure of the calling EMT.
    1562815624 * @param   cbInstr         The instruction length in bytes.
     15625 * @param   iEffSeg         The effective segment register to use with @a
     15626 *                          GCPtrVmxon.
    1562915627 * @param   GCPtrVmxon      The linear address of the VMXON pointer.
    15630  * @param   uExitInstrInfo  The VM-exit instruction information field.
    15631  * @param   GCPtrDisp       The displacement field for @a GCPtrVmxon if any.
     15628 * @param   pExitInfo       The VM-exit instruction information struct.
    1563215629 * @thread  EMT(pVCpu)
    1563315630 */
    15634 VMM_INT_DECL(VBOXSTRICTRC) IEMExecDecodedVmxon(PVMCPU pVCpu, uint8_t cbInstr, RTGCPHYS GCPtrVmxon, uint32_t uExitInstrInfo,
    15635                                                RTGCPTR GCPtrDisp)
     15631VMM_INT_DECL(VBOXSTRICTRC) IEMExecDecodedVmxon(PVMCPU pVCpu, uint8_t cbInstr, uint8_t iEffSeg, RTGCPHYS GCPtrVmxon,
     15632                                               PCVMXVEXITINFO pExitInfo)
    1563615633{
    1563715634    IEMEXEC_ASSERT_INSTR_LEN_RETURN(cbInstr, 3);
    1563815635    IEM_CTX_ASSERT(pVCpu, CPUMCTX_EXTRN_HWVIRT);
     15636    Assert(pExitInfo);
    1563915637
    1564015638    iemInitExec(pVCpu, false /*fBypassHandlers*/);
    15641     PCVMXEXITINSTRINFO pExitInstrInfo = (PCVMXEXITINSTRINFO)&uExitInstrInfo;
    15642     VBOXSTRICTRC rcStrict = iemVmxVmxon(pVCpu, cbInstr, GCPtrVmxon, pExitInstrInfo, GCPtrDisp);
     15639    VBOXSTRICTRC rcStrict = iemVmxVmxon(pVCpu, cbInstr, iEffSeg, GCPtrVmxon, pExitInfo);
    1564315640    if (pVCpu->iem.s.cActiveMappings)
    1564415641        iemMemRollback(pVCpu);

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

    r73937 r73959  
    10411041 * @param   pVCpu           The cross context virtual CPU structure.
    10421042 * @param   cbInstr         The instruction length.
     1043 * @param   iEffSeg         The effective segment register to use with @a u64Val.
     1044 *                          Pass UINT8_MAX if it is a register access.
     1045 * @param   enmEffAddrMode  The effective addressing mode.
     1046 * @param   u64Val          The value to write (or guest linear address to the
     1047 *                          value), @a iEffSeg will indicate if it's a memory
     1048 *                          operand.
    10431049 * @param   uFieldEnc       The VMCS field encoding.
    1044  * @param   u64Val          The value to write (or guest linear address to the
    1045  *                          value), @a pExitInstrInfo will indicate whether it's a
    1046  *                          memory or register operand.
    1047  * @param   pExitInstrInfo  Pointer to the VM-exit instruction information field.
    1048  * @param   GCPtrDisp       The displacement field for @a GCPtrVmcs if any.
    1049  */
    1050 IEM_STATIC VBOXSTRICTRC iemVmxVmwrite(PVMCPU pVCpu, uint8_t cbInstr, uint32_t uFieldEnc, uint64_t u64Val,
    1051                                       PCVMXEXITINSTRINFO pExitInstrInfo, RTGCPTR GCPtrDisp)
     1050 * @param   pExitInfo       Pointer to the VM-exit information struct.
     1051 */
     1052IEM_STATIC VBOXSTRICTRC iemVmxVmwrite(PVMCPU pVCpu, uint8_t cbInstr, uint8_t iEffSeg, IEMMODE enmEffAddrMode,
     1053                                      uint64_t u64Val, uint32_t uFieldEnc, PCVMXVEXITINFO pExitInfo)
    10521054{
    10531055    if (IEM_IS_VMX_NON_ROOT_MODE(pVCpu))
    10541056    {
    1055         RT_NOREF(GCPtrDisp);
     1057        RT_NOREF(pExitInfo);
    10561058        /** @todo NSTVMX: intercept. */
    10571059        /** @todo NSTVMX: VMCS shadowing intercept (VMREAD/VMWRITE bitmap). */
    … …  
    10891091
    10901092    /* If the VMWRITE instruction references memory, access the specified in memory operand. */
    1091     if (!pExitInstrInfo->VmreadVmwrite.fIsRegOperand)
    1092     {
    1093         uint8_t const uAddrSize = pExitInstrInfo->VmreadVmwrite.u3AddrSize;
    1094         static uint64_t const s_auAddrSizeMasks[] = { UINT64_C(0xffff), UINT64_C(0xffffffff), UINT64_C(0xffffffffffffffff), 0 };
    1095         AssertRCReturn(uAddrSize != 3, VERR_IEM_IPE_1);
    1096         RTGCPTR const GCPtrVal = u64Val & s_auAddrSizeMasks[uAddrSize];
     1093    bool const fIsRegOperand = iEffSeg == UINT8_MAX;
     1094    if (fIsRegOperand)
     1095    {
     1096        static uint64_t const s_auAddrSizeMasks[] = { UINT64_C(0xffff), UINT64_C(0xffffffff), UINT64_C(0xffffffffffffffff) };
     1097        Assert(enmEffAddrMode < RT_ELEMENTS(s_auAddrSizeMasks));
     1098        RTGCPTR const GCPtrVal = u64Val & s_auAddrSizeMasks[enmEffAddrMode];
    10971099
    10981100        /* Read the value from the specified guest memory location. */
    10991101        VBOXSTRICTRC rcStrict;
    11001102        if (pVCpu->iem.s.enmCpuMode == IEMMODE_64BIT)
    1101             rcStrict = iemMemFetchDataU64(pVCpu, &u64Val, pExitInstrInfo->VmreadVmwrite.iSegReg, GCPtrVal);
     1103            rcStrict = iemMemFetchDataU64(pVCpu, &u64Val, iEffSeg, GCPtrVal);
    11021104        else
    11031105        {
    11041106            uint32_t u32Val;
    1105             rcStrict = iemMemFetchDataU32(pVCpu, &u32Val, pExitInstrInfo->VmreadVmwrite.iSegReg, GCPtrVal);
     1107            rcStrict = iemMemFetchDataU32(pVCpu, &u32Val, iEffSeg, GCPtrVal);
    11061108            u64Val = u32Val;
    11071109        }
    … …  
    11821184 * @param   pVCpu           The cross context virtual CPU structure.
    11831185 * @param   cbInstr         The instruction length.
     1186 * @param   iEffSeg         The effective segment register to use with @a GCPtrVmcs.
    11841187 * @param   GCPtrVmcs       The linear address of the VMCS pointer.
    1185  * @param   pExitInstrInfo  Pointer to the VM-exit instruction information field.
    1186  * @param   GCPtrDisp       The displacement field for @a GCPtrVmcs if any.
     1188 * @param   pExitInfo       Pointer to the VM-exit information struct. Optional, can
     1189 *                          be NULL.
    11871190 *
    11881191 * @remarks Common VMX instruction checks are already expected to by the caller,
    11891192 *          i.e. VMX operation, CR4.VMXE, Real/V86 mode, EFER/CS.L checks.
    11901193 */
    1191 IEM_STATIC VBOXSTRICTRC iemVmxVmclear(PVMCPU pVCpu, uint8_t cbInstr, RTGCPHYS GCPtrVmcs, PCVMXEXITINSTRINFO pExitInstrInfo,
    1192                                       RTGCPTR GCPtrDisp)
     1194IEM_STATIC VBOXSTRICTRC iemVmxVmclear(PVMCPU pVCpu, uint8_t cbInstr, uint8_t iEffSeg, RTGCPHYS GCPtrVmcs,
     1195                                      PCVMXVEXITINFO pExitInfo)
    11931196{
    11941197    if (IEM_IS_VMX_NON_ROOT_MODE(pVCpu))
    11951198    {
    1196         RT_NOREF(GCPtrDisp);
     1199        RT_NOREF(pExitInfo);
    11971200        /** @todo NSTVMX: intercept. */
    11981201    }
    … …  
    12091212    /* Get the VMCS pointer from the location specified by the source memory operand. */
    12101213    RTGCPHYS GCPhysVmcs;
    1211     VBOXSTRICTRC rcStrict = iemMemFetchDataU64(pVCpu, &GCPhysVmcs, pExitInstrInfo->VmxXsave.iSegReg, GCPtrVmcs);
     1214    VBOXSTRICTRC rcStrict = iemMemFetchDataU64(pVCpu, &GCPhysVmcs, iEffSeg, GCPtrVmcs);
    12121215    if (RT_UNLIKELY(rcStrict != VINF_SUCCESS))
    12131216    {
    … …  
    12921295 * @param   pVCpu           The cross context virtual CPU structure.
    12931296 * @param   cbInstr         The instruction length.
     1297 * @param   iEffSeg         The effective segment register to use with @a GCPtrVmcs.
    12941298 * @param   GCPtrVmcs       The linear address of where to store the current VMCS
    12951299 *                          pointer.
    1296  * @param   pExitInstrInfo  Pointer to the VM-exit instruction information field.
    1297  * @param   GCPtrDisp       The displacement field for @a GCPtrVmcs if any.
     1300 * @param   pExitInfo       Pointer to the VM-exit information struct. Optional, can
     1301 *                          be NULL.
    12981302 *
    12991303 * @remarks Common VMX instruction checks are already expected to by the caller,
    13001304 *          i.e. VMX operation, CR4.VMXE, Real/V86 mode, EFER/CS.L checks.
    13011305 */
    1302 IEM_STATIC VBOXSTRICTRC iemVmxVmptrst(PVMCPU pVCpu, uint8_t cbInstr, RTGCPHYS GCPtrVmcs, PCVMXEXITINSTRINFO pExitInstrInfo,
    1303                                       RTGCPTR GCPtrDisp)
     1306IEM_STATIC VBOXSTRICTRC iemVmxVmptrst(PVMCPU pVCpu, uint8_t cbInstr, uint8_t iEffSeg, RTGCPHYS GCPtrVmcs,
     1307                                      PCVMXVEXITINFO pExitInfo)
    13041308{
    13051309    if (IEM_IS_VMX_NON_ROOT_MODE(pVCpu))
    13061310    {
    1307         RT_NOREF(GCPtrDisp);
     1311        RT_NOREF(pExitInfo);
    13081312        /** @todo NSTVMX: intercept. */
    13091313    }
    … …  
    13201324    /* Set the VMCS pointer to the location specified by the destination memory operand. */
    13211325    AssertCompile(NIL_RTGCPHYS == ~(RTGCPHYS)0U);
    1322     VBOXSTRICTRC rcStrict = iemMemStoreDataU64(pVCpu, pExitInstrInfo->VmxXsave.iSegReg, GCPtrVmcs,
    1323                                                IEM_VMX_GET_CURRENT_VMCS(pVCpu));
     1326    VBOXSTRICTRC rcStrict = iemMemStoreDataU64(pVCpu, iEffSeg, GCPtrVmcs, IEM_VMX_GET_CURRENT_VMCS(pVCpu));
    13241327    if (RT_LIKELY(rcStrict == VINF_SUCCESS))
    13251328    {
    … …  
    13421345 * @param   cbInstr         The instruction length.
    13431346 * @param   GCPtrVmcs       The linear address of the current VMCS pointer.
    1344  * @param   pExitInstrInfo  Pointer to the VM-exit instruction information field.
    1345  * @param   GCPtrDisp       The displacement field for @a GCPtrVmcs if any.
     1347 * @param   pExitInfo       Pointer to the virtual VM-exit information struct.
     1348 *                          Optional, can be NULL.
    13461349 *
    13471350 * @remarks Common VMX instruction checks are already expected to by the caller,
    13481351 *          i.e. VMX operation, CR4.VMXE, Real/V86 mode, EFER/CS.L checks.
    13491352 */
    1350 IEM_STATIC VBOXSTRICTRC iemVmxVmptrld(PVMCPU pVCpu, uint8_t cbInstr, RTGCPHYS GCPtrVmcs, PCVMXEXITINSTRINFO pExitInstrInfo,
    1351                                       RTGCPTR GCPtrDisp)
     1353IEM_STATIC VBOXSTRICTRC iemVmxVmptrld(PVMCPU pVCpu, uint8_t cbInstr, uint8_t iEffSeg, RTGCPHYS GCPtrVmcs,
     1354                                      PCVMXVEXITINFO pExitInfo)
    13521355{
    13531356    if (IEM_IS_VMX_NON_ROOT_MODE(pVCpu))
    13541357    {
    1355         RT_NOREF(GCPtrDisp);
     1358        RT_NOREF(pExitInfo);
    13561359        /** @todo NSTVMX: intercept. */
    13571360    }
    … …  
    13681371    /* Get the VMCS pointer from the location specified by the source memory operand. */
    13691372    RTGCPHYS GCPhysVmcs;
    1370     VBOXSTRICTRC rcStrict = iemMemFetchDataU64(pVCpu, &GCPhysVmcs, pExitInstrInfo->VmxXsave.iSegReg, GCPtrVmcs);
     1373    VBOXSTRICTRC rcStrict = iemMemFetchDataU64(pVCpu, &GCPhysVmcs, iEffSeg, GCPtrVmcs);
    13711374    if (RT_UNLIKELY(rcStrict != VINF_SUCCESS))
    13721375    {
    … …  
    14731476 * @param   pVCpu           The cross context virtual CPU structure.
    14741477 * @param   cbInstr         The instruction length.
     1478 * @param   iEffSeg         The effective segment register to use with @a
     1479 *                          GCPtrVmxon.
    14751480 * @param   GCPtrVmxon      The linear address of the VMXON pointer.
    1476  * @param   pExitInstrInfo  Pointer to the VM-exit instruction information field.
    1477  * @param   GCPtrDisp       The displacement field for @a GCPtrVmxon if any.
     1481 * @param   pExitInfo       Pointer to the VM-exit instruction information struct.
     1482 *                          Optional, can  be NULL.
    14781483 *
    14791484 * @remarks Common VMX instruction checks are already expected to by the caller,
    14801485 *          i.e. CR4.VMXE, Real/V86 mode, EFER/CS.L checks.
    14811486 */
    1482 IEM_STATIC VBOXSTRICTRC iemVmxVmxon(PVMCPU pVCpu, uint8_t cbInstr, RTGCPHYS GCPtrVmxon, PCVMXEXITINSTRINFO pExitInstrInfo,
    1483                                     RTGCPTR GCPtrDisp)
     1487IEM_STATIC VBOXSTRICTRC iemVmxVmxon(PVMCPU pVCpu, uint8_t cbInstr, uint8_t iEffSeg, RTGCPHYS GCPtrVmxon,
     1488                                    PCVMXVEXITINFO pExitInfo)
    14841489{
    14851490#if defined(VBOX_WITH_NESTED_HWVIRT_ONLY_IN_IEM) && !defined(IN_RING3)
    1486     RT_NOREF5(pVCpu, cbInstr, GCPtrVmxon, pExitInstrInfo, GCPtrDisp);
     1491    RT_NOREF5(pVCpu, cbInstr, iEffSeg, GCPtrVmxon, pExitInfo);
    14871492    return VINF_EM_RAW_EMULATE_INSTR;
    14881493#else
    … …  
    15341539        /* Get the VMXON pointer from the location specified by the source memory operand. */
    15351540        RTGCPHYS GCPhysVmxon;
    1536         VBOXSTRICTRC rcStrict = iemMemFetchDataU64(pVCpu, &GCPhysVmxon, pExitInstrInfo->VmxXsave.iSegReg, GCPtrVmxon);
     1541        VBOXSTRICTRC rcStrict = iemMemFetchDataU64(pVCpu, &GCPhysVmxon, iEffSeg, GCPtrVmxon);
    15371542        if (RT_UNLIKELY(rcStrict != VINF_SUCCESS))
    15381543        {
    … …  
    16251630    else if (IEM_IS_VMX_NON_ROOT_MODE(pVCpu))
    16261631    {
    1627         RT_NOREF(GCPtrDisp);
     1632        RT_NOREF(pExitInfo);
    16281633        /** @todo NSTVMX: intercept. */
    16291634    }
    … …  
    16511656 * Implements 'VMXON'.
    16521657 */
    1653 IEM_CIMPL_DEF_1(iemCImpl_vmxon, RTGCPTR, GCPtrVmxon)
    1654 {
    1655     RTGCPTR GCPtrDisp;
    1656     VMXEXITINSTRINFO ExitInstrInfo;
    1657     ExitInstrInfo.u = iemVmxGetExitInstrInfo(pVCpu, VMX_EXIT_VMXON, VMX_INSTR_ID_NONE, &GCPtrDisp);
    1658     return iemVmxVmxon(pVCpu, cbInstr, GCPtrVmxon, &ExitInstrInfo, GCPtrDisp);
     1658IEM_CIMPL_DEF_2(iemCImpl_vmxon, uint8_t, iEffSeg, RTGCPTR, GCPtrVmxon)
     1659{
     1660    return iemVmxVmxon(pVCpu, cbInstr, iEffSeg, GCPtrVmxon, NULL /* pExitInfo */);
    16591661}
    16601662
    … …  
    17251727 * Implements 'VMPTRLD'.
    17261728 */
    1727 IEM_CIMPL_DEF_1(iemCImpl_vmptrld, RTGCPTR, GCPtrVmcs)
    1728 {
    1729     RTGCPTR GCPtrDisp;
    1730     VMXEXITINSTRINFO ExitInstrInfo;
    1731     ExitInstrInfo.u = iemVmxGetExitInstrInfo(pVCpu, VMX_EXIT_VMPTRLD, VMX_INSTR_ID_NONE, &GCPtrDisp);
    1732     return iemVmxVmptrld(pVCpu, cbInstr, GCPtrVmcs, &ExitInstrInfo, GCPtrDisp);
     1729IEM_CIMPL_DEF_2(iemCImpl_vmptrld, uint8_t, iEffSeg, RTGCPTR, GCPtrVmcs)
     1730{
     1731    return iemVmxVmptrld(pVCpu, cbInstr, iEffSeg, GCPtrVmcs, NULL /* pExitInfo */);
    17331732}
    17341733
    … …  
    17371736 * Implements 'VMPTRST'.
    17381737 */
    1739 IEM_CIMPL_DEF_1(iemCImpl_vmptrst, RTGCPTR, GCPtrVmcs)
    1740 {
    1741     RTGCPTR GCPtrDisp;
    1742     VMXEXITINSTRINFO ExitInstrInfo;
    1743     ExitInstrInfo.u = iemVmxGetExitInstrInfo(pVCpu, VMX_EXIT_VMPTRST, VMX_INSTR_ID_NONE, &GCPtrDisp);
    1744     return iemVmxVmptrst(pVCpu, cbInstr, GCPtrVmcs, &ExitInstrInfo, GCPtrDisp);
     1738IEM_CIMPL_DEF_2(iemCImpl_vmptrst, uint8_t, iEffSeg, RTGCPTR, GCPtrVmcs)
     1739{
     1740    return iemVmxVmptrst(pVCpu, cbInstr, iEffSeg, GCPtrVmcs, NULL /* pExitInfo */);
    17451741}
    17461742
    … …  
    17491745 * Implements 'VMCLEAR'.
    17501746 */
    1751 IEM_CIMPL_DEF_1(iemCImpl_vmclear, RTGCPTR, GCPtrVmcs)
    1752 {
    1753     RTGCPTR GCPtrDisp;
    1754     VMXEXITINSTRINFO ExitInstrInfo;
    1755     ExitInstrInfo.u = iemVmxGetExitInstrInfo(pVCpu, VMX_EXIT_VMCLEAR, VMX_INSTR_ID_NONE, &GCPtrDisp);
    1756     return iemVmxVmclear(pVCpu, cbInstr, GCPtrVmcs, &ExitInstrInfo, GCPtrDisp);
     1747IEM_CIMPL_DEF_2(iemCImpl_vmclear, uint8_t, iEffSeg, RTGCPTR, GCPtrVmcs)
     1748{
     1749    return iemVmxVmclear(pVCpu, cbInstr, iEffSeg, GCPtrVmcs, NULL /* pExitInfo */);
    17571750}
    17581751
    … …  
    17611754 * Implements 'VMWRITE' register.
    17621755 */
    1763 IEM_CIMPL_DEF_2(iemCImpl_vmwrite_reg, uint32_t, u32VmcsFieldEnc, uint64_t, u64Val)
    1764 {
    1765     VMXEXITINSTRINFO ExitInstrInfo;
    1766     ExitInstrInfo.u = iemVmxGetExitInstrInfo(pVCpu, VMX_EXIT_VMWRITE, VMX_INSTR_ID_NONE, NULL /* pGCPtrDisp */);
    1767     return iemVmxVmwrite(pVCpu, cbInstr, u32VmcsFieldEnc, u64Val, &ExitInstrInfo, 0 /* GCPtrDisp */);
     1756IEM_CIMPL_DEF_2(iemCImpl_vmwrite_reg, uint64_t, u64Val, uint32_t, uFieldEnc)
     1757{
     1758    return iemVmxVmwrite(pVCpu, cbInstr, UINT8_MAX /*iEffSeg*/, IEMMODE_64BIT /* N/A */, u64Val, uFieldEnc, NULL /* pExitInfo */);
    17681759}
    17691760
    … …  
    17721763 * Implements 'VMWRITE' memory.
    17731764 */
    1774 IEM_CIMPL_DEF_2(iemCImpl_vmwrite_mem, uint32_t, u32VmcsFieldEnc, RTGCUINTPTR64, GCPtrVal)
    1775 {
    1776     RTGCPTR GCPtrDisp;
    1777     VMXEXITINSTRINFO ExitInstrInfo;
    1778     ExitInstrInfo.u = iemVmxGetExitInstrInfo(pVCpu, VMX_EXIT_VMWRITE, VMX_INSTR_ID_NONE, &GCPtrDisp);
    1779     return iemVmxVmwrite(pVCpu, cbInstr, u32VmcsFieldEnc, GCPtrVal, &ExitInstrInfo, GCPtrDisp);
     1765IEM_CIMPL_DEF_4(iemCImpl_vmwrite_mem, uint8_t, iEffSeg, IEMMODE, enmEffAddrMode, RTGCPTR, GCPtrVal, uint32_t, uFieldEnc)
     1766{
     1767    return iemVmxVmwrite(pVCpu, cbInstr, iEffSeg, enmEffAddrMode, GCPtrVal, uFieldEnc,  NULL /* pExitInfo */);
    17801768}
    17811769

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

    r73937 r73959  
    43044304        {
    43054305            IEM_MC_BEGIN(2, 0);
    4306             IEM_MC_ARG(uint64_t, u64Enc, 0);
    4307             IEM_MC_ARG(uint64_t, u64Val, 1);
     4306            IEM_MC_ARG(uint64_t, u64Val, 0);
     4307            IEM_MC_ARG(uint64_t, u64Enc, 1);
     4308            IEM_MC_FETCH_GREG_U64(u64Val, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    43084309            IEM_MC_FETCH_GREG_U64(u64Enc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    4309             IEM_MC_FETCH_GREG_U64(u64Val, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    4310             IEM_MC_CALL_CIMPL_2(iemCImpl_vmwrite_reg, u64Enc, u64Val);
     4310            IEM_MC_CALL_CIMPL_2(iemCImpl_vmwrite_reg, u64Val, u64Enc);
    43114311            IEM_MC_END();
    43124312        }
    … …  
    43144314        {
    43154315            IEM_MC_BEGIN(2, 0);
    4316             IEM_MC_ARG(uint32_t, u32Enc, 0);
    4317             IEM_MC_ARG(uint32_t, u32Val, 1);
     4316            IEM_MC_ARG(uint32_t, u32Val, 0);
     4317            IEM_MC_ARG(uint32_t, u32Enc, 1);
     4318            IEM_MC_FETCH_GREG_U32(u32Val, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    43184319            IEM_MC_FETCH_GREG_U32(u32Enc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    4319             IEM_MC_FETCH_GREG_U32(u32Val, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
    4320             IEM_MC_CALL_CIMPL_2(iemCImpl_vmwrite_reg, u32Enc, u32Val);
     4320            IEM_MC_CALL_CIMPL_2(iemCImpl_vmwrite_reg, u32Val, u32Enc);
    43214321            IEM_MC_END();
    43224322        }
    … …  
    43294329        if (enmEffOpSize == IEMMODE_64BIT)
    43304330        {
    4331             IEM_MC_BEGIN(2, 0);
    4332             IEM_MC_ARG(uint64_t, u64Enc,   0);
    4333             IEM_MC_ARG(RTGCPTR,  GCPtrVal, 1);
     4331            IEM_MC_BEGIN(4, 0);
     4332            IEM_MC_ARG(uint8_t,       iEffSeg,                                          0);
     4333            IEM_MC_ARG_CONST(IEMMODE, enmEffAddrMode,/*=*/pVCpu->iem.s.enmEffAddrMode,  1);
     4334            IEM_MC_ARG(RTGCPTR,       GCPtrVal,                                         2);
     4335            IEM_MC_ARG(uint64_t,      u64Enc,                                           3);
    43344336            IEM_MC_CALC_RM_EFF_ADDR(GCPtrVal, bRm, 0);
    43354337            IEMOP_HLP_DONE_DECODING_NO_SIZE_OP_REPZ_OR_REPNZ_PREFIXES();
    43364338            IEM_MC_FETCH_GREG_U64(u64Enc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    4337             IEM_MC_CALL_CIMPL_2(iemCImpl_vmwrite_mem, u64Enc, GCPtrVal);
     4339            IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
     4340            IEM_MC_CALL_CIMPL_4(iemCImpl_vmwrite_mem, iEffSeg, enmEffAddrMode, GCPtrVal, u64Enc);
    43384341            IEM_MC_END();
    43394342        }
    43404343        else
    43414344        {
    4342             IEM_MC_BEGIN(2, 0);
    4343             IEM_MC_ARG(uint32_t, u32Enc,   0);
    4344             IEM_MC_ARG(RTGCPTR,  GCPtrVal, 1);
     4345            IEM_MC_BEGIN(4, 0);
     4346            IEM_MC_ARG(uint8_t,       iEffSeg,                                          0);
     4347            IEM_MC_ARG_CONST(IEMMODE, enmEffAddrMode,/*=*/pVCpu->iem.s.enmEffAddrMode,  1);
     4348            IEM_MC_ARG(RTGCPTR,       GCPtrVal,                                         2);
     4349            IEM_MC_ARG(uint32_t,      u32Enc,                                           3);
    43454350            IEM_MC_CALC_RM_EFF_ADDR(GCPtrVal, bRm, 0);
    43464351            IEMOP_HLP_DONE_DECODING_NO_SIZE_OP_REPZ_OR_REPNZ_PREFIXES();
    43474352            IEM_MC_FETCH_GREG_U32(u32Enc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
    4348             IEM_MC_CALL_CIMPL_2(iemCImpl_vmwrite_mem, u32Enc, GCPtrVal);
     4353            IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
     4354            IEM_MC_CALL_CIMPL_4(iemCImpl_vmwrite_mem, iEffSeg, enmEffAddrMode, GCPtrVal, u32Enc);
    43494355            IEM_MC_END();
    43504356        }
    … …  
    85018507    IEMOP_HLP_IN_VMX_OPERATION();
    85028508    IEMOP_HLP_VMX_INSTR();
    8503     IEM_MC_BEGIN(1, 0);
    8504     IEM_MC_ARG(RTGCPTR, GCPtrEffSrc, 0);
     8509    IEM_MC_BEGIN(2, 0);
     8510    IEM_MC_ARG(uint8_t, iEffSeg,     0);
     8511    IEM_MC_ARG(RTGCPTR, GCPtrEffSrc, 1);
    85058512    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    85068513    IEMOP_HLP_DONE_DECODING_NO_SIZE_OP_REPZ_OR_REPNZ_PREFIXES();
    8507     IEM_MC_CALL_CIMPL_1(iemCImpl_vmptrld, GCPtrEffSrc);
     8514    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
     8515    IEM_MC_CALL_CIMPL_2(iemCImpl_vmptrld, iEffSeg, GCPtrEffSrc);
    85088516    IEM_MC_END();
    85098517    return VINF_SUCCESS;
    … …  
    85208528    IEMOP_HLP_IN_VMX_OPERATION();
    85218529    IEMOP_HLP_VMX_INSTR();
    8522     IEM_MC_BEGIN(1, 0);
    8523     IEM_MC_ARG(RTGCPTR, GCPtrEffDst, 0);
     8530    IEM_MC_BEGIN(2, 0);
     8531    IEM_MC_ARG(uint8_t, iEffSeg,     0);
     8532    IEM_MC_ARG(RTGCPTR, GCPtrEffDst, 1);
    85248533    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    85258534    IEMOP_HLP_DONE_DECODING();
    8526     IEM_MC_CALL_CIMPL_1(iemCImpl_vmclear, GCPtrEffDst);
     8535    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
     8536    IEM_MC_CALL_CIMPL_2(iemCImpl_vmclear, iEffSeg, GCPtrEffDst);
    85278537    IEM_MC_END();
    85288538    return VINF_SUCCESS;
    … …  
    85388548    IEMOP_MNEMONIC(vmxon, "vmxon");
    85398549    IEMOP_HLP_VMX_INSTR();
    8540     IEM_MC_BEGIN(1, 0);
    8541     IEM_MC_ARG(RTGCPTR, GCPtrEffSrc, 0);
     8550    IEM_MC_BEGIN(2, 0);
     8551    IEM_MC_ARG(uint8_t, iEffSeg,     0);
     8552    IEM_MC_ARG(RTGCPTR, GCPtrEffSrc, 1);
    85428553    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
    85438554    IEMOP_HLP_DONE_DECODING();
    8544     IEM_MC_CALL_CIMPL_1(iemCImpl_vmxon, GCPtrEffSrc);
     8555    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
     8556    IEM_MC_CALL_CIMPL_2(iemCImpl_vmxon, iEffSeg, GCPtrEffSrc);
    85458557    IEM_MC_END();
    85468558    return VINF_SUCCESS;
    … …  
    85578569    IEMOP_HLP_IN_VMX_OPERATION();
    85588570    IEMOP_HLP_VMX_INSTR();
    8559     IEM_MC_BEGIN(1, 0);
    8560     IEM_MC_ARG(RTGCPTR, GCPtrEffDst, 0);
     8571    IEM_MC_BEGIN(2, 0);
     8572    IEM_MC_ARG(uint8_t, iEffSeg,     0);
     8573    IEM_MC_ARG(RTGCPTR, GCPtrEffDst, 1);
    85618574    IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm, 0);
    85628575    IEMOP_HLP_DONE_DECODING_NO_SIZE_OP_REPZ_OR_REPNZ_PREFIXES();
    8563     IEM_MC_CALL_CIMPL_1(iemCImpl_vmptrst, GCPtrEffDst);
     8576    IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
     8577    IEM_MC_CALL_CIMPL_2(iemCImpl_vmptrst, iEffSeg, GCPtrEffDst);
    85648578    IEM_MC_END();
    85658579    return VINF_SUCCESS;

  • trunk/src/VBox/VMM/VMMR0/HMVMXR0.cpp

    r73943 r73959  
    1349813498    }
    1349913499
    13500     rcStrict = IEMExecDecodedVmxon(pVCpu, pVmxTransient->cbInstr, GCPtrVmxon, pExitInstrInfo->u, GCPtrDisp);
     13500    VMXVEXITINFO ExitInfo;
     13501    RT_ZERO(ExitInfo);
     13502    ExitInfo.ExitInstrInfo.u = pExitInstrInfo->u;
     13503    ExitInfo.u64ExitQual     = GCPtrDisp;
     13504    uint8_t const iEffSeg    = pExitInstrInfo->VmreadVmwrite.iSegReg;
     13505    rcStrict = IEMExecDecodedVmxon(pVCpu, pVmxTransient->cbInstr, iEffSeg, GCPtrVmxon, &ExitInfo);
    1350113506    if (RT_LIKELY(rcStrict == VINF_SUCCESS))
    1350213507        ASMAtomicUoOrU64(&pVCpu->hm.s.fCtxChanged, HM_CHANGED_GUEST_RIP | HM_CHANGED_GUEST_RFLAGS | HM_CHANGED_GUEST_HWVIRT);
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