VirtualBox

Changeset 40449 in vbox


Ignore:
Timestamp:
Mar 13, 2012 3:51:02 PM (13 years ago)
Author:
vboxsync
Message:

SELM: Refactoring (PVM -> PVMCPU).

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed

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

    r37955 r40449  
    7474/** @} */
    7575
    76 VMMDECL(int)        SELMToFlatEx(PVM pVM, DIS_SELREG SelReg, PCCPUMCTXCORE pCtxCore, RTGCPTR Addr, unsigned fFlags, PRTGCPTR ppvGC);
    77 VMMDECL(int)        SELMToFlatBySelEx(PVM pVM, X86EFLAGS eflags, RTSEL Sel, RTGCPTR Addr, PCCPUMSELREGHID pHiddenSel,
    78                                       unsigned fFlags, PRTGCPTR ppvGC, uint32_t *pcb);
    79 VMMDECL(int)        SELMValidateAndConvertCSAddr(PVM pVM, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS,
     76VMMDECL(int)        SELMToFlatEx(PVMCPU pVCpu, DIS_SELREG SelReg, PCCPUMCTXCORE pCtxCore, RTGCPTR Addr, unsigned fFlags, PRTGCPTR ppvGC);
     77VMMDECL(int)        SELMToFlatBySelEx(PVMCPU pVCpu, X86EFLAGS eflags, RTSEL Sel, RTGCPTR Addr, PCCPUMSELREGHID pHiddenSel,
     78                                      uint32_t fFlags, PRTGCPTR ppvGC, uint32_t *pcb);
     79VMMDECL(int)        SELMValidateAndConvertCSAddr(PVMCPU pVCpu, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS,
    8080                                                 PCCPUMSELREGHID pHiddenCSSel, RTGCPTR Addr, PRTGCPTR ppvFlat);
    81 VMMDECL(int)        SELMValidateAndConvertCSAddrGCTrap(PVM pVM, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS, RTGCPTR Addr,
     81VMMDECL(int)        SELMValidateAndConvertCSAddrGCTrap(PVMCPU pVCpu, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS, RTGCPTR Addr,
    8282                                                       PRTGCPTR ppvFlat, uint32_t *pcBits);
    83 VMMDECL(DISCPUMODE) SELMGetCpuModeFromSelector(PVM pVM, X86EFLAGS eflags, RTSEL Sel, PCCPUMSELREGHID pHiddenSel);
     83VMMDECL(DISCPUMODE) SELMGetCpuModeFromSelector(PVMCPU pVCpu, X86EFLAGS eflags, RTSEL Sel, PCCPUMSELREGHID pHiddenSel);
    8484VMMDECL(int)        SELMGetLDTFromSel(PVM pVM, RTSEL SelLdt, PRTGCPTR ppvLdt, unsigned *pcbLimit);
    8585

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

    r40448 r40449  
    288288 *
    289289 */
    290 static DECLCALLBACK(int) EMReadBytes(RTUINTPTR pSrc, uint8_t *pDest, unsigned cb, void *pvUserdata)
     290static DECLCALLBACK(int) emReadBytes(RTUINTPTR pSrc, uint8_t *pDest, unsigned cb, void *pvUserdata)
    291291{
    292292    PDISCPUSTATE  pDis   = (PDISCPUSTATE)pvUserdata;
    … …  
    304304    {
    305305        unsigned offset = pSrc - pState->GCPtr;
    306 
    307306        Assert(pSrc >= pState->GCPtr);
    308307
    309         for (unsigned i=0; i<cb; i++)
    310         {
     308        for (unsigned i = 0; i < cb; i++)
    311309            pDest[i] = pState->aOpcode[offset + i];
    312         }
    313310        return VINF_SUCCESS;
    314311    }
    … …  
    368365        State.GCPtr = NIL_RTGCPTR;
    369366    }
    370     return DISCoreOneEx(InstrGC, pDis->mode, EMReadBytes, &State, pDis, pOpsize);
     367    return DISCoreOneEx(InstrGC, pDis->mode, emReadBytes, &State, pDis, pOpsize);
    371368}
    372369
    … …  
    381378    State.GCPtr = InstrGC;
    382379
    383     return DISCoreOneEx(InstrGC, pDis->mode, EMReadBytes, &State, pDis, pOpsize);
     380    return DISCoreOneEx(InstrGC, pDis->mode, emReadBytes, &State, pDis, pOpsize);
    384381}
    385382
    … …  
    403400{
    404401    RTGCPTR GCPtrInstr;
    405     int rc = SELMToFlatEx(pVM, DIS_SELREG_CS, pCtxCore, pCtxCore->rip, 0, &GCPtrInstr);
     402    int rc = SELMToFlatEx(pVCpu, DIS_SELREG_CS, pCtxCore, pCtxCore->rip, 0, &GCPtrInstr);
    406403    if (RT_FAILURE(rc))
    407404    {
    … …  
    459456#endif
    460457
    461     rc = DISCoreOneEx(GCPtrInstr, SELMGetCpuModeFromSelector(pVM, pCtxCore->eflags, pCtxCore->cs, (PCPUMSELREGHID)&pCtxCore->csHid),
    462                       EMReadBytes, &State,
     458    rc = DISCoreOneEx(GCPtrInstr, SELMGetCpuModeFromSelector(pVCpu, pCtxCore->eflags, pCtxCore->cs, (PCPUMSELREGHID)&pCtxCore->csHid),
     459                      emReadBytes, &State,
    463460                      pDis, pcbInstr);
    464461    if (RT_SUCCESS(rc))
    … …  
    503500#else
    504501    RTGCPTR pbCode;
    505     VBOXSTRICTRC rc = SELMToFlatEx(pVM, DIS_SELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
     502    VBOXSTRICTRC rc = SELMToFlatEx(pVCpu, DIS_SELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
    506503    if (RT_SUCCESS(rc))
    507504    {
    508505        uint32_t     cbOp;
    509506        PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
    510         pDis->mode = SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
    511         rc = emDisCoreOne(pVM, pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
     507        pDis->mode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
     508        rc = emDisCoreOne(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
    512509        if (RT_SUCCESS(rc))
    513510        {
    … …  
    560557#else
    561558    RTGCPTR pbCode;
    562     VBOXSTRICTRC rc = SELMToFlatEx(pVM, DIS_SELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
     559    VBOXSTRICTRC rc = SELMToFlatEx(pVCpu, DIS_SELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
    563560    if (RT_SUCCESS(rc))
    564561    {
    565562        uint32_t     cbOp;
    566563        PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
    567         pDis->mode = SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
    568         rc = emDisCoreOne(pVM, pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
     564        pDis->mode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
     565        rc = emDisCoreOne(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
    569566        if (RT_SUCCESS(rc))
    570567        {
    … …  
    967964
    968965            /* Read stack value first */
    969             if (SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->ss, &pRegFrame->ssHid) == CPUMODE_16BIT)
     966            if (SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->ss, &pRegFrame->ssHid) == CPUMODE_16BIT)
    970967                return VERR_EM_INTERPRETER; /* No legacy 16 bits stuff here, please. */
    971968

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

    r40280 r40449  
    20522052    /* Convert destination address es:edi. */
    20532053    RTGCPTR GCPtrDst;
    2054     int rc2 = SELMToFlatEx(pVM, DIS_SELREG_ES, pRegFrame, pRegFrame->rdi & fAddrMask,
     2054    int rc2 = SELMToFlatEx(pVCpu, DIS_SELREG_ES, pRegFrame, pRegFrame->rdi & fAddrMask,
    20552055                           SELMTOFLAT_FLAGS_HYPER | SELMTOFLAT_FLAGS_NO_PL,
    20562056                           &GCPtrDst);
    … …  
    22142214    /* Convert source address ds:esi. */
    22152215    RTGCPTR GCPtrSrc;
    2216     int rc2 = SELMToFlatEx(pVM, DIS_SELREG_DS, pRegFrame, pRegFrame->rsi & fAddrMask,
     2216    int rc2 = SELMToFlatEx(pVCpu, DIS_SELREG_DS, pRegFrame, pRegFrame->rsi & fAddrMask,
    22172217                           SELMTOFLAT_FLAGS_HYPER | SELMTOFLAT_FLAGS_NO_PL,
    22182218                           &GCPtrSrc);

  • trunk/src/VBox/VMM/VMMAll/PGMAllBth.h

    r40274 r40449  
    907907                 */
    908908                RTGCPTR PC;
    909                 rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs,
     909                rc = SELMValidateAndConvertCSAddr(pVCpu, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs,
    910910                                                  &pRegFrame->csHid, (RTGCPTR)pRegFrame->eip, &PC);
    911911                if (rc == VINF_SUCCESS)

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

    r39078 r40449  
    140140 *
    141141 * @returns VBox status
    142  * @param   pVM         VM Handle.
    143  * @param   SelReg      Selector register
    144  * @param   pCtxCore    CPU context
     142 * @param   pVCpu       The virtual CPU handle.
     143 * @param   SelReg      Selector register.
     144 * @param   pCtxCore    CPU context.
    145145 * @param   Addr        Address part.
    146146 * @param   fFlags      SELMTOFLAT_FLAGS_*
    … …  
    148148 * @param   ppvGC       Where to store the GC flat address.
    149149 */
    150 VMMDECL(int) SELMToFlatEx(PVM pVM, DIS_SELREG SelReg, PCCPUMCTXCORE pCtxCore, RTGCPTR Addr, unsigned fFlags, PRTGCPTR ppvGC)
     150VMMDECL(int) SELMToFlatEx(PVMCPU pVCpu, DIS_SELREG SelReg, PCCPUMCTXCORE pCtxCore, RTGCPTR Addr, unsigned fFlags, PRTGCPTR ppvGC)
    151151{
    152152    /*
    … …  
    155155    PCPUMSELREGHID pHiddenSel;
    156156    RTSEL          Sel;
    157     PVMCPU         pVCpu = VMMGetCpu(pVM);
    158157
    159158    int rc = DISFetchRegSegEx(pCtxCore, SelReg, &Sel, &pHiddenSel);
    … …  
    303302        X86DESC Desc;
    304303
     304        PVM pVM = pVCpu->CTX_SUFF(pVM);
    305305        if (!(Sel & X86_SEL_LDT))
    306306        {
    … …  
    448448 *
    449449 * @returns VBox status
    450  * @param   pVM         VM Handle.
     450 * @param   pVCpu       The virtual CPU handle.
    451451 * @param   eflags      Current eflags
    452452 * @param   Sel         Selector part.
    … …  
    460460 * @remarks Don't use when in long mode.
    461461 */
    462 VMMDECL(int) SELMToFlatBySelEx(PVM pVM, X86EFLAGS eflags, RTSEL Sel, RTGCPTR Addr, PCCPUMSELREGHID pHiddenSel, unsigned fFlags, PRTGCPTR ppvGC, uint32_t *pcb)
    463 {
    464     PVMCPU pVCpu = VMMGetCpu(pVM);
    465 
     462VMMDECL(int) SELMToFlatBySelEx(PVMCPU pVCpu, X86EFLAGS eflags, RTSEL Sel, RTGCPTR Addr, PCCPUMSELREGHID pHiddenSel, uint32_t fFlags, PRTGCPTR ppvGC, uint32_t *pcb)
     463{
    466464    Assert(!CPUMIsGuestInLongMode(pVCpu));    /* DON'T USE! */
    467465
    … …  
    514512        X86DESC Desc;
    515513
     514        PVM pVM = pVCpu->CTX_SUFF(pVM);
    516515        if (!(Sel & X86_SEL_LDT))
    517516        {
    … …  
    834833 *
    835834 * @returns VBox status code.
    836  * @param   pVM          VM Handle.
    837  * @param   eflags       Current eflags
    838  * @param   SelCPL       Current privilege level. Get this from SS - CS might be conforming!
    839  *                       A full selector can be passed, we'll only use the RPL part.
    840  * @param   SelCS        Selector part.
    841  * @param   Addr         Address part.
    842  * @param   ppvFlat      Where to store the flat address.
    843  * @param   pcBits       Where to store the 64-bit/32-bit/16-bit indicator.
    844  */
    845 VMMDECL(int) SELMValidateAndConvertCSAddrGCTrap(PVM pVM, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS, RTGCPTR Addr, PRTGCPTR ppvFlat, uint32_t *pcBits)
    846 {
    847     Assert(pVM->cCpus == 1);
    848     PVMCPU pVCpu = &pVM->aCpus[0];
    849 
     835 * @param   pVCpu       The virtual CPU handle.
     836 * @param   eflags      Current eflags
     837 * @param   SelCPL      Current privilege level. Get this from SS - CS might be
     838 *                      conforming! A full selector can be passed, we'll only
     839 *                      use the RPL part.
     840 * @param   SelCS       Selector part.
     841 * @param   Addr        Address part.
     842 * @param   ppvFlat     Where to store the flat address.
     843 * @param   pcBits      Where to store the 64-bit/32-bit/16-bit indicator.
     844 */
     845VMMDECL(int) SELMValidateAndConvertCSAddrGCTrap(PVMCPU pVCpu, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS, RTGCPTR Addr, PRTGCPTR ppvFlat, uint32_t *pcBits)
     846{
    850847    if (    eflags.Bits.u1VM
    851848        ||  CPUMIsGuestInRealMode(pVCpu))
    … …  
    855852    }
    856853    Assert(!CPUMAreHiddenSelRegsValid(pVCpu));
    857     return selmValidateAndConvertCSAddrStd(pVM, pVCpu, SelCPL, SelCS, Addr, ppvFlat, pcBits);
     854    return selmValidateAndConvertCSAddrStd(pVCpu->CTX_SUFF(pVM), pVCpu, SelCPL, SelCS, Addr, ppvFlat, pcBits);
    858855}
    859856#endif /* IN_RC */
    … …  
    864861 *
    865862 * @returns VBox status code.
    866  * @param   pVM          VM Handle.
     863 * @param   pVCpu       The virtual CPU handle.
    867864 * @param   eflags       Current eflags
    868865 * @param   SelCPL       Current privilege level. Get this from SS - CS might be conforming!
    … …  
    873870 * @param   ppvFlat      Where to store the flat address.
    874871 */
    875 VMMDECL(int) SELMValidateAndConvertCSAddr(PVM pVM, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS, PCCPUMSELREGHID pHiddenCSSel,
     872VMMDECL(int) SELMValidateAndConvertCSAddr(PVMCPU pVCpu, X86EFLAGS eflags, RTSEL SelCPL, RTSEL SelCS, PCCPUMSELREGHID pHiddenCSSel,
    876873                                          RTGCPTR Addr, PRTGCPTR ppvFlat)
    877874{
    878     PVMCPU pVCpu = VMMGetCpu(pVM);
    879 
    880875    if (    eflags.Bits.u1VM
    881876        ||  CPUMIsGuestInRealMode(pVCpu))
    … …  
    887882    /** @todo when we're in 16 bits mode, we should cut off the address as well? (like in selmValidateAndConvertCSAddrRealMode) */
    888883    if (!CPUMAreHiddenSelRegsValid(pVCpu) || !pHiddenCSSel)
    889         return selmValidateAndConvertCSAddrStd(pVM, pVCpu, SelCPL, SelCS, Addr, ppvFlat, NULL);
     884        return selmValidateAndConvertCSAddrStd(pVCpu->CTX_SUFF(pVM), pVCpu, SelCPL, SelCS, Addr, ppvFlat, NULL);
    890885#endif
    891886    return selmValidateAndConvertCSAddrHidden(pVCpu, SelCPL, SelCS, pHiddenCSSel, Addr, ppvFlat);
    … …  
    925920 *
    926921 * @returns DISCPUMODE according to the selector type (16, 32 or 64 bits)
    927  * @param   pVM        VM Handle.
     922 * @param   pVCpu      The virtual CPU handle.
    928923 * @param   eflags     Current eflags register
    929924 * @param   Sel        The selector.
    930925 * @param   pHiddenSel The hidden selector register.
    931926 */
    932 VMMDECL(DISCPUMODE) SELMGetCpuModeFromSelector(PVM pVM, X86EFLAGS eflags, RTSEL Sel, PCCPUMSELREGHID pHiddenSel)
    933 {
    934     PVMCPU pVCpu = VMMGetCpu(pVM);
     927VMMDECL(DISCPUMODE) SELMGetCpuModeFromSelector(PVMCPU pVCpu, X86EFLAGS eflags, RTSEL Sel, PCCPUMSELREGHID pHiddenSel)
     928{
    935929#ifdef IN_RING0
    936930    Assert(CPUMAreHiddenSelRegsValid(pVCpu));
    … …  
    946940            return CPUMODE_16BIT;
    947941
    948         return selmGetCpuModeFromSelector(pVM, pVCpu, Sel);
     942        return selmGetCpuModeFromSelector(pVCpu->CTX_SUFF(pVM), pVCpu, Sel);
    949943    }
    950944#endif /* !IN_RING0 */

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

    r39078 r40449  
    488488            fakeflags.u32 = 0;
    489489
    490             rc = SELMValidateAndConvertCSAddr(pVM, fakeflags, 0, GuestIdte.Gen.u16SegSel, NULL, pHandler, &dummy);
     490            rc = SELMValidateAndConvertCSAddr(pVCpu, fakeflags, 0, GuestIdte.Gen.u16SegSel, NULL, pHandler, &dummy);
    491491            if (rc == VINF_SUCCESS)
    492492            {
    … …  
    554554                        || !ss_r0
    555555                        || (ss_r0 & X86_SEL_RPL) != ((dpl == 0) ? 1 : dpl)
    556                         || SELMToFlatBySelEx(pVM, fakeflags, ss_r0, (RTGCPTR)esp_r0, NULL, SELMTOFLAT_FLAGS_CPL1, (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS
     556                        || SELMToFlatBySelEx(pVCpu, fakeflags, ss_r0, (RTGCPTR)esp_r0, NULL, SELMTOFLAT_FLAGS_CPL1, (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS
    557557                       )
    558558                    {
    … …  
    568568
    569569                    if (    eflags.Bits.u1VM    /* illegal */
    570                         ||  SELMToFlatBySelEx(pVM, fakeflags, ss_r0, (RTGCPTR)esp_r0, NULL, SELMTOFLAT_FLAGS_CPL1, (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS)
     570                        ||  SELMToFlatBySelEx(pVCpu, fakeflags, ss_r0, (RTGCPTR)esp_r0, NULL, SELMTOFLAT_FLAGS_CPL1, (PRTGCPTR)&pTrapStackGC, NULL) != VINF_SUCCESS)
    571571                    {
    572572                        AssertMsgFailed(("Invalid stack %04X:%08RX32??? (VM=%d)\n", ss_r0, esp_r0, eflags.Bits.u1VM));

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

    r40447 r40449  
    27382738     * Only allow 32 & 64 bits code.
    27392739     */
    2740     DISCPUMODE enmMode = SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
     2740    DISCPUMODE enmMode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
    27412741    if (enmMode != CPUMODE_16BIT)
    27422742    {
    27432743        RTGCPTR pbCode;
    2744         int rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs,
     2744        int rc = SELMValidateAndConvertCSAddr(pVCpu, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs,
    27452745                                              &pRegFrame->csHid, (RTGCPTR)pRegFrame->rip, &pbCode);
    27462746        if (RT_SUCCESS(rc))

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

    r40447 r40449  
    31813181                        }
    31823182
    3183                         rc2 = SELMToFlatEx(pVM, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), pCtx->esp & uMask, 0, &GCPtrStack);
     3183                        rc2 = SELMToFlatEx(pVCpu, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), pCtx->esp & uMask, 0, &GCPtrStack);
    31843184                        if (RT_FAILURE(rc2))
    31853185                        {
    … …  
    32233223                        }
    32243224
    3225                         rc2 = SELMToFlatEx(pVM, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), (pCtx->esp - cbParm) & uMask, 0, &GCPtrStack);
     3225                        rc2 = SELMToFlatEx(pVCpu, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), (pCtx->esp - cbParm) & uMask, 0, &GCPtrStack);
    32263226                        if (RT_FAILURE(rc2))
    32273227                        {
    … …  
    32593259                        }
    32603260
    3261                         rc2 = SELMToFlatEx(pVM, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), pCtx->esp & uMask, 0, &GCPtrStack);
     3261                        rc2 = SELMToFlatEx(pVCpu, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), pCtx->esp & uMask, 0, &GCPtrStack);
    32623262                        if (RT_FAILURE(rc2))
    32633263                        {

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

    r40274 r40449  
    22722272    {
    22732273        /* Assuming 32 bits code for now. */
    2274         Assert(SELMGetCpuModeFromSelector(pVM, pCtxCore->eflags, pCtxCore->cs, &pCtxCore->csHid) == CPUMODE_32BIT);
     2274        Assert(SELMGetCpuModeFromSelector(VMMGetCpu0(pVM), pCtxCore->eflags, pCtxCore->cs, &pCtxCore->csHid) == CPUMODE_32BIT);
    22752275
    22762276        pInstrGC = SELMToFlat(pVM, DIS_SELREG_CS, pCtxCore, pInstrGC);

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

    r40442 r40449  
    684684            {
    685685                rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
    686                                         (SELMGetCpuModeFromSelector(pVM, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0);
     686                                        (SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0);
    687687                if (RT_SUCCESS(rc))
    688688                {
    … …  
    934934        {
    935935            int rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
    936                                         (SELMGetCpuModeFromSelector(pVM, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0);
     936                                        (SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0);
    937937            if (RT_SUCCESS(rc))
    938938            {
    … …  
    10411041        if (    (pCtx->ss & X86_SEL_RPL) == 0
    10421042            &&  !pCtx->eflags.Bits.u1VM
    1043             &&  SELMGetCpuModeFromSelector(pVM, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT)
     1043            &&  SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT)
    10441044        {
    10451045            STAM_PROFILE_START(&pVCpu->em.s.StatPrivEmu, a);

  • trunk/src/VBox/VMM/VMMRC/PATMRC.cpp

    r40447 r40449  
    472472            return VINF_SUCCESS;
    473473        }
    474         else
    475474        if (pRec->patch.flags & PATMFL_INT3_REPLACEMENT)
    476475        {
    … …  
    506505            }
    507506
    508             cpu.mode = SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->cs, 0);
    509             if(cpu.mode != CPUMODE_32BIT)
     507            cpu.mode = SELMGetCpuModeFromSelector(VMMGetCpu0(pVM), pRegFrame->eflags, pRegFrame->cs, 0);
     508            if (cpu.mode != CPUMODE_32BIT)
    510509            {
    511510                AssertFailed();

  • trunk/src/VBox/VMM/VMMRC/TRPMRC.cpp

    r40447 r40449  
    177177     */
    178178    RTGCPTR PC;
    179     int rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
     179    int rc = SELMValidateAndConvertCSAddr(pVCpu, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
    180180                                          (RTGCPTR)pRegFrame->eip, &PC);
    181181    if (rc == VINF_SUCCESS)

  • trunk/src/VBox/VMM/VMMRC/TRPMRCHandlers.cpp

    r40442 r40449  
    494494         */
    495495        RTGCPTR PC;
    496         rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
     496        rc = SELMValidateAndConvertCSAddr(pVCpu, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
    497497                                          (RTGCPTR)pRegFrame->eip, &PC);
    498498        if (RT_FAILURE(rc))
    … …  
    629629     */
    630630    RTGCPTR GCPtr;
    631     if (   SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
     631    if (   SELMValidateAndConvertCSAddr(pVCpu, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
    632632                                        (RTGCPTR)pRegFrame->eip, &GCPtr)
    633633        == VINF_SUCCESS)
    … …  
    951951    RTGCPTR PC;
    952952    uint32_t cBits;
    953     int rc = SELMValidateAndConvertCSAddrGCTrap(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs,
     953    int rc = SELMValidateAndConvertCSAddrGCTrap(pVCpu, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs,
    954954                                                (RTGCPTR)pRegFrame->eip, &PC, &cBits);
    955955    if (RT_FAILURE(rc))

  • trunk/src/VBox/VMM/VMMRZ/DBGFRZ.cpp

    r39405 r40449  
    125125    {
    126126        RTGCPTR pPc;
    127         int rc = SELMValidateAndConvertCSAddr(pVM, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
     127        int rc = SELMValidateAndConvertCSAddr(pVCpu, pRegFrame->eflags, pRegFrame->ss, pRegFrame->cs, &pRegFrame->csHid,
    128128#ifdef IN_RC
    129129                                              (RTGCPTR)((RTGCUINTPTR)pRegFrame->eip - 1),

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

    r40280 r40449  
    112112        case VINF_PATM_HC_MMIO_PATCH_READ:
    113113            rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
    114                                     PATMFL_MMIO_ACCESS | ((SELMGetCpuModeFromSelector(pVM, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0));
     114                                    PATMFL_MMIO_ACCESS | ((SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0));
    115115            if (RT_FAILURE(rc))
    116116                rc = emR3ExecuteInstruction(pVM, pVCpu, "MMIO");
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