VirtualBox

Changeset 36833 in vbox


Ignore:
Timestamp:
Apr 24, 2011 10:59:32 PM (14 years ago)
Author:
vboxsync
Message:

IEM: Fixed missing RIP advancing when rCX was 0. 'LSS GReg, r/m' should not inhibit interrupt delivery like pop SS and mov SS, GReg.

Location:
trunk/src/VBox/VMM/VMMAll
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r36831 r36833  
    46774677
    46784678/**
    4679  * Implements 'mov SReg, r/m'.
     4679 * Common worker for 'pop SReg', 'mov SReg, GReg' and 'lXs GReg, reg/mem'.
    46804680 *
    46814681 * @param   iSegReg     The segment register number (valid).
    … …  
    47104710
    47114711        iemRegAddToRip(pIemCpu, cbInstr);
    4712         if (iSegReg == X86_SREG_SS)
    4713             EMSetInhibitInterruptsPC(IEMCPU_TO_VMCPU(pIemCpu), pCtx->rip);
    47144712        return VINF_SUCCESS;
    47154713    }
    … …  
    47394737            *pSel = uSel;
    47404738            iemRegAddToRip(pIemCpu, cbInstr);
    4741             EMSetInhibitInterruptsPC(IEMCPU_TO_VMCPU(pIemCpu), pCtx->rip);
    47424739            return VINF_SUCCESS;
    47434740        }
    … …  
    48814878
    48824879    iemRegAddToRip(pIemCpu, cbInstr);
    4883     if (iSegReg == X86_SREG_SS)
    4884         EMSetInhibitInterruptsPC(IEMCPU_TO_VMCPU(pIemCpu), pCtx->rip);
    48854880    return VINF_SUCCESS;
     4881}
     4882
     4883
     4884/**
     4885 * Implements 'mov SReg, r/m'.
     4886 *
     4887 * @param   iSegReg     The segment register number (valid).
     4888 * @param   uSel        The new selector value.
     4889 */
     4890IEM_CIMPL_DEF_2(iemCImpl_load_SReg, uint8_t, iSegReg, uint16_t, uSel)
     4891{
     4892    VBOXSTRICTRC rcStrict = IEM_CIMPL_CALL_2(iemCImpl_LoadSReg, iSegReg, uSel);
     4893    if (rcStrict == VINF_SUCCESS)
     4894    {
     4895        if (iSegReg == X86_SREG_SS)
     4896        {
     4897            PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
     4898            EMSetInhibitInterruptsPC(IEMCPU_TO_VMCPU(pIemCpu), pCtx->rip);
     4899        }
     4900    }
     4901    return rcStrict;
     4902}
     4903
     4904
     4905/**
     4906 * Implements 'pop SReg'.
     4907 *
     4908 * @param   iSegReg         The segment register number (valid).
     4909 * @param   enmEffOpSize    The efficient operand size (valid).
     4910 */
     4911IEM_CIMPL_DEF_2(iemOpCImpl_pop_Sreg, uint8_t, iSegReg, IEMMODE, enmEffOpSize)
     4912{
     4913    PCPUMCTX        pCtx = pIemCpu->CTX_SUFF(pCtx);
     4914    VBOXSTRICTRC    rcStrict;
     4915
     4916    /*
     4917     * Read the selector off the stack and join paths with mov ss, reg.
     4918     */
     4919    RTUINT64U TmpRsp;
     4920    TmpRsp.u = pCtx->rsp;
     4921    switch (enmEffOpSize)
     4922    {
     4923        case IEMMODE_16BIT:
     4924        {
     4925            uint16_t uSel;
     4926            rcStrict = iemMemStackPopU16Ex(pIemCpu, &uSel, &TmpRsp);
     4927            if (rcStrict == VINF_SUCCESS)
     4928                rcStrict = IEM_CIMPL_CALL_2(iemCImpl_LoadSReg, iSegReg, uSel);
     4929            break;
     4930        }
     4931
     4932        case IEMMODE_32BIT:
     4933        {
     4934            uint32_t u32Value;
     4935            rcStrict = iemMemStackPopU32Ex(pIemCpu, &u32Value, &TmpRsp);
     4936            if (rcStrict == VINF_SUCCESS)
     4937                rcStrict = IEM_CIMPL_CALL_2(iemCImpl_LoadSReg, iSegReg, (uint16_t)u32Value);
     4938            break;
     4939        }
     4940
     4941        case IEMMODE_64BIT:
     4942        {
     4943            uint64_t u64Value;
     4944            rcStrict = iemMemStackPopU64Ex(pIemCpu, &u64Value, &TmpRsp);
     4945            if (rcStrict == VINF_SUCCESS)
     4946                rcStrict = IEM_CIMPL_CALL_2(iemCImpl_LoadSReg, iSegReg, (uint16_t)u64Value);
     4947            break;
     4948        }
     4949        IEM_NOT_REACHED_DEFAULT_CASE_RET();
     4950    }
     4951
     4952    /*
     4953     * Commit the stack on success.
     4954     */
     4955    if (rcStrict == VINF_SUCCESS)
     4956    {
     4957        pCtx->rsp = TmpRsp.u;
     4958        if (iSegReg == X86_SREG_SS)
     4959            EMSetInhibitInterruptsPC(IEMCPU_TO_VMCPU(pIemCpu), pCtx->rip);
     4960    }
     4961    return rcStrict;
    48864962}
    48874963
    … …  
    49234999    }
    49245000
    4925     return rcStrict;
    4926 }
    4927 
    4928 
    4929 /**
    4930  * Implements 'pop SReg'.
    4931  *
    4932  * @param   iSegReg         The segment register number (valid).
    4933  * @param   enmEffOpSize    The efficient operand size (valid).
    4934  */
    4935 IEM_CIMPL_DEF_2(iemOpCImpl_pop_Sreg, uint8_t, iSegReg, IEMMODE, enmEffOpSize)
    4936 {
    4937     PCPUMCTX        pCtx = pIemCpu->CTX_SUFF(pCtx);
    4938     VBOXSTRICTRC    rcStrict;
    4939 
    4940     /*
    4941      * Read the selector off the stack and join paths with mov ss, reg.
    4942      */
    4943     RTUINT64U TmpRsp;
    4944     TmpRsp.u = pCtx->rsp;
    4945     switch (enmEffOpSize)
    4946     {
    4947         case IEMMODE_16BIT:
    4948         {
    4949             uint16_t uSel;
    4950             rcStrict = iemMemStackPopU16Ex(pIemCpu, &uSel, &TmpRsp);
    4951             if (rcStrict == VINF_SUCCESS)
    4952                 rcStrict = IEM_CIMPL_CALL_2(iemCImpl_LoadSReg, iSegReg, uSel);
    4953             break;
    4954         }
    4955 
    4956         case IEMMODE_32BIT:
    4957         {
    4958             uint32_t u32Value;
    4959             rcStrict = iemMemStackPopU32Ex(pIemCpu, &u32Value, &TmpRsp);
    4960             if (rcStrict == VINF_SUCCESS)
    4961                 rcStrict = IEM_CIMPL_CALL_2(iemCImpl_LoadSReg, iSegReg, (uint16_t)u32Value);
    4962             break;
    4963         }
    4964 
    4965         case IEMMODE_64BIT:
    4966         {
    4967             uint64_t u64Value;
    4968             rcStrict = iemMemStackPopU64Ex(pIemCpu, &u64Value, &TmpRsp);
    4969             if (rcStrict == VINF_SUCCESS)
    4970                 rcStrict = IEM_CIMPL_CALL_2(iemCImpl_LoadSReg, iSegReg, (uint16_t)u64Value);
    4971             break;
    4972         }
    4973         IEM_NOT_REACHED_DEFAULT_CASE_RET();
    4974     }
    4975 
    4976     /*
    4977      * Commit the stack on success.
    4978      */
    4979     if (rcStrict == VINF_SUCCESS)
    4980         pCtx->rsp = TmpRsp.u;
    49815001    return rcStrict;
    49825002}

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

    r36829 r36833  
    6666    ADDR_TYPE       uCounterReg = pCtx->ADDR_rCX;
    6767    if (uCounterReg == 0)
     68    {
     69        iemRegAddToRip(pIemCpu, cbInstr);
    6870        return VINF_SUCCESS;
     71    }
    6972
    7073    PCCPUMSELREGHID pSrc1Hid = iemSRegGetHid(pIemCpu, iEffSeg);
    … …  
    218221    ADDR_TYPE       uCounterReg = pCtx->ADDR_rCX;
    219222    if (uCounterReg == 0)
     223    {
     224        iemRegAddToRip(pIemCpu, cbInstr);
    220225        return VINF_SUCCESS;
     226    }
    221227
    222228    PCCPUMSELREGHID pSrc1Hid = iemSRegGetHid(pIemCpu, iEffSeg);
    … …  
    370376    ADDR_TYPE       uCounterReg = pCtx->ADDR_rCX;
    371377    if (uCounterReg == 0)
     378    {
     379        iemRegAddToRip(pIemCpu, cbInstr);
    372380        return VINF_SUCCESS;
     381    }
    373382
    374383    VBOXSTRICTRC rcStrict = iemMemSegCheckReadAccessEx(pIemCpu, &pCtx->esHid, X86_SREG_ES);
    … …  
    495504    ADDR_TYPE       uCounterReg = pCtx->ADDR_rCX;
    496505    if (uCounterReg == 0)
     506    {
     507        iemRegAddToRip(pIemCpu, cbInstr);
    497508        return VINF_SUCCESS;
     509    }
    498510
    499511    VBOXSTRICTRC rcStrict = iemMemSegCheckReadAccessEx(pIemCpu, &pCtx->esHid, X86_SREG_ES);
    … …  
    622634    ADDR_TYPE       uCounterReg = pCtx->ADDR_rCX;
    623635    if (uCounterReg == 0)
     636    {
     637        iemRegAddToRip(pIemCpu, cbInstr);
    624638        return VINF_SUCCESS;
     639    }
    625640
    626641    PCCPUMSELREGHID pSrcHid = iemSRegGetHid(pIemCpu, iEffSeg);
    … …  
    734749    if (rcStrict == VINF_SUCCESS)
    735750        iemRegAddToRip(pIemCpu, cbInstr);
    736     else
    737         AssertFailed();
    738751
    739752    return rcStrict;
    … …  
    753766    ADDR_TYPE       uCounterReg = pCtx->ADDR_rCX;
    754767    if (uCounterReg == 0)
     768    {
     769        iemRegAddToRip(pIemCpu, cbInstr);
    755770        return VINF_SUCCESS;
     771    }
    756772
    757773    VBOXSTRICTRC rcStrict = iemMemSegCheckWriteAccessEx(pIemCpu, &pCtx->esHid, X86_SREG_ES);
    … …  
    866882    ADDR_TYPE       uCounterReg = pCtx->ADDR_rCX;
    867883    if (uCounterReg == 0)
     884    {
     885        iemRegAddToRip(pIemCpu, cbInstr);
    868886        return VINF_SUCCESS;
     887    }
    869888
    870889    PCCPUMSELREGHID pSrcHid = iemSRegGetHid(pIemCpu, iEffSeg);
    … …  
    10381057    ADDR_TYPE       uCounterReg = pCtx->ADDR_rCX;
    10391058    if (uCounterReg == 0)
     1059    {
     1060        iemRegAddToRip(pIemCpu, cbInstr);
    10401061        return VINF_SUCCESS;
     1062    }
    10411063
    10421064    rcStrict = iemMemSegCheckWriteAccessEx(pIemCpu, &pCtx->esHid, X86_SREG_ES);
    … …  
    12321254    ADDR_TYPE       uCounterReg = pCtx->ADDR_rCX;
    12331255    if (uCounterReg == 0)
     1256    {
     1257        iemRegAddToRip(pIemCpu, cbInstr);
    12341258        return VINF_SUCCESS;
     1259    }
    12351260
    12361261    PCCPUMSELREGHID pHid = iemSRegGetHid(pIemCpu, iEffSeg);

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

    r36829 r36833  
    59935993        IEM_MC_ARG(uint16_t,      u16Value,          1);
    59945994        IEM_MC_FETCH_GREG_U16(u16Value, (bRm & X86_MODRM_RM_MASK) | pIemCpu->uRexB);
    5995         IEM_MC_CALL_CIMPL_2(iemCImpl_LoadSReg, iSRegArg, u16Value);
     5995        IEM_MC_CALL_CIMPL_2(iemCImpl_load_SReg, iSRegArg, u16Value);
    59965996        IEM_MC_END();
    59975997    }
    … …  
    60086008        IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffDst, bRm);
    60096009        IEM_MC_FETCH_MEM_U16(u16Value, pIemCpu->iEffSeg, GCPtrEffDst);
    6010         IEM_MC_CALL_CIMPL_2(iemCImpl_LoadSReg, iSRegArg, u16Value);
     6010        IEM_MC_CALL_CIMPL_2(iemCImpl_load_SReg, iSRegArg, u16Value);
    60116011        IEM_MC_END();
    60126012    }
    … …  
    60176017/** Opcode 0x8f. */
    60186018FNIEMOP_STUB(iemOp_pop_Ev);
     6019/** @todo DO ME NEXT, PLEEEASE. */
    60196020
    60206021
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