VirtualBox

Changeset 102471 in vbox for trunk


Ignore:
Timestamp:
Dec 5, 2023 12:46:45 PM (14 months ago)
Author:
vboxsync
Message:

VMM/IEM: IEM_MC_ASSIGN_TO_SMALLER (lea); fixed a few bugs wrt guest register shadowing. bugref:10371

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/Makefile.kmk

    r101906 r102471  
    265265   VBoxVMM_LIBS.darwin += /opt/local/lib/libcapstone.dylib
    266266  endif
     267  VMMAll/IEMAllN8veRecompiler.cpp_CXXFLAGS.win = /bigobj
    267268 endif
    268269 VMMAll/IEMAllThrdFuncs.cpp_CXXFLAGS.win = /bigobj

  • trunk/src/VBox/VMM/VMMAll/IEMAllInstPython.py

    r102452 r102471  
    28172817    'IEM_MC_ARG_LOCAL_EFLAGS':                                   (McBlock.parseMcArgLocalEFlags,    False, True,  ),
    28182818    'IEM_MC_ARG_LOCAL_REF':                                      (McBlock.parseMcArgLocalRef,       False, True,  ),
    2819     'IEM_MC_ASSIGN_TO_SMALLER':                                  (McBlock.parseMcGeneric,           False, False, ),
     2819    'IEM_MC_ASSIGN_TO_SMALLER':                                  (McBlock.parseMcGeneric,           False, True, ),
    28202820    'IEM_MC_BEGIN':                                              (McBlock.parseMcBegin,             False, True,  ),
    28212821    'IEM_MC_BROADCAST_XREG_U16_ZX_VLMAX':                        (McBlock.parseMcGeneric,           True,  False, ),

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

    r102452 r102471  
    29492949        Assert(pReNative->Core.bmHstRegsWithGstShadow & RT_BIT_32(idxReg));
    29502950
     2951        pReNative->Core.bmHstRegsWithGstShadow &= ~RT_BIT_32(idxReg);
    29512952        pReNative->Core.bmGstRegShadows        &= ~pReNative->Core.aHstRegs[idxReg].fGstRegShadows;
    2952         pReNative->Core.bmHstRegsWithGstShadow &= ~RT_BIT_32(idxReg);
    29532953        pReNative->Core.aHstRegs[idxReg].fGstRegShadows = 0;
    29542954        return idxReg;
    … …  
    29892989
    29902990                pReNative->Core.aVars[idxVar].idxReg    = UINT8_MAX;
     2991                pReNative->Core.bmHstRegs              &= ~RT_BIT_32(idxReg);
     2992
     2993                pReNative->Core.bmHstRegsWithGstShadow &= ~RT_BIT_32(idxReg);
    29912994                pReNative->Core.bmGstRegShadows        &= ~pReNative->Core.aHstRegs[idxReg].fGstRegShadows;
    2992                 pReNative->Core.bmHstRegsWithGstShadow &= ~RT_BIT_32(idxReg);
    2993                 pReNative->Core.bmHstRegs              &= ~RT_BIT_32(idxReg);
     2995                pReNative->Core.aHstRegs[idxReg].fGstRegShadows = 0;
    29942996                return idxReg;
    29952997            }
    … …  
    30313033    if (fGstRegShadows)
    30323034    {
    3033         pReNative->Core.bmHstRegsWithGstShadow |= RT_BIT_32(idxRegNew);
     3035        pReNative->Core.bmHstRegsWithGstShadow = (pReNative->Core.bmHstRegsWithGstShadow & ~RT_BIT_32(idxRegOld))
     3036                                               | RT_BIT_32(idxRegNew);
    30343037        while (fGstRegShadows)
    30353038        {
    … …  
    31093112    pReNative->Core.aVars[idxVar].idxReg    = UINT8_MAX;
    31103113    pReNative->Core.bmHstRegsWithGstShadow &= ~RT_BIT_32(idxRegOld);
     3114    pReNative->Core.bmHstRegs              &= ~RT_BIT_32(idxRegOld);
    31113115    pReNative->Core.bmGstRegShadows        &= ~pReNative->Core.aHstRegs[idxRegOld].fGstRegShadows;
    3112     pReNative->Core.bmHstRegs              &= ~RT_BIT_32(idxRegOld);
    31133116    pReNative->Core.aHstRegs[idxRegOld].fGstRegShadows = 0;
    31143117    return off;
    … …  
    32023205{
    32033206    Assert(!(pReNative->Core.bmGstRegShadows & RT_BIT_64(enmGstReg)));
     3207    Assert(!pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows);
    32043208    Assert((unsigned)enmGstReg < (unsigned)kIemNativeGstReg_End);
    32053209
    32063210    pReNative->Core.aidxGstRegShadows[enmGstReg]       = idxHstReg;
    3207     pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows = RT_BIT_64(enmGstReg);
     3211    pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows = RT_BIT_64(enmGstReg); /** @todo why? not OR? */
    32083212    pReNative->Core.bmGstRegShadows                   |= RT_BIT_64(enmGstReg);
    32093213    pReNative->Core.bmHstRegsWithGstShadow            |= RT_BIT_32(idxHstReg);
    … …  
    33283332{
    33293333    Assert(pReNative->Core.aHstRegs[idxRegFrom].fGstRegShadows & RT_BIT_64(enmGstReg));
     3334    Assert(pReNative->Core.aidxGstRegShadows[enmGstReg] == idxRegFrom);
    33303335    Assert(      (pReNative->Core.bmGstRegShadows & pReNative->Core.aHstRegs[idxRegFrom].fGstRegShadows)
    33313336              == pReNative->Core.aHstRegs[idxRegFrom].fGstRegShadows
    … …  
    36253630                Assert(   (pReNative->Core.aHstRegs[idxReg].fGstRegShadows & pReNative->Core.bmGstRegShadows)
    36263631                       == pReNative->Core.aHstRegs[idxReg].fGstRegShadows);
    3627                 pReNative->Core.bmGstRegShadows &= ~pReNative->Core.aHstRegs[idxReg].fGstRegShadows;
     3632                pReNative->Core.bmHstRegsWithGstShadow &= ~RT_BIT_32(idxReg);
     3633                pReNative->Core.bmGstRegShadows        &= ~pReNative->Core.aHstRegs[idxReg].fGstRegShadows;
    36283634                pReNative->Core.aHstRegs[idxReg].fGstRegShadows = 0;
    36293635            }
    … …  
    37263732    {
    37273733        pReNative->Core.bmHstRegsWithGstShadow &= ~RT_BIT_32(idxHstReg);
    3728         uint64_t const fGstRegShadowsOld = pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows;
     3734        uint64_t const fGstRegShadowsOld        = pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows;
     3735        pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows = 0;
    37293736        pReNative->Core.bmGstRegShadows        &= ~fGstRegShadowsOld;
    3730         uint64_t       fGstRegShadows    = fGstRegShadowsOld;
     3737        uint64_t       fGstRegShadows           = fGstRegShadowsOld;
    37313738        while (fGstRegShadows)
    37323739        {
    … …  
    38653872     * Reduce the mask by what's currently shadowed
    38663873     */
    3867     fGstRegs &= pReNative->Core.bmGstRegShadows;
     3874    uint64_t const bmGstRegShadowsOld = pReNative->Core.bmGstRegShadows;
     3875    fGstRegs &= bmGstRegShadowsOld;
    38683876    if (fGstRegs)
    38693877    {
    3870         Log12(("iemNativeRegFlushGuestShadows: flushing %#RX64 (%#RX64 -> %#RX64)\n",
    3871                fGstRegs, pReNative->Core.bmGstRegShadows, pReNative->Core.bmGstRegShadows & ~fGstRegs));
    3872         pReNative->Core.bmGstRegShadows &= ~fGstRegs;
    3873         if (pReNative->Core.bmGstRegShadows)
     3878        uint64_t const bmGstRegShadowsNew = bmGstRegShadowsOld & ~fGstRegs;
     3879        Log12(("iemNativeRegFlushGuestShadows: flushing %#RX64 (%#RX64 -> %#RX64)\n", fGstRegs, bmGstRegShadowsOld, bmGstRegShadowsNew));
     3880        pReNative->Core.bmGstRegShadows = bmGstRegShadowsNew;
     3881        if (bmGstRegShadowsNew)
    38743882        {
    38753883            /*
    … …  
    38863894                uint64_t const fInThisHstReg = (pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows & fGstRegs) | RT_BIT_64(idxGstReg);
    38873895                fGstRegs &= ~fInThisHstReg;
    3888                 pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows &= ~fInThisHstReg;
    3889                 if (!pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows)
     3896                uint64_t const fGstRegShadowsNew = pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows & ~fInThisHstReg;
     3897                pReNative->Core.aHstRegs[idxHstReg].fGstRegShadows = fGstRegShadowsNew;
     3898                if (!fGstRegShadowsNew)
    38903899                    pReNative->Core.bmHstRegsWithGstShadow &= ~RT_BIT_32(idxHstReg);
    38913900            } while (fGstRegs != 0);
    … …  
    62706279    {
    62716280        idxReg = g_aidxIemNativeCallRegs[uArgNo];
     6281        iemNativeRegClearGstRegShadowing(pReNative, idxReg, *poff);
    62726282        Log11(("iemNativeVarAllocRegister: idxVar=%u idxReg=%u (matching arg %u)\n", idxVar, idxReg, uArgNo));
    62736283    }
    … …  
    65986608
    65996609
     6610#define IEM_MC_ASSIGN_TO_SMALLER(a_VarDst, a_VarSrcEol) off = iemNativeVarAssignToSmaller(pReNative, off, a_VarDst, a_VarSrcEol)
     6611
     6612/**
     6613 * This is called by IEM_MC_ASSIGN_TO_SMALLER.
     6614 */
     6615DECL_INLINE_THROW(uint32_t)
     6616iemNativeVarAssignToSmaller(PIEMRECOMPILERSTATE pReNative, uint32_t off, uint8_t idxVarDst, uint8_t idxVarSrc)
     6617{
     6618    IEMNATIVE_ASSERT_VAR_IDX(pReNative, idxVarDst);
     6619    AssertStmt(pReNative->Core.aVars[idxVarDst].enmKind == kIemNativeVarKind_Invalid,
     6620               IEMNATIVE_DO_LONGJMP(pReNative, VERR_IEM_VAR_UNEXPECTED_KIND));
     6621    Assert(   pReNative->Core.aVars[idxVarDst].cbVar == sizeof(uint16_t)
     6622           || pReNative->Core.aVars[idxVarDst].cbVar == sizeof(uint32_t));
     6623
     6624    IEMNATIVE_ASSERT_VAR_IDX(pReNative, idxVarSrc);
     6625    AssertStmt(   pReNative->Core.aVars[idxVarSrc].enmKind == kIemNativeVarKind_Stack
     6626               || pReNative->Core.aVars[idxVarSrc].enmKind == kIemNativeVarKind_Immediate,
     6627               IEMNATIVE_DO_LONGJMP(pReNative, VERR_IEM_VAR_UNEXPECTED_KIND));
     6628
     6629    Assert(pReNative->Core.aVars[idxVarDst].cbVar < pReNative->Core.aVars[idxVarSrc].cbVar);
     6630
     6631    /*
     6632     * Special case for immediates.
     6633     */
     6634    if (pReNative->Core.aVars[idxVarSrc].enmKind == kIemNativeVarKind_Immediate)
     6635    {
     6636        switch (pReNative->Core.aVars[idxVarDst].cbVar)
     6637        {
     6638            case sizeof(uint16_t):
     6639                iemNativeVarSetKindToConst(pReNative, idxVarDst, (uint16_t)pReNative->Core.aVars[idxVarSrc].u.uValue);
     6640                break;
     6641            case sizeof(uint32_t):
     6642                iemNativeVarSetKindToConst(pReNative, idxVarDst, (uint32_t)pReNative->Core.aVars[idxVarSrc].u.uValue);
     6643                break;
     6644            default: AssertFailed(); break;
     6645        }
     6646    }
     6647    else
     6648    {
     6649        /*
     6650         * The generic solution for now.
     6651         */
     6652        /** @todo optimize this by having the python script make sure the source
     6653         *        variable passed to IEM_MC_ASSIGN_TO_SMALLER is not used after the
     6654         *        statement.   Then we could just transfer the register assignments. */
     6655        uint8_t const idxRegDst = iemNativeVarAllocRegister(pReNative, idxVarDst, &off);
     6656        uint8_t const idxRegSrc = iemNativeVarAllocRegister(pReNative, idxVarSrc, &off);
     6657        switch (pReNative->Core.aVars[idxVarDst].cbVar)
     6658        {
     6659            case sizeof(uint16_t):
     6660                off = iemNativeEmitLoadGprFromGpr16(pReNative, off, idxRegDst, idxRegSrc);
     6661                break;
     6662            case sizeof(uint32_t):
     6663                off = iemNativeEmitLoadGprFromGpr32(pReNative, off, idxRegDst, idxRegSrc);
     6664                break;
     6665            default: AssertFailed(); break;
     6666        }
     6667    }
     6668    return off;
     6669}
     6670
     6671
    66006672
    66016673/*********************************************************************************************************************************
    … …  
    67126784        Assert(pReNative->Core.bmVars & RT_BIT_32(pReNative->Core.aidxArgVars[i]));
    67136785    }
     6786    iemNativeRegAssertSanity(pReNative);
    67146787#endif
    67156788
    … …  
    67206793    uint32_t bmVars = pReNative->Core.bmVars;
    67216794    if (bmVars)
     6795    {
    67226796        do
    67236797        {
    … …  
    67446818            }
    67456819        } while (bmVars != 0);
     6820#if 0 //def VBOX_STRICT
     6821        iemNativeRegAssertSanity(pReNative);
     6822#endif
     6823    }
    67466824
    67476825    uint8_t const cRegArgs = RT_MIN(cArgs, RT_ELEMENTS(g_aidxIemNativeCallRegs));
    … …  
    67526830     */
    67536831    if (pReNative->Core.bmHstRegs & g_afIemNativeCallRegs[cRegArgs])
     6832    {
    67546833        for (uint32_t i = 0; i < cRegArgs; i++)
    67556834        {
    … …  
    68016880            }
    68026881        }
     6882#if 0 //def VBOX_STRICT
     6883        iemNativeRegAssertSanity(pReNative);
     6884#endif
     6885    }
    68036886
    68046887    Assert(!(pReNative->Core.bmHstRegs & g_afIemNativeCallRegs[cHiddenArgs])); /* No variables for hidden arguments. */
    … …  
    68126895     */
    68136896    if (cArgs > IEMNATIVE_CALL_ARG_GREG_COUNT)
     6897    {
    68146898        for (unsigned i = IEMNATIVE_CALL_ARG_GREG_COUNT; i < cArgs; i++)
    68156899        {
    … …  
    68766960            }
    68776961        }
     6962# if 0 //def VBOX_STRICT
     6963        iemNativeRegAssertSanity(pReNative);
     6964# endif
     6965    }
    68786966#else
    68796967    AssertCompile(IEMNATIVE_CALL_MAX_ARG_COUNT <= IEMNATIVE_CALL_ARG_GREG_COUNT);
    … …  
    68886976     */
    68896977    if (~pReNative->Core.bmHstRegs & (g_afIemNativeCallRegs[cRegArgs] & ~g_afIemNativeCallRegs[cHiddenArgs]))
     6978    {
    68906979        for (unsigned i = cHiddenArgs; i < cRegArgs; i++)
    68916980        {
    … …  
    69567045            }
    69577046        }
     7047#if 0 //def VBOX_STRICT
     7048        iemNativeRegAssertSanity(pReNative);
     7049#endif
     7050    }
    69587051#ifdef VBOX_STRICT
    69597052    else
    … …  
    76247717    else
    76257718    {
    7626         AssertStmt(pReNative->Core.aVars[idxValueVar].enmKind != kIemNativeVarKind_Immediate,
     7719        AssertStmt(pReNative->Core.aVars[idxValueVar].enmKind == kIemNativeVarKind_Immediate,
    76277720                   IEMNATIVE_DO_LONGJMP(pReNative, VERR_IEM_VAR_UNEXPECTED_KIND));
    76287721        return iemNativeEmitStoreGregU8Const(pReNative, off, iGRegEx, (uint8_t)pReNative->Core.aVars[idxValueVar].u.uValue);
    … …  
    77567849    else
    77577850    {
    7758         AssertStmt(pReNative->Core.aVars[idxValueVar].enmKind != kIemNativeVarKind_Immediate,
     7851        AssertStmt(pReNative->Core.aVars[idxValueVar].enmKind == kIemNativeVarKind_Immediate,
    77597852                   IEMNATIVE_DO_LONGJMP(pReNative, VERR_IEM_VAR_UNEXPECTED_KIND));
    77607853        return iemNativeEmitStoreGregU16Const(pReNative, off, iGReg, (uint16_t)pReNative->Core.aVars[idxValueVar].u.uValue);
    … …  
    78397932    else
    78407933    {
    7841         AssertStmt(pReNative->Core.aVars[idxValueVar].enmKind != kIemNativeVarKind_Immediate,
     7934        AssertStmt(pReNative->Core.aVars[idxValueVar].enmKind == kIemNativeVarKind_Immediate,
    78427935                   IEMNATIVE_DO_LONGJMP(pReNative, VERR_IEM_VAR_UNEXPECTED_KIND));
    78437936        return iemNativeEmitStoreGregU32Const(pReNative, off, iGReg, (uint32_t)pReNative->Core.aVars[idxValueVar].u.uValue);
    … …  
    78927985    else
    78937986    {
    7894         AssertStmt(pReNative->Core.aVars[idxValueVar].enmKind != kIemNativeVarKind_Immediate,
     7987        AssertStmt(pReNative->Core.aVars[idxValueVar].enmKind == kIemNativeVarKind_Immediate,
    78957988                   IEMNATIVE_DO_LONGJMP(pReNative, VERR_IEM_VAR_UNEXPECTED_KIND));
    78967989        return iemNativeEmitStoreGregU64Const(pReNative, off, iGReg, pReNative->Core.aVars[idxValueVar].u.uValue);

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

    r102448 r102471  
    208208   do { pVCpu->cpum.GstCtx.eflags.u = (a_EFlags); Assert(pVCpu->cpum.GstCtx.eflags.u & X86_EFL_1); } while (0)
    209209
    210 #define IEM_MC_ASSIGN_TO_SMALLER(a_VarOrArg, a_CVariableOrConst) (a_VarOrArg) = (a_CVariableOrConst)
     210/** ASSUMES the source variable not used after this statement. */
     211#define IEM_MC_ASSIGN_TO_SMALLER(a_VarDst, a_VarSrcEol) (a_VarDst) = (a_VarSrcEol)
    211212
    212213#define IEM_MC_FETCH_GREG_U8(a_u8Dst, a_iGReg)          (a_u8Dst)  = iemGRegFetchU8(pVCpu, (a_iGReg))
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