VirtualBox

Changeset 43394 in vbox


Ignore:
Timestamp:
Sep 21, 2012 11:11:17 AM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
80872
Message:

VMM: HM cleanup.

Location:
trunk
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/err.h

    r43387 r43394  
    157157/** Indicating that a rescheduling to vmx-mode execution.
    158158 * Typically caused by REM detecting that hardware-accelerated raw-mode execution is possible. */
    159 #define VINF_EM_RESCHEDULE_HWACC            1116
     159#define VINF_EM_RESCHEDULE_HM            1116
    160160/** Indicating that a rescheduling to raw-mode execution.
    161161 * Typically caused by REM detecting that raw-mode execution is possible.

  • trunk/include/VBox/sup.h

    r43379 r43394  
    424424/** @see VMMR0_DO_RAW_RUN. */
    425425#define SUP_VMMR0_DO_RAW_RUN    0
    426 /** @see VMMR0_DO_HWACC_RUN. */
    427 #define SUP_VMMR0_DO_HWACC_RUN  1
     426/** @see VMMR0_DO_HM_RUN. */
     427#define SUP_VMMR0_DO_HM_RUN  1
    428428/** @see VMMR0_DO_NOP */
    429429#define SUP_VMMR0_DO_NOP        2

  • trunk/include/VBox/vmm/dbgf.h

    r42420 r43394  
    202202    DBGFEVENTCTX_REM,
    203203    /** VMX / AVT mode. */
    204     DBGFEVENTCTX_HWACCL,
     204    DBGFEVENTCTX_HM,
    205205    /** Hypervisor context. */
    206206    DBGFEVENTCTX_HYPER,

  • trunk/include/VBox/vmm/em.h

    r42186 r43394  
    5252    EMSTATE_RAW,
    5353    /** Hardware accelerated raw-mode execution. */
    54     EMSTATE_HWACC,
     54    EMSTATE_HM,
    5555    /** Value reserved for future use (used to be PARAV). */
    5656    EMSTATE_RESERVED,
    … …  
    6868    EMSTATE_DEBUG_GUEST_RAW,
    6969    /** Guest debug event from hardware accelerated mode is being processed. */
    70     EMSTATE_DEBUG_GUEST_HWACC,
     70    EMSTATE_DEBUG_GUEST_HM,
    7171    /** Guest debug event from recompiled-mode is being processed. */
    7272    EMSTATE_DEBUG_GUEST_REM,

  • trunk/include/VBox/vmm/iom.h

    r42451 r43394  
    7676                                 && (rc) >= VINF_EM_FIRST \
    7777                                 && (rc) != VINF_EM_RESCHEDULE_RAW \
    78                                  && (rc) != VINF_EM_RESCHEDULE_HWACC \
     78                                 && (rc) != VINF_EM_RESCHEDULE_HM \
    7979                                ) \
    8080                            )

  • trunk/include/VBox/vmm/vmm.h

    r43392 r43394  
    321321    VMMR0_DO_RAW_RUN = SUP_VMMR0_DO_RAW_RUN,
    322322    /** Run guest code using the available hardware acceleration technology. */
    323     VMMR0_DO_HWACC_RUN = SUP_VMMR0_DO_HWACC_RUN,
     323    VMMR0_DO_HM_RUN = SUP_VMMR0_DO_HM_RUN,
    324324    /** Official NOP that we use for profiling. */
    325325    VMMR0_DO_NOP = SUP_VMMR0_DO_NOP,
    … …  
    353353    VMMR0_DO_VMMR0_TERM,
    354354    /** Setup the hardware accelerated raw-mode session. */
    355     VMMR0_DO_HWACC_SETUP_VM,
     355    VMMR0_DO_HM_SETUP_VM,
    356356    /** Attempt to enable or disable hardware accelerated raw-mode. */
    357     VMMR0_DO_HWACC_ENABLE,
     357    VMMR0_DO_HM_ENABLE,
    358358    /** Calls function in the hypervisor.
    359359     * The caller must setup the hypervisor context so the call will be performed.

  • trunk/src/VBox/Debugger/DBGConsole.cpp

    r41573 r43394  
    580580        case DBGFEVENTCTX_RAW:      return "raw";
    581581        case DBGFEVENTCTX_REM:      return "rem";
    582         case DBGFEVENTCTX_HWACCL:   return "hwaccl";
     582        case DBGFEVENTCTX_HM:   return "hwaccl";
    583583        case DBGFEVENTCTX_HYPER:    return "hyper";
    584584        case DBGFEVENTCTX_OTHER:    return "other";

  • trunk/src/VBox/HostDrivers/Support/SUPDrv.c

    r43387 r43394  
    10291029                pDevExt->pfnVMMR0EntryFast(pSession->pVM, idCpu, SUP_VMMR0_DO_RAW_RUN);
    10301030                break;
    1031             case SUP_IOCTL_FAST_DO_HWACC_RUN:
    1032                 pDevExt->pfnVMMR0EntryFast(pSession->pVM, idCpu, SUP_VMMR0_DO_HWACC_RUN);
     1031            case SUP_IOCTL_FAST_DO_HM_RUN:
     1032                pDevExt->pfnVMMR0EntryFast(pSession->pVM, idCpu, SUP_VMMR0_DO_HM_RUN);
    10331033                break;
    10341034            case SUP_IOCTL_FAST_DO_NOP:

  • trunk/src/VBox/HostDrivers/Support/SUPDrvIOC.h

    r43379 r43394  
    101101/** Fast path IOCtl: VMMR0_DO_RAW_RUN */
    102102#define SUP_IOCTL_FAST_DO_RAW_RUN               SUP_CTL_CODE_FAST(64)
    103 /** Fast path IOCtl: VMMR0_DO_HWACC_RUN */
    104 #define SUP_IOCTL_FAST_DO_HWACC_RUN             SUP_CTL_CODE_FAST(65)
     103/** Fast path IOCtl: VMMR0_DO_HM_RUN */
     104#define SUP_IOCTL_FAST_DO_HM_RUN             SUP_CTL_CODE_FAST(65)
    105105/** Just a NOP call for profiling the latency of a fast ioctl call to VMMR0. */
    106106#define SUP_IOCTL_FAST_DO_NOP                   SUP_CTL_CODE_FAST(66)

  • trunk/src/VBox/HostDrivers/Support/SUPLib.cpp

    r43379 r43394  
    591591    if (RT_LIKELY(uOperation == SUP_VMMR0_DO_RAW_RUN))
    592592        return suplibOsIOCtlFast(&g_supLibData, SUP_IOCTL_FAST_DO_RAW_RUN, idCpu);
    593     if (RT_LIKELY(uOperation == SUP_VMMR0_DO_HWACC_RUN))
    594         return suplibOsIOCtlFast(&g_supLibData, SUP_IOCTL_FAST_DO_HWACC_RUN, idCpu);
     593    if (RT_LIKELY(uOperation == SUP_VMMR0_DO_HM_RUN))
     594        return suplibOsIOCtlFast(&g_supLibData, SUP_IOCTL_FAST_DO_HM_RUN, idCpu);
    595595    if (RT_LIKELY(uOperation == SUP_VMMR0_DO_NOP))
    596596        return suplibOsIOCtlFast(&g_supLibData, SUP_IOCTL_FAST_DO_NOP, idCpu);
    … …  
    607607     */
    608608    AssertMsgReturn(    uOperation != SUP_VMMR0_DO_RAW_RUN
    609                     &&  uOperation != SUP_VMMR0_DO_HWACC_RUN
     609                    &&  uOperation != SUP_VMMR0_DO_HM_RUN
    610610                    &&  uOperation != SUP_VMMR0_DO_NOP,
    611611                    ("%#x\n", uOperation),
    … …  
    694694     */
    695695    AssertMsgReturn(    uOperation != SUP_VMMR0_DO_RAW_RUN
    696                     &&  uOperation != SUP_VMMR0_DO_HWACC_RUN
     696                    &&  uOperation != SUP_VMMR0_DO_HM_RUN
    697697                    &&  uOperation != SUP_VMMR0_DO_NOP,
    698698                    ("%#x\n", uOperation),

  • trunk/src/VBox/HostDrivers/Support/darwin/SUPDrv-darwin.cpp

    r43379 r43394  
    515515     */
    516516    if (    iCmd == SUP_IOCTL_FAST_DO_RAW_RUN
    517         ||  iCmd == SUP_IOCTL_FAST_DO_HWACC_RUN
     517        ||  iCmd == SUP_IOCTL_FAST_DO_HM_RUN
    518518        ||  iCmd == SUP_IOCTL_FAST_DO_NOP)
    519519        return supdrvIOCtlFast(iCmd, *(uint32_t *)pData, &g_DevExt, pSession);

  • trunk/src/VBox/HostDrivers/Support/freebsd/SUPDrv-freebsd.c

    r41067 r43394  
    289289     */
    290290    if (    ulCmd == SUP_IOCTL_FAST_DO_RAW_RUN
    291         ||  ulCmd == SUP_IOCTL_FAST_DO_HWACC_RUN
     291        ||  ulCmd == SUP_IOCTL_FAST_DO_HM_RUN
    292292        ||  ulCmd == SUP_IOCTL_FAST_DO_NOP)
    293293        return supdrvIOCtlFast(ulCmd, *(uint32_t *)pvData, &g_VBoxDrvFreeBSDDevExt, pSession);

  • trunk/src/VBox/HostDrivers/Support/linux/SUPDrv-linux.c

    r41067 r43394  
    540540#ifdef HAVE_UNLOCKED_IOCTL
    541541    if (RT_LIKELY(   uCmd == SUP_IOCTL_FAST_DO_RAW_RUN
    542                   || uCmd == SUP_IOCTL_FAST_DO_HWACC_RUN
     542                  || uCmd == SUP_IOCTL_FAST_DO_HM_RUN
    543543                  || uCmd == SUP_IOCTL_FAST_DO_NOP))
    544544        return supdrvIOCtlFast(uCmd, ulArg, &g_DevExt, (PSUPDRVSESSION)pFilp->private_data);
    … …  
    550550    unlock_kernel();
    551551    if (RT_LIKELY(   uCmd == SUP_IOCTL_FAST_DO_RAW_RUN
    552                   || uCmd == SUP_IOCTL_FAST_DO_HWACC_RUN
     552                  || uCmd == SUP_IOCTL_FAST_DO_HM_RUN
    553553                  || uCmd == SUP_IOCTL_FAST_DO_NOP))
    554554        rc = supdrvIOCtlFast(uCmd, ulArg, &g_DevExt, (PSUPDRVSESSION)pFilp->private_data);

  • trunk/src/VBox/HostDrivers/Support/solaris/SUPDrv-solaris.c

    r41067 r43394  
    685685     */
    686686    if (    Cmd == SUP_IOCTL_FAST_DO_RAW_RUN
    687         ||  Cmd == SUP_IOCTL_FAST_DO_HWACC_RUN
     687        ||  Cmd == SUP_IOCTL_FAST_DO_HM_RUN
    688688        ||  Cmd == SUP_IOCTL_FAST_DO_NOP)
    689689    {

  • trunk/src/VBox/HostDrivers/Support/win/SUPDrv-win.cpp

    r41774 r43394  
    356356    ULONG ulCmd = pStack->Parameters.DeviceIoControl.IoControlCode;
    357357    if (    ulCmd == SUP_IOCTL_FAST_DO_RAW_RUN
    358         ||  ulCmd == SUP_IOCTL_FAST_DO_HWACC_RUN
     358        ||  ulCmd == SUP_IOCTL_FAST_DO_HM_RUN
    359359        ||  ulCmd == SUP_IOCTL_FAST_DO_NOP)
    360360    {

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

    r43387 r43394  
    744744         * we hope to get away with page faults and later calling into the kernel.
    745745         */
    746         case VMMR0_DO_HWACC_RUN:
     746        case VMMR0_DO_HM_RUN:
    747747        {
    748748#ifdef VBOX_WITH_VMMR0_DISABLE_PREEMPTION
    … …  
    964964         * Attempt to enable hm mode and check the current setting.
    965965         */
    966         case VMMR0_DO_HWACC_ENABLE:
     966        case VMMR0_DO_HM_ENABLE:
    967967            return HMR0EnableAllCpus(pVM);
    968968
    … …  
    970970         * Setup the hardware accelerated session.
    971971         */
    972         case VMMR0_DO_HWACC_SETUP_VM:
     972        case VMMR0_DO_HM_SETUP_VM:
    973973            return HMR0SetupVM(pVM);
    974974

  • trunk/src/VBox/VMM/VMMR3/EM.cpp

    r43392 r43394  
    635635     */
    636636    return    pVCpu->em.s.enmState == EMSTATE_RAW
    637            || pVCpu->em.s.enmState == EMSTATE_HWACC
     637           || pVCpu->em.s.enmState == EMSTATE_HM
    638638           || pVCpu->em.s.enmState == EMSTATE_REM
    639639         ? VINF_EM_RESCHEDULE
    … …  
    696696        case EMSTATE_NONE:              return "EMSTATE_NONE";
    697697        case EMSTATE_RAW:               return "EMSTATE_RAW";
    698         case EMSTATE_HWACC:             return "EMSTATE_HWACC";
     698        case EMSTATE_HM:             return "EMSTATE_HM";
    699699        case EMSTATE_REM:               return "EMSTATE_REM";
    700700        case EMSTATE_HALTED:            return "EMSTATE_HALTED";
    … …  
    11971197        if (   EMIsHwVirtExecutionEnabled(pVM)
    11981198            && HMR3CanExecuteGuest(pVM, pCtx))
    1199             return EMSTATE_HWACC;
     1199            return EMSTATE_HM;
    12001200
    12011201        /*
    … …  
    16861686        if (    !VM_FF_ISPENDING(pVM, VM_FF_PGM_NO_MEMORY)
    16871687            &&  !VMCPU_FF_ISPENDING(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
    1688             &&  (!rc || rc >= VINF_EM_RESCHEDULE_HWACC)
     1688            &&  (!rc || rc >= VINF_EM_RESCHEDULE_HM)
    16891689            &&  !TRPMHasTrap(pVCpu) /* an interrupt could already be scheduled for dispatching in the recompiler. */
    16901690            &&  PATMAreInterruptsEnabled(pVM)
    … …  
    19311931                VBOXVMM_EM_FF_ALL_RET(pVCpu, rc);
    19321932                if (   (   rc == VINF_EM_RESCHEDULE_REM
    1933                         || rc == VINF_EM_RESCHEDULE_HWACC)
     1933                        || rc == VINF_EM_RESCHEDULE_HM)
    19341934                    && pVCpu->em.s.fForceRAW)
    19351935                    rc = VINF_EM_RESCHEDULE_RAW;
    … …  
    19621962                 * Reschedule - to hardware accelerated raw-mode execution.
    19631963                 */
    1964                 case VINF_EM_RESCHEDULE_HWACC:
    1965                     Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_HWACC: %d -> %d (EMSTATE_HWACC)\n", enmOldState, EMSTATE_HWACC));
     1964                case VINF_EM_RESCHEDULE_HM:
     1965                    Log2(("EMR3ExecuteVM: VINF_EM_RESCHEDULE_HM: %d -> %d (EMSTATE_HM)\n", enmOldState, EMSTATE_HM));
    19661966                    Assert(!pVCpu->em.s.fForceRAW);
    1967                     pVCpu->em.s.enmState = EMSTATE_HWACC;
     1967                    pVCpu->em.s.enmState = EMSTATE_HM;
    19681968                    break;
    19691969
    … …  
    21632163                    && (pVCpu->em.s.MWait.fWait & EMMWAIT_FLAG_ACTIVE)
    21642164                    && (   enmNewState == EMSTATE_RAW
    2165                         || enmNewState == EMSTATE_HWACC
     2165                        || enmNewState == EMSTATE_HM
    21662166                        || enmNewState == EMSTATE_REM
    21672167                        || enmNewState == EMSTATE_DEBUG_GUEST_RAW
    2168                         || enmNewState == EMSTATE_DEBUG_GUEST_HWACC
     2168                        || enmNewState == EMSTATE_DEBUG_GUEST_HM
    21692169                        || enmNewState == EMSTATE_DEBUG_GUEST_REM) )
    21702170                {
    … …  
    21962196                 * Execute hardware accelerated raw.
    21972197                 */
    2198                 case EMSTATE_HWACC:
     2198                case EMSTATE_HM:
    21992199#ifndef IEM_VERIFICATION_MODE /* remove later */
    22002200                    rc = emR3HmExecute(pVM, pVCpu, &fFFDone);

  • trunk/src/VBox/VMM/VMMR3/EMHM.cpp

    r43392 r43394  
    8181static int emR3HmStep(PVM pVM, PVMCPU pVCpu)
    8282{
    83     Assert(pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_HWACC);
     83    Assert(pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_HM);
    8484
    8585    int         rc;
    … …  
    132132    int     rc          = VINF_SUCCESS;
    133133    EMSTATE enmOldState = pVCpu->em.s.enmState;
    134     pVCpu->em.s.enmState  = EMSTATE_DEBUG_GUEST_HWACC;
     134    pVCpu->em.s.enmState  = EMSTATE_DEBUG_GUEST_HM;
    135135
    136136    Log(("Single step BEGIN:\n"));
    … …  
    217217            {
    218218#ifdef EM_NOTIFY_HM
    219                 if (pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_HWACC)
     219                if (pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_HM)
    220220                    HMR3NotifyEmulated(pVCpu);
    221221#endif
    … …  
    247247
    248248#ifdef EM_NOTIFY_HM
    249     if (pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_HWACC)
     249    if (pVCpu->em.s.enmState == EMSTATE_DEBUG_GUEST_HM)
    250250        HMR3NotifyEmulated(pVCpu);
    251251#endif
    … …  
    584584            VBOXVMM_EM_FF_ALL_RET(pVCpu, rc);
    585585            if (    rc != VINF_SUCCESS
    586                 &&  rc != VINF_EM_RESCHEDULE_HWACC)
     586                &&  rc != VINF_EM_RESCHEDULE_HM)
    587587            {
    588588                *pfFFDone = true;

  • trunk/src/VBox/VMM/VMMR3/HM.cpp

    r43391 r43394  
    774774
    775775    /* Enable VT-x or AMD-V on all host CPUs. */
    776     rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_HWACC_ENABLE, 0, NULL);
     776    rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_HM_ENABLE, 0, NULL);
    777777    if (RT_FAILURE(rc))
    778778    {
    779         LogRel(("HMR3InitFinalize: SUPR3CallVMMR0Ex VMMR0_DO_HWACC_ENABLE failed with %Rrc\n", rc));
     779        LogRel(("HMR3InitFinalize: SUPR3CallVMMR0Ex VMMR0_DO_HM_ENABLE failed with %Rrc\n", rc));
    780780        return rc;
    781781    }
    … …  
    11871187            }
    11881188
    1189             rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_HWACC_SETUP_VM, 0, NULL);
     1189            rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_HM_SETUP_VM, 0, NULL);
    11901190            AssertRC(rc);
    11911191            if (rc == VINF_SUCCESS)
    … …  
    13861386                pVM->hm.s.fNestedPaging = pVM->hm.s.fAllowNestedPaging;
    13871387
    1388             rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_HWACC_SETUP_VM, 0, NULL);
     1388            rc = SUPR3CallVMMR0Ex(pVM->pVMR0, 0 /*idCpu*/, VMMR0_DO_HM_SETUP_VM, 0, NULL);
    13891389            AssertRC(rc);
    13901390            if (rc == VINF_SUCCESS)

  • trunk/src/VBox/VMM/VMMR3/TRPM.cpp

    r43387 r43394  
    15291529                AssertRC(rc);
    15301530                STAM_COUNTER_INC(&pVM->trpm.s.paStatForwardedIRQR3[u8Interrupt]);
    1531                 return HMR3IsActive(pVCpu) ? VINF_EM_RESCHEDULE_HWACC : VINF_EM_RESCHEDULE_REM;
     1531                return HMR3IsActive(pVCpu) ? VINF_EM_RESCHEDULE_HM : VINF_EM_RESCHEDULE_REM;
    15321532            }
    15331533            /* If the guest gate is not patched, then we will check (again) if we can patch it. */
    … …  
    15641564        {
    15651565            AssertRC(rc);
    1566             return HMR3IsActive(pVCpu) ? VINF_EM_RESCHEDULE_HWACC : VINF_EM_RESCHEDULE_REM; /* (Heed the halted state if this is changed!) */
     1566            return HMR3IsActive(pVCpu) ? VINF_EM_RESCHEDULE_HM : VINF_EM_RESCHEDULE_REM; /* (Heed the halted state if this is changed!) */
    15671567        }
    15681568#else
    … …  
    15771577                AssertRC(rc);
    15781578                STAM_COUNTER_INC(&pVM->trpm.s.paStatForwardedIRQR3[u8Interrupt]);
    1579                 return VINF_EM_RESCHEDULE_HWACC;
     1579                return VINF_EM_RESCHEDULE_HM;
    15801580            }
    15811581        }

  • trunk/src/VBox/VMM/VMMR3/VMM.cpp

    r43392 r43394  
    12831283            rc = VERR_GENERAL_FAILURE;
    12841284#else
    1285             rc = SUPR3CallVMMR0Fast(pVM->pVMR0, VMMR0_DO_HWACC_RUN, pVCpu->idCpu);
     1285            rc = SUPR3CallVMMR0Fast(pVM->pVMR0, VMMR0_DO_HM_RUN, pVCpu->idCpu);
    12861286            if (RT_LIKELY(rc == VINF_SUCCESS))
    12871287                rc = pVCpu->vmm.s.iLastGZRc;

  • trunk/src/VBox/VMM/VMMR3/VMMTests.cpp

    r43391 r43394  
    559559
    560560            uint64_t TickThisStart = ASMReadTSC();
    561             rc = SUPR3CallVMMR0Fast(pVM->pVMR0, VMMR0_DO_HWACC_RUN, 0);
     561            rc = SUPR3CallVMMR0Fast(pVM->pVMR0, VMMR0_DO_HM_RUN, 0);
    562562            uint64_t TickThisElapsed = ASMReadTSC() - TickThisStart;
    563563            if (RT_FAILURE(rc))

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

    r43391 r43394  
    4747            break;
    4848        case VINF_EM_RESCHEDULE_RAW:
    49         case VINF_EM_RESCHEDULE_HWACC:
     49        case VINF_EM_RESCHEDULE_HM:
    5050        case VINF_EM_RAW_INTERRUPT:
    5151        case VINF_EM_RAW_TO_R3:

  • trunk/src/recompiler/VBoxRecompiler.c

    r43387 r43394  
    865865                break;
    866866            case EXCP_EXECUTE_RAW:
    867             case EXCP_EXECUTE_HWACC:
     867            case EXCP_EXECUTE_HM:
    868868                /** @todo: is it correct? No! */
    869869                rc = VINF_SUCCESS;
    … …  
    954954
    955955    /* Make sure this flag is set; we might never execute remR3CanExecuteRaw in the AMD-V case.
    956      * CPU_RAW_HWACC makes sure we never execute interrupt handlers in the recompiler.
     956     * CPU_RAW_HM makes sure we never execute interrupt handlers in the recompiler.
    957957     */
    958958    if (HMIsEnabled(pVM))
    959         pVM->rem.s.Env.state |= CPU_RAW_HWACC;
     959        pVM->rem.s.Env.state |= CPU_RAW_HM;
    960960
    961961    /* Skip the TB flush as that's rather expensive and not necessary for single instruction emulation. */
    … …  
    10531053             * Switch to hardware accelerated RAW-mode.
    10541054             */
    1055             case EXCP_EXECUTE_HWACC:
    1056                 Log2(("REMR3EmulateInstruction: cpu_exec -> EXCP_EXECUTE_HWACC\n"));
    1057                 rc = VINF_EM_RESCHEDULE_HWACC;
     1055            case EXCP_EXECUTE_HM:
     1056                Log2(("REMR3EmulateInstruction: cpu_exec -> EXCP_EXECUTE_HM\n"));
     1057                rc = VINF_EM_RESCHEDULE_HM;
    10581058                break;
    10591059
    … …  
    12561256             * Switch to hardware accelerated RAW-mode.
    12571257             */
    1258             case EXCP_EXECUTE_HWACC:
    1259                 RTLogPrintf("remR3RunLoggingStep: cpu_exec -> EXCP_EXECUTE_HWACC rc=VINF_EM_RESCHEDULE_HWACC\n");
    1260                 rc = VINF_EM_RESCHEDULE_HWACC;
     1258            case EXCP_EXECUTE_HM:
     1259                RTLogPrintf("remR3RunLoggingStep: cpu_exec -> EXCP_EXECUTE_HM rc=VINF_EM_RESCHEDULE_HM\n");
     1260                rc = VINF_EM_RESCHEDULE_HM;
    12611261                break;
    12621262
    … …  
    13771377         * Switch to hardware accelerated RAW-mode.
    13781378         */
    1379         case EXCP_EXECUTE_HWACC:
    1380             Log2(("REMR3Run: cpu_exec -> EXCP_EXECUTE_HWACC\n"));
    1381             rc = VINF_EM_RESCHEDULE_HWACC;
     1379        case EXCP_EXECUTE_HM:
     1380            Log2(("REMR3Run: cpu_exec -> EXCP_EXECUTE_HM\n"));
     1381            rc = VINF_EM_RESCHEDULE_HM;
    13821382            break;
    13831383
    … …  
    14401440        CPUMCTX Ctx;
    14411441
    1442         env->state |= CPU_RAW_HWACC;
     1442        env->state |= CPU_RAW_HM;
    14431443
    14441444        /*
    … …  
    15301530        if (HMR3CanExecuteGuest(env->pVM, &Ctx) == true)
    15311531        {
    1532             *piException = EXCP_EXECUTE_HWACC;
     1532            *piException = EXCP_EXECUTE_HM;
    15331533            return true;
    15341534        }

  • trunk/src/recompiler/cpu-defs.h

    r42601 r43394  
    7777#ifdef VBOX
    7878# define EXCP_EXECUTE_RAW   0x11024 /**< execute raw mode. */
    79 # define EXCP_EXECUTE_HWACC 0x11025 /**< execute hardware accelerated raw mode. */
     79# define EXCP_EXECUTE_HM 0x11025 /**< execute hardware accelerated raw mode. */
    8080# define EXCP_SINGLE_INSTR  0x11026 /**< executed single instruction. */
    8181# define EXCP_RC            0x11027 /**< a EM rc was raised (VMR3Reset/Suspend/PowerOff). */

  • trunk/src/recompiler/cpu-exec.c

    r42601 r43394  
    437437                                || !(env->eflags & IF_MASK)
    438438                                ||  (env->hflags & HF_INHIBIT_IRQ_MASK)
    439                                 ||  (env->state & CPU_RAW_HWACC)
     439                                ||  (env->state & CPU_RAW_HM)
    440440                               )
    441441                            {

  • trunk/src/recompiler/target-i386/cpu.h

    r42407 r43394  
    910910# define CPU_EMULATE_SINGLE_INSTR 0x0040 /* Execute a single instruction in emulation mode */
    911911# define CPU_EMULATE_SINGLE_STEP  0x0080 /* go into single step mode */
    912 # define CPU_RAW_HWACC            0x0100 /* Set after first time HWACC is executed, never cleared. */
     912# define CPU_RAW_HM            0x0100 /* Set after first time HWACC is executed, never cleared. */
    913913/** @} */
    914914#endif /* !VBOX */
Note: See TracChangeset for help on using the changeset viewer.

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