VirtualBox

Changeset 41727 in vbox for trunk/src/VBox/VMM/VMMR3


Ignore:
Timestamp:
Jun 14, 2012 10:49:03 PM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
78535
Message:

DIS: register macro name adjustments.

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

Legend:

Unmodified
Added
Removed

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

    r41678 r41727  
    22632263        Assert(SELMGetCpuModeFromSelector(VMMGetCpu0(pVM), pCtxCore->eflags, pCtxCore->cs, &pCtxCore->csHid) == DISCPUMODE_32BIT);
    22642264
    2265         pInstrGC = SELMToFlat(pVM, DIS_SELREG_CS, pCtxCore, pInstrGC);
     2265        pInstrGC = SELMToFlat(pVM, DISSELREG_CS, pCtxCore, pInstrGC);
    22662266        return CSAMR3CheckCode(pVM, pInstrGC);
    22672267    }

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

    r41675 r41727  
    283283
    284284    if (   DIS_FMT_SEL_IS_REG(u32Sel)
    285         ?  DIS_FMT_SEL_GET_REG(u32Sel) == DIS_SELREG_CS
     285        ?  DIS_FMT_SEL_GET_REG(u32Sel) == DISSELREG_CS
    286286        :  pSelInfo->Sel == DIS_FMT_SEL_GET_VALUE(u32Sel))
    287287    {

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

    r41675 r41727  
    408408        /* Prefetch pages for EIP and ESP. */
    409409        /** @todo This is rather expensive. Should investigate if it really helps at all. */
    410         rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->rip));
     410        rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pCtx->rip));
    411411        if (rc == VINF_SUCCESS)
    412             rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), pCtx->rsp));
     412            rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_SS, CPUMCTX2CORE(pCtx), pCtx->rsp));
    413413        if (rc != VINF_SUCCESS)
    414414        {

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

    r41678 r41727  
    683683            if (pCtx->SysEnter.cs != 0)
    684684            {
    685                 rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
     685                rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
    686686                                        (SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == DISCPUMODE_32BIT) ? PATMFL_CODE32 : 0);
    687687                if (RT_SUCCESS(rc))
    … …  
    933933            && !PATMIsPatchGCAddr(pVM, pCtx->eip))
    934934        {
    935             int rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
     935            int rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
    936936                                        (SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == DISCPUMODE_32BIT) ? PATMFL_CODE32 : 0);
    937937            if (RT_SUCCESS(rc))
    … …  
    12771277        /* Prefetch pages for EIP and ESP. */
    12781278        /** @todo This is rather expensive. Should investigate if it really helps at all. */
    1279         rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->rip));
     1279        rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pCtx->rip));
    12801280        if (rc == VINF_SUCCESS)
    1281             rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DIS_SELREG_SS, CPUMCTX2CORE(pCtx), pCtx->rsp));
     1281            rc = PGMPrefetchPage(pVCpu, SELMToFlat(pVM, DISSELREG_SS, CPUMCTX2CORE(pCtx), pCtx->rsp));
    12821282        if (rc != VINF_SUCCESS)
    12831283        {

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

    r41678 r41727  
    20282028                *
    20292029                */
    2030             bool fUsesEax = (pDis->param2.fUse == DISUSE_REG_GEN32 && pDis->param2.base.reg_gen == USE_REG_EAX);
     2030            bool fUsesEax = (pDis->param2.fUse == DISUSE_REG_GEN32 && pDis->param2.base.reg_gen == DISGREG_EAX);
    20312031
    20322032            aPatch[off++] = 0x51;    /* push ecx */
    … …  
    20412041                {
    20422042                    aPatch[off++] = 0x89;    /* mov eax, src_reg */
    2043                     aPatch[off++] = MAKE_MODRM(3, pDis->param2.base.reg_gen, USE_REG_EAX);
     2043                    aPatch[off++] = MAKE_MODRM(3, pDis->param2.base.reg_gen, DISGREG_EAX);
    20442044                }
    20452045            }
    … …  
    20812081            Assert(pDis->param1.fUse == DISUSE_REG_GEN32);
    20822082
    2083             if (pDis->param1.base.reg_gen != USE_REG_ECX)
     2083            if (pDis->param1.base.reg_gen != DISGREG_ECX)
    20842084                aPatch[off++] = 0x51;    /* push ecx */
    2085             if (pDis->param1.base.reg_gen != USE_REG_EDX)
     2085            if (pDis->param1.base.reg_gen != DISGREG_EDX )
    20862086                aPatch[off++] = 0x52;    /* push edx */
    2087             if (pDis->param1.base.reg_gen != USE_REG_EAX)
     2087            if (pDis->param1.base.reg_gen != DISGREG_EAX)
    20882088                aPatch[off++] = 0x50;    /* push eax */
    20892089
    … …  
    20982098            aPatch[off++] = 0x32;
    20992099
    2100             if (pDis->param1.base.reg_gen != USE_REG_EAX)
     2100            if (pDis->param1.base.reg_gen != DISGREG_EAX)
    21012101            {
    21022102                aPatch[off++] = 0x89;    /* mov dst_reg, eax */
    2103                 aPatch[off++] = MAKE_MODRM(3, USE_REG_EAX, pDis->param1.base.reg_gen);
     2103                aPatch[off++] = MAKE_MODRM(3, DISGREG_EAX, pDis->param1.base.reg_gen);
    21042104            }
    21052105
    2106             if (pDis->param1.base.reg_gen != USE_REG_EAX)
     2106            if (pDis->param1.base.reg_gen != DISGREG_EAX)
    21072107                aPatch[off++] = 0x58;    /* pop eax */
    2108             if (pDis->param1.base.reg_gen != USE_REG_EDX)
     2108            if (pDis->param1.base.reg_gen != DISGREG_EDX )
    21092109                aPatch[off++] = 0x5A;    /* pop edx */
    2110             if (pDis->param1.base.reg_gen != USE_REG_ECX)
     2110            if (pDis->param1.base.reg_gen != DISGREG_ECX)
    21112111                aPatch[off++] = 0x59;    /* pop ecx */
    21122112        }

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

    r41681 r41727  
    17491749            /* mov ss, src? */
    17501750            if (    (pCpu->param1.fUse & DISUSE_REG_SEG)
    1751                 &&  (pCpu->param1.base.reg_seg == DIS_SELREG_SS))
     1751                &&  (pCpu->param1.base.reg_seg == DISSELREG_SS))
    17521752            {
    17531753                Log(("Force recompilation of next instruction for OP_MOV at %RRv\n", pCurInstrGC));
    … …  
    34863486
    34873487    pBranchTarget = pCtx->edx;
    3488     pBranchTarget = SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pBranchTarget);
     3488    pBranchTarget = SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pBranchTarget);
    34893489
    34903490    /* First we check if the duplicate function target lies in some existing function patch already. Will save some space. */
    … …  
    40684068    if (CPUMGetGuestCPL(pVCpu, CPUMCTX2CORE(pCtx)) == 0)
    40694069    {
    4070         RTRCPTR pInstrGCFlat = SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pInstrGC);
     4070        RTRCPTR pInstrGCFlat = SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), pInstrGC);
    40714071        if (pInstrGCFlat != pInstrGC)
    40724072        {
    … …  
    63086308
    63096309                    /* continue at the original instruction */
    6310                     *ppNewEip = pNewEip - SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), 0);
     6310                    *ppNewEip = pNewEip - SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), 0);
    63116311                    STAM_PROFILE_ADV_STOP(&pVM->patm.s.StatHandleTrap, a);
    63126312                    return VINF_SUCCESS;
    … …  
    63436343
    63446344            /* continue at the original instruction */
    6345             *ppNewEip = pNewEip - SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), 0);
     6345            *ppNewEip = pNewEip - SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), 0);
    63466346            STAM_PROFILE_ADV_STOP(&pVM->patm.s.StatHandleTrap, a);
    63476347            return VINF_SUCCESS;
    … …  
    63926392        }
    63936393
    6394         *ppNewEip = pNewEip - SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), 0);
     6394        *ppNewEip = pNewEip - SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), 0);
    63956395        STAM_PROFILE_ADV_STOP(&pVM->patm.s.StatHandleTrap, a);
    63966396        return rc;
    … …  
    64296429
    64306430    /* Return original address, correct by subtracting the CS base address. */
    6431     *ppNewEip = pNewEip - SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), 0);
     6431    *ppNewEip = pNewEip - SELMToFlat(pVM, DISSELREG_CS, CPUMCTX2CORE(pCtx), 0);
    64326432
    64336433    /* Reset the PATM stack. */

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

    r41692 r41727  
    424424    rc = patmPatchReadBytes(pVM, pPB, pCurInstrGC, cbInstrShutUpGcc);
    425425    AssertRC(rc);
    426     PATCHGEN_EPILOG(pPatch, cbInstrShutUpGcc); 
     426    PATCHGEN_EPILOG(pPatch, cbInstrShutUpGcc);
    427427    return rc;
    428428}
    … …  
    13671367        pPB[offset++] = 0x8D;              // lea       edx, dword ptr [dest]
    13681368        // duplicate and modify modrm byte and additional bytes if present (e.g. direct address)
    1369         pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, USE_REG_EDX, pCpu->ModRM.Bits.Rm);
     1369        pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, DISGREG_EDX , pCpu->ModRM.Bits.Rm);
    13701370
    13711371        i = 3;  /* standard offset of modrm bytes */
    … …  
    14621462    pPB[offset++] = 0x8D;              // lea       edx, dword ptr [dest]
    14631463    // duplicate and modify modrm byte and additional bytes if present (e.g. direct address)
    1464     pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, USE_REG_EDX, pCpu->ModRM.Bits.Rm);
     1464    pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, DISGREG_EDX , pCpu->ModRM.Bits.Rm);
    14651465
    14661466    i = 3;  /* standard offset of modrm bytes */
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