Lines Matching defs:pIemCpu
29 * @param pIemCpu The IEM per CPU data.
34 static VBOXSTRICTRC iemHlpCheckPortIOPermissionBitmap(PIEMCPU pIemCpu, PCCPUMCTX pCtx, uint16_t u16Port, uint8_t cbOperand)
51 return iemRaiseGeneralProtectionFault0(pIemCpu);
58 VBOXSTRICTRC rcStrict = iemMemFetchSysU16(pIemCpu, &offBitmap, UINT8_MAX,
78 return iemRaiseGeneralProtectionFault0(pIemCpu);
88 rcStrict = iemMemFetchSysU16(pIemCpu, &bmBytes, UINT8_MAX, pCtx->tr.u64Base + offFirstBit);
104 return iemRaiseGeneralProtectionFault0(pIemCpu);
118 * @param pIemCpu The IEM per CPU data.
123 DECLINLINE(VBOXSTRICTRC) iemHlpCheckPortIOPermission(PIEMCPU pIemCpu, PCCPUMCTX pCtx, uint16_t u16Port, uint8_t cbOperand)
126 Efl.u = IEMMISC_GET_EFL(pIemCpu, pCtx);
128 && ( pIemCpu->uCpl > Efl.Bits.u2IOPL
130 return iemHlpCheckPortIOPermissionBitmap(pIemCpu, pCtx, u16Port, cbOperand);
172 * @param pIemCpu The IEM state of the calling EMT.
177 static void iemHlpUpdateArithEFlagsU8(PIEMCPU pIemCpu, uint8_t u8Result, uint32_t fToUpdate, uint32_t fUndefined)
179 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
186 pIemCpu->fUndefinedEFlags |= fUndefined;
197 static void iemHlpAdjustSelectorForNewCpl(PIEMCPU pIemCpu, uint8_t uCpl, PCPUMSELREG pSReg)
200 if (!CPUMSELREG_ARE_HIDDEN_PARTS_VALID(IEMCPU_TO_VMCPU(pIemCpu), pSReg))
201 CPUMGuestLazyLoadHiddenSelectorReg(IEMCPU_TO_VMCPU(pIemCpu), pSReg);
203 Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(IEMCPU_TO_VMCPU(pIemCpu), pSReg));
210 iemHlpLoadNullDataSelectorProt(pIemCpu, pSReg, 0);
217 * @param pIemCpu The IEM state of the calling EMT.
219 DECLINLINE(void) iemHlpUsedFpu(PIEMCPU pIemCpu)
221 CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_FPU_REM);
235 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
236 RTGCPTR GCPtrStart = iemRegGetEffRsp(pIemCpu, pCtx);
248 if (RT_UNLIKELY( IEM_IS_REAL_OR_V86_MODE(pIemCpu)
254 rcStrict = iemMemStackPopU16Ex(pIemCpu, &pCtx->di, &TmpRsp);
256 rcStrict = iemMemStackPopU16Ex(pIemCpu, &pCtx->si, &TmpRsp);
258 rcStrict = iemMemStackPopU16Ex(pIemCpu, &pCtx->bp, &TmpRsp);
261 iemRegAddToRspEx(pIemCpu, pCtx, &TmpRsp, 2); /* sp */
262 rcStrict = iemMemStackPopU16Ex(pIemCpu, &pCtx->bx, &TmpRsp);
265 rcStrict = iemMemStackPopU16Ex(pIemCpu, &pCtx->dx, &TmpRsp);
267 rcStrict = iemMemStackPopU16Ex(pIemCpu, &pCtx->cx, &TmpRsp);
269 rcStrict = iemMemStackPopU16Ex(pIemCpu, &pCtx->ax, &TmpRsp);
273 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
279 rcStrict = iemMemMap(pIemCpu, (void **)&pa16Mem, 16, X86_SREG_SS, GCPtrStart, IEM_ACCESS_STACK_R);
290 rcStrict = iemMemCommitAndUnmap(pIemCpu, (void *)pa16Mem, IEM_ACCESS_STACK_R);
293 iemRegAddToRsp(pIemCpu, pCtx, 16);
294 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
307 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
308 RTGCPTR GCPtrStart = iemRegGetEffRsp(pIemCpu, pCtx);
320 if (RT_UNLIKELY( IEM_IS_REAL_OR_V86_MODE(pIemCpu)
326 rcStrict = iemMemStackPopU32Ex(pIemCpu, &pCtx->edi, &TmpRsp);
328 rcStrict = iemMemStackPopU32Ex(pIemCpu, &pCtx->esi, &TmpRsp);
330 rcStrict = iemMemStackPopU32Ex(pIemCpu, &pCtx->ebp, &TmpRsp);
333 iemRegAddToRspEx(pIemCpu, pCtx, &TmpRsp, 2); /* sp */
334 rcStrict = iemMemStackPopU32Ex(pIemCpu, &pCtx->ebx, &TmpRsp);
337 rcStrict = iemMemStackPopU32Ex(pIemCpu, &pCtx->edx, &TmpRsp);
339 rcStrict = iemMemStackPopU32Ex(pIemCpu, &pCtx->ecx, &TmpRsp);
341 rcStrict = iemMemStackPopU32Ex(pIemCpu, &pCtx->eax, &TmpRsp);
354 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
360 rcStrict = iemMemMap(pIemCpu, (void **)&pa32Mem, 32, X86_SREG_SS, GCPtrStart, IEM_ACCESS_STACK_R);
371 rcStrict = iemMemCommitAndUnmap(pIemCpu, (void *)pa32Mem, IEM_ACCESS_STACK_R);
374 iemRegAddToRsp(pIemCpu, pCtx, 32);
375 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
388 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
389 RTGCPTR GCPtrTop = iemRegGetEffRsp(pIemCpu, pCtx);
402 && IEM_IS_REAL_OR_V86_MODE(pIemCpu) ) )
407 rcStrict = iemMemStackPushU16Ex(pIemCpu, pCtx->ax, &TmpRsp);
409 rcStrict = iemMemStackPushU16Ex(pIemCpu, pCtx->cx, &TmpRsp);
411 rcStrict = iemMemStackPushU16Ex(pIemCpu, pCtx->dx, &TmpRsp);
413 rcStrict = iemMemStackPushU16Ex(pIemCpu, pCtx->bx, &TmpRsp);
415 rcStrict = iemMemStackPushU16Ex(pIemCpu, pCtx->sp, &TmpRsp);
417 rcStrict = iemMemStackPushU16Ex(pIemCpu, pCtx->bp, &TmpRsp);
419 rcStrict = iemMemStackPushU16Ex(pIemCpu, pCtx->si, &TmpRsp);
421 rcStrict = iemMemStackPushU16Ex(pIemCpu, pCtx->di, &TmpRsp);
425 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
432 rcStrict = iemMemMap(pIemCpu, (void **)&pa16Mem, 16, X86_SREG_SS, GCPtrBottom, IEM_ACCESS_STACK_W);
443 rcStrict = iemMemCommitAndUnmap(pIemCpu, (void *)pa16Mem, IEM_ACCESS_STACK_W);
446 iemRegSubFromRsp(pIemCpu, pCtx, 16);
447 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
460 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
461 RTGCPTR GCPtrTop = iemRegGetEffRsp(pIemCpu, pCtx);
474 && IEM_IS_REAL_OR_V86_MODE(pIemCpu) ) )
479 rcStrict = iemMemStackPushU32Ex(pIemCpu, pCtx->eax, &TmpRsp);
481 rcStrict = iemMemStackPushU32Ex(pIemCpu, pCtx->ecx, &TmpRsp);
483 rcStrict = iemMemStackPushU32Ex(pIemCpu, pCtx->edx, &TmpRsp);
485 rcStrict = iemMemStackPushU32Ex(pIemCpu, pCtx->ebx, &TmpRsp);
487 rcStrict = iemMemStackPushU32Ex(pIemCpu, pCtx->esp, &TmpRsp);
489 rcStrict = iemMemStackPushU32Ex(pIemCpu, pCtx->ebp, &TmpRsp);
491 rcStrict = iemMemStackPushU32Ex(pIemCpu, pCtx->esi, &TmpRsp);
493 rcStrict = iemMemStackPushU32Ex(pIemCpu, pCtx->edi, &TmpRsp);
497 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
504 rcStrict = iemMemMap(pIemCpu, (void **)&pa32Mem, 32, X86_SREG_SS, GCPtrBottom, IEM_ACCESS_STACK_W);
515 rcStrict = iemMemCommitAndUnmap(pIemCpu, pa32Mem, IEM_ACCESS_STACK_W);
518 iemRegSubFromRsp(pIemCpu, pCtx, 32);
519 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
535 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
541 uint32_t fEfl = IEMMISC_GET_EFL(pIemCpu, pCtx);
548 return iemRaiseGeneralProtectionFault0(pIemCpu);
551 return iemMemStackPushU16(pIemCpu, (uint16_t)fEfl);
563 rcStrict = iemMemStackPushU16(pIemCpu, (uint16_t)fEfl);
566 rcStrict = iemMemStackPushU32(pIemCpu, fEfl);
569 rcStrict = iemMemStackPushU64(pIemCpu, fEfl);
576 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
588 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
589 uint32_t const fEflOld = IEMMISC_GET_EFL(pIemCpu, pCtx);
608 rcStrict = iemMemStackPopU16(pIemCpu, &u16Value);
615 rcStrict = iemMemStackPopU32(pIemCpu, &fEflNew);
634 rcStrict = iemMemStackPopU16Ex(pIemCpu, &u16Value, &TmpRsp);
643 return iemRaiseGeneralProtectionFault0(pIemCpu);
653 return iemRaiseGeneralProtectionFault0(pIemCpu);
667 rcStrict = iemMemStackPopU16(pIemCpu, &u16Value);
674 rcStrict = iemMemStackPopU32(pIemCpu, &fEflNew);
681 rcStrict = iemMemStackPopU64(pIemCpu, &u64Value);
692 || pIemCpu->uCpl == 0)
697 else if (pIemCpu->uCpl <= X86_EFL_GET_IOPL(fEflOld))
713 IEMMISC_SET_EFL(pIemCpu, pCtx, fEflNew);
714 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
729 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
732 return iemRaiseGeneralProtectionFault0(pIemCpu);
734 VBOXSTRICTRC rcStrict = iemMemStackPushU16(pIemCpu, uOldPC);
751 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
755 return iemRaiseGeneralProtectionFault0(pIemCpu);
757 VBOXSTRICTRC rcStrict = iemMemStackPushU16(pIemCpu, uOldPC);
776 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
779 return iemRaiseGeneralProtectionFault0(pIemCpu);
781 VBOXSTRICTRC rcStrict = iemMemStackPushU32(pIemCpu, uOldPC);
791 && !CSAMIsEnabled(IEMCPU_TO_VM(pIemCpu))
792 && pIemCpu->uCpl == 0)
794 EMSTATE enmState = EMGetState(IEMCPU_TO_VMCPU(pIemCpu));
798 CSAMR3RecordCallAddress(IEMCPU_TO_VM(pIemCpu), pCtx->eip);
815 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
819 return iemRaiseGeneralProtectionFault0(pIemCpu);
821 VBOXSTRICTRC rcStrict = iemMemStackPushU32(pIemCpu, uOldPC);
840 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
843 return iemRaiseGeneralProtectionFault0(pIemCpu);
845 VBOXSTRICTRC rcStrict = iemMemStackPushU64(pIemCpu, uOldPC);
862 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
866 return iemRaiseNotCanonical(pIemCpu);
868 VBOXSTRICTRC rcStrict = iemMemStackPushU64(pIemCpu, uOldPC);
896 if ( pDesc->Legacy.Gate.u2Dpl < pIemCpu->uCpl
900 pIemCpu->uCpl, (uSel & X86_SEL_RPL)));
901 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel & X86_SEL_MASK_OFF_RPL);
910 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uSel & X86_SEL_MASK_OFF_RPL);
913 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
915 return iemTaskSwitch(pIemCpu, pIemCpu->CTX_SUFF(pCtx), enmBranch == IEMBRANCH_JUMP ? IEMTASKSWITCH_JUMP : IEMTASKSWITCH_CALL,
937 if ( pDesc->Legacy.Gate.u2Dpl < pIemCpu->uCpl
941 pIemCpu->uCpl, (uSel & X86_SEL_RPL)));
942 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel & X86_SEL_MASK_OFF_RPL);
951 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uSel & X86_SEL_MASK_OFF_RPL);
961 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel & X86_SEL_MASK_OFF_RPL);
965 VBOXSTRICTRC rcStrict = iemMemFetchSelDesc(pIemCpu, &TssDesc, uSelTss, X86_XCPT_GP);
973 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel & X86_SEL_MASK_OFF_RPL);
979 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uSelTss & X86_SEL_MASK_OFF_RPL);
982 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
984 return iemTaskSwitch(pIemCpu, pIemCpu->CTX_SUFF(pCtx), enmBranch == IEMBRANCH_JUMP ? IEMTASKSWITCH_JUMP : IEMTASKSWITCH_CALL,
1035 if ( pDesc->Legacy.Gate.u2Dpl < pIemCpu->uCpl
1039 pIemCpu->uCpl, (uSel & X86_SEL_RPL)));
1040 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1047 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uSel);
1054 rcStrict = iemMemFetchSelDesc(pIemCpu, &DescCS, uNewCS, X86_XCPT_GP);
1064 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCS);
1072 if (DescCS.Legacy.Gen.u2Dpl > pIemCpu->uCpl)
1075 uNewCS, DescCS.Legacy.Gen.u2Dpl, pIemCpu->uCpl));
1076 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCS);
1081 if (DescCS.Legacy.Gen.u2Dpl != pIemCpu->uCpl)
1084 uNewCS, DescCS.Legacy.Gen.u2Dpl, pIemCpu->uCpl));
1085 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCS);
1092 if (DescCS.Legacy.Gen.u2Dpl > pIemCpu->uCpl)
1095 uNewCS, DescCS.Legacy.Gen.u2Dpl, pIemCpu->uCpl));
1096 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCS & X86_SEL_MASK_OFF_RPL);
1101 if (IEM_IS_LONG_MODE(pIemCpu))
1106 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCS);
1114 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCS);
1121 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uNewCS);
1124 pCtx = pIemCpu->CTX_SUFF(pCtx);
1144 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, 0);
1153 return iemRaiseNotCanonical(pIemCpu);
1162 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewCS);
1172 pCtx->cs.Sel |= pIemCpu->uCpl; /** @todo is this right for conforming segs? or in general? */
1184 if (DescCS.Legacy.Gen.u2Dpl < pIemCpu->uCpl)
1209 if (!IEM_IS_LONG_MODE(pIemCpu))
1234 return iemRaiseTaskSwitchFaultBySelector(pIemCpu, pCtx->tr.Sel);
1238 rcStrict = iemMemMap(pIemCpu, &uPtrTSS.pv, cbNewStack, UINT8_MAX, GCPtrTSS, IEM_ACCESS_SYS_R);
1245 if (!IEM_IS_LONG_MODE(pIemCpu))
1268 rcStrict = iemMemCommitAndUnmap(pIemCpu, uPtrTSS.pv, IEM_ACCESS_SYS_R);
1279 if (!IEM_IS_LONG_MODE(pIemCpu))
1284 return iemRaiseTaskSwitchFaultBySelector(pIemCpu, uNewSS);
1288 rcStrict = iemMemFetchSelDesc(pIemCpu, &DescSS, uNewSS, X86_XCPT_SS);
1298 return iemRaiseTaskSwitchFaultBySelector(pIemCpu, uNewSS);
1305 return iemRaiseTaskSwitchFaultBySelector(pIemCpu, uNewSS);
1311 return iemRaiseStackSelectorNotPresentBySelector(pIemCpu, uNewSS);
1321 rcStrict = iemMemFetchSelDesc(pIemCpu, &DescSS, uNewSS, X86_XCPT_SS);
1342 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewSS);
1362 pIemCpu->uCpl = uNewCSDpl;
1363 Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(IEMCPU_TO_VMCPU(pIemCpu), &pCtx->ss));
1364 CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_HIDDEN_SEL_REGS);
1367 rcStrict = iemMemStackPushBeginSpecial(pIemCpu, cbNewStack,
1375 if (!IEM_IS_LONG_MODE(pIemCpu))
1384 rcStrict = iemMemMap(pIemCpu, &uPtrParmWds.pv, cbWords * 4, UINT8_MAX, GCPtrParmWds, IEM_ACCESS_DATA_R);
1396 rcStrict = iemMemCommitAndUnmap(pIemCpu, uPtrParmWds.pv, IEM_ACCESS_DATA_R);
1416 rcStrict = iemMemMap(pIemCpu, &uPtrParmWds.pv, cbWords * 2, UINT8_MAX, GCPtrParmWds, IEM_ACCESS_DATA_R);
1428 rcStrict = iemMemCommitAndUnmap(pIemCpu, uPtrParmWds.pv, IEM_ACCESS_DATA_R);
1451 rcStrict = iemMemStackPushCommitSpecial(pIemCpu, uPtrRet.pv, uNewRsp);
1464 if (!IEM_IS_LONG_MODE(pIemCpu))
1469 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, 0);
1479 return iemRaiseNotCanonical(pIemCpu);
1492 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewCS);
1502 pCtx->cs.Sel |= pIemCpu->uCpl;
1517 rcStrict = iemMemStackPushBeginSpecial(pIemCpu,
1518 IEM_IS_LONG_MODE(pIemCpu) ? 8+8
1530 if (!IEM_IS_LONG_MODE(pIemCpu))
1535 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, 0);
1544 return iemRaiseNotCanonical(pIemCpu);
1557 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewCS);
1565 if (!IEM_IS_LONG_MODE(pIemCpu))
1586 rcStrict = iemMemStackPushCommitSpecial(pIemCpu, uPtrRet.pv, uNewRsp);
1593 pCtx->cs.Sel |= pIemCpu->uCpl;
1620 if (IEM_IS_LONG_MODE(pIemCpu))
1633 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1651 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1655 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1664 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1678 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
1687 if ( pIemCpu->enmCpuMode == IEMMODE_16BIT
1688 && IEM_IS_REAL_OR_V86_MODE(pIemCpu))
1691 return iemRaiseGeneralProtectionFault0(pIemCpu);
1711 return iemRaiseGeneralProtectionFault0(pIemCpu);
1716 VBOXSTRICTRC rcStrict = iemMemFetchSelDesc(pIemCpu, &Desc, uSel, X86_XCPT_GP);
1724 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uSel);
1738 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1744 && IEM_IS_LONG_MODE(pIemCpu))
1747 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1753 if (pIemCpu->uCpl < Desc.Legacy.Gen.u2Dpl)
1756 uSel, offSeg, Desc.Legacy.Gen.u2Dpl, pIemCpu->uCpl));
1757 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1762 if (pIemCpu->uCpl != Desc.Legacy.Gen.u2Dpl)
1764 Log(("jmpf %04x:%08RX64 -> CPL != DPL; DPL=%d CPL=%u\n", uSel, offSeg, Desc.Legacy.Gen.u2Dpl, pIemCpu->uCpl));
1765 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1767 if ((uSel & X86_SEL_RPL) > pIemCpu->uCpl)
1769 Log(("jmpf %04x:%08RX64 -> RPL > DPL; RPL=%d CPL=%u\n", uSel, offSeg, (uSel & X86_SEL_RPL), pIemCpu->uCpl));
1770 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1782 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
1790 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1801 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uSel);
1811 pCtx->cs.Sel |= pIemCpu->uCpl; /** @todo is this right for conforming segs? or in general? */
1835 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
1845 if ( pIemCpu->enmCpuMode == IEMMODE_16BIT
1846 && IEM_IS_REAL_OR_V86_MODE(pIemCpu))
1851 rcStrict = iemMemStackPushBeginSpecial(pIemCpu, enmEffOpSize == IEMMODE_32BIT ? 6 : 4,
1858 return iemRaiseGeneralProtectionFault0(pIemCpu);
1871 rcStrict = iemMemStackPushCommitSpecial(pIemCpu, uPtrRet.pv, uNewRsp);
1891 return iemRaiseGeneralProtectionFault0(pIemCpu);
1896 rcStrict = iemMemFetchSelDesc(pIemCpu, &Desc, uSel, X86_XCPT_GP);
1911 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1917 && IEM_IS_LONG_MODE(pIemCpu))
1920 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1926 if (pIemCpu->uCpl < Desc.Legacy.Gen.u2Dpl)
1929 uSel, offSeg, Desc.Legacy.Gen.u2Dpl, pIemCpu->uCpl));
1930 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1935 if (pIemCpu->uCpl != Desc.Legacy.Gen.u2Dpl)
1937 Log(("callf %04x:%08RX64 -> CPL != DPL; DPL=%d CPL=%u\n", uSel, offSeg, Desc.Legacy.Gen.u2Dpl, pIemCpu->uCpl));
1938 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1940 if ((uSel & X86_SEL_RPL) > pIemCpu->uCpl)
1942 Log(("callf %04x:%08RX64 -> RPL > DPL; RPL=%d CPL=%u\n", uSel, offSeg, (uSel & X86_SEL_RPL), pIemCpu->uCpl));
1943 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1951 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uSel);
1957 rcStrict = iemMemStackPushBeginSpecial(pIemCpu,
1971 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
1976 return iemRaiseNotCanonical(pIemCpu);
1986 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
1999 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uSel);
2022 rcStrict = iemMemStackPushCommitSpecial(pIemCpu, uPtrRet.pv, uNewRsp);
2029 pCtx->cs.Sel |= pIemCpu->uCpl;
2051 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
2064 rcStrict = iemMemStackPopBeginSpecial(pIemCpu, cbRetPtr, &uPtrFrame.pv, &uNewRsp);
2086 if ( pIemCpu->enmCpuMode == IEMMODE_16BIT
2087 && IEM_IS_REAL_OR_V86_MODE(pIemCpu))
2096 return iemRaiseSelectorBounds(pIemCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
2099 rcStrict = iemMemStackPopCommitSpecial(pIemCpu, uPtrFrame.pv, uNewRsp);
2110 iemRegAddToRsp(pIemCpu, pCtx, cbPop);
2120 return iemRaiseGeneralProtectionFault0(pIemCpu);
2125 rcStrict = iemMemFetchSelDesc(pIemCpu, &DescCs, uNewCs, X86_XCPT_GP);
2135 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
2141 && IEM_IS_LONG_MODE(pIemCpu))
2144 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
2148 if ((uNewCs & X86_SEL_RPL) < pIemCpu->uCpl)
2150 Log(("retf %04x:%08RX64 -> RPL < CPL(%d).\n", uNewCs, uNewRip, pIemCpu->uCpl));
2151 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
2160 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
2169 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
2177 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uNewCs);
2183 if ((uNewCs & X86_SEL_RPL) != pIemCpu->uCpl)
2187 rcStrict = iemMemStackPopContinueSpecial(pIemCpu, cbPop + cbRetPtr, &uPtrStack.pv, &uNewRsp);
2221 return iemRaiseGeneralProtectionFault0(pIemCpu);
2229 rcStrict = iemMemFetchSelDesc(pIemCpu, &DescSs, uNewOuterSs, X86_XCPT_GP);
2238 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewOuterSs);
2248 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewOuterSs);
2254 && IEM_IS_LONG_MODE(pIemCpu))
2258 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewOuterSs);
2266 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewOuterSs);
2273 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uNewCs);
2283 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
2288 return iemRaiseNotCanonical(pIemCpu);
2299 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
2312 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewCs);
2321 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewOuterSs);
2329 rcStrict = iemMemStackPopCommitSpecial(pIemCpu, uPtrFrame.pv, uNewRsp);
2348 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
2353 pIemCpu->uCpl = (uNewCs & X86_SEL_RPL);
2354 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCs & X86_SEL_RPL, &pCtx->ds);
2355 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCs & X86_SEL_RPL, &pCtx->es);
2356 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCs & X86_SEL_RPL, &pCtx->fs);
2357 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCs & X86_SEL_RPL, &pCtx->gs);
2363 iemRegAddToRsp(pIemCpu, pCtx, cbPop);
2377 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
2382 return iemRaiseNotCanonical(pIemCpu);
2392 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
2405 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewCs);
2413 rcStrict = iemMemStackPopCommitSpecial(pIemCpu, uPtrFrame.pv, uNewRsp);
2429 iemRegAddToRsp(pIemCpu, pCtx, cbPop);
2448 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
2460 rcStrict = iemMemStackPopU16Ex(pIemCpu, &NewRip.Words.w0, &NewRsp);
2464 rcStrict = iemMemStackPopU32Ex(pIemCpu, &NewRip.DWords.dw0, &NewRsp);
2467 rcStrict = iemMemStackPopU64Ex(pIemCpu, &NewRip.u, &NewRsp);
2482 return iemRaiseSelectorBounds(pIemCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
2490 return iemRaiseNotCanonical(pIemCpu);
2498 iemRegAddToRsp(pIemCpu, pCtx, cbPop);
2515 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
2524 rcStrict = iemMemStackPushU64Ex(pIemCpu, TmpRbp.u, &NewRsp);
2529 rcStrict = iemMemStackPushU32Ex(pIemCpu, TmpRbp.DWords.dw0, &NewRsp);
2534 rcStrict = iemMemStackPushU16Ex(pIemCpu, TmpRbp.Words.w0, &NewRsp);
2555 rcStrict = iemMemStackPopU16Ex(pIemCpu, &u16Tmp, &TmpRbp);
2558 rcStrict = iemMemStackPushU16Ex(pIemCpu, u16Tmp, &NewRsp);
2570 rcStrict = iemMemStackPopU32Ex(pIemCpu, &u32Tmp, &TmpRbp);
2573 rcStrict = iemMemStackPushU32Ex(pIemCpu, u32Tmp, &NewRsp);
2582 rcStrict = iemMemStackPopU64Ex(pIemCpu, &u64Tmp, &TmpRbp);
2585 rcStrict = iemMemStackPushU64Ex(pIemCpu, u64Tmp, &NewRsp);
2596 rcStrict = iemMemStackPushU64Ex(pIemCpu, NewRbp.u, &NewRsp);
2598 rcStrict = iemMemStackPushU32Ex(pIemCpu, NewRbp.DWords.dw0, &NewRsp);
2600 rcStrict = iemMemStackPushU16Ex(pIemCpu, NewRbp.Words.w0, &NewRsp);
2607 iemRegSubFromRspEx(pIemCpu, pCtx, &NewRsp, cbFrame);
2614 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
2631 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
2635 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
2653 rcStrict = iemMemStackPopU16Ex(pIemCpu, &NewRbp.Words.w0, &NewRsp);
2657 rcStrict = iemMemStackPopU32Ex(pIemCpu, &NewRbp.DWords.dw0, &NewRsp);
2660 rcStrict = iemMemStackPopU64Ex(pIemCpu, &NewRbp.u, &NewRsp);
2671 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
2685 Assert(pIemCpu->cXcptRecursions == 0);
2686 return iemRaiseXcptOrInt(pIemCpu,
2702 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
2704 Efl.u = IEMMISC_GET_EFL(pIemCpu, pCtx);
2713 return iemRaiseGeneralProtectionFault0(pIemCpu);
2728 rcStrict = iemMemStackPopBeginSpecial(pIemCpu, 12, &uFrame.pv, &uNewRsp);
2733 return iemRaiseGeneralProtectionFault0(pIemCpu);
2745 rcStrict = iemMemStackPopBeginSpecial(pIemCpu, 6, &uFrame.pv, &uNewRsp);
2765 return iemRaiseSelectorBounds(pIemCpu, X86_SREG_CS, IEM_ACCESS_INSTRUCTION);
2790 return iemRaiseGeneralProtectionFault0(pIemCpu);
2796 rcStrict = iemMemStackPopCommitSpecial(pIemCpu, uFrame.pv, uNewRsp);
2800 RTTraceBufAddMsgF(IEMCPU_TO_VM(pIemCpu)->CTX_SUFF(hTraceBuf), "iret/rm %04x:%04x -> %04x:%04x %x %04llx",
2811 IEMMISC_SET_EFL(pIemCpu, pCtx, uNewFlags);
2855 rcStrict = iemMemStackPopContinueSpecial(pIemCpu, 24, &uFrame.pv, &uNewRsp);
2864 rcStrict = iemMemCommitAndUnmap(pIemCpu, (void *)uFrame.pv, IEM_ACCESS_STACK_R); /* don't use iemMemStackPopCommitSpecial here. */
2874 RTTraceBufAddMsgF(IEMCPU_TO_VM(pIemCpu)->CTX_SUFF(hTraceBuf), "iret/p/v %04x:%08x -> %04x:%04x %x %04x:%04x",
2878 IEMMISC_SET_EFL(pIemCpu, pCtx, uNewFlags);
2887 pIemCpu->uCpl = 3;
2907 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
2908 VBOXSTRICTRC rcStrict = iemMemFetchSysU16(pIemCpu, &uSelRet, UINT8_MAX, pCtx->tr.u64Base);
2918 return iemRaiseTaskSwitchFaultBySelector(pIemCpu, uSelRet);
2922 rcStrict = iemMemFetchSelDesc(pIemCpu, &TssDesc, uSelRet, X86_XCPT_GP);
2929 return iemRaiseTaskSwitchFaultBySelector(pIemCpu, uSelRet & X86_SEL_MASK_OFF_RPL);
2936 return iemRaiseTaskSwitchFaultBySelector(pIemCpu, uSelRet & X86_SEL_MASK_OFF_RPL);
2942 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uSelRet & X86_SEL_MASK_OFF_RPL);
2946 return iemTaskSwitch(pIemCpu, pIemCpu->CTX_SUFF(pCtx), IEMTASKSWITCH_IRET, uNextEip, 0 /* fFlags */, 0 /* uErr */,
2959 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
2983 rcStrict = iemMemStackPopBeginSpecial(pIemCpu, 12, &uFrame.pv, &uNewRsp);
2992 rcStrict = iemMemStackPopBeginSpecial(pIemCpu, 6, &uFrame.pv, &uNewRsp);
2999 rcStrict = iemMemCommitAndUnmap(pIemCpu, (void *)uFrame.pv, IEM_ACCESS_STACK_R); /* don't use iemMemStackPopCommitSpecial here. */
3007 && pIemCpu->uCpl == 0)
3020 return iemRaiseGeneralProtectionFault0(pIemCpu);
3024 rcStrict = iemMemFetchSelDesc(pIemCpu, &DescCS, uNewCs, X86_XCPT_GP);
3035 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
3040 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
3045 PVM pVM = IEMCPU_TO_VM(pIemCpu);
3050 if ( pIemCpu->uCpl == 0
3058 else if (pIemCpu->uCpl <= 1 && EMIsRawRing1Enabled(pVM))
3064 && pIemCpu->uCpl <= 1)
3074 if ((uNewCs & X86_SEL_RPL) < pIemCpu->uCpl)
3076 Log(("iret %04x:%08x - RPL < CPL (%d) -> #GP\n", uNewCs, uNewEip, pIemCpu->uCpl));
3077 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
3083 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
3090 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uNewCs);
3098 if ((uNewCs & X86_SEL_RPL) != pIemCpu->uCpl)
3104 rcStrict = iemMemStackPopContinueSpecial(pIemCpu, 8, &uFrame.pv, &uNewRsp);
3112 rcStrict = iemMemStackPopContinueSpecial(pIemCpu, 4, &uFrame.pv, &uNewRsp);
3118 rcStrict = iemMemCommitAndUnmap(pIemCpu, (void *)uFrame.pv, IEM_ACCESS_STACK_R);
3126 return iemRaiseGeneralProtectionFault0(pIemCpu);
3130 rcStrict = iemMemFetchSelDesc(pIemCpu, &DescSS, uNewSS, X86_XCPT_GP); /** @todo Correct exception? */
3142 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewSS);
3148 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewSS);
3156 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewSS);
3162 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewSS);
3169 return iemRaiseStackSelectorNotPresentBySelector(pIemCpu, uNewSS);
3180 return iemRaiseSelectorBoundsBySelector(pIemCpu, uNewCs);
3189 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewCs);
3196 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewSS);
3206 if (pIemCpu->uCpl == 0)
3208 else if (pIemCpu->uCpl <= pCtx->eflags.Bits.u2IOPL)
3210 uint32_t fEFlagsNew = IEMMISC_GET_EFL(pIemCpu, pCtx);
3214 RTTraceBufAddMsgF(IEMCPU_TO_VM(pIemCpu)->CTX_SUFF(hTraceBuf), "iret/%up%u %04x:%08x -> %04x:%04x %x %04x:%04x",
3215 pIemCpu->uCpl, uNewCs & X86_SEL_RPL, pCtx->cs.Sel, pCtx->eip,
3219 IEMMISC_SET_EFL(pIemCpu, pCtx, fEFlagsNew);
3238 pIemCpu->uCpl = uNewCs & X86_SEL_RPL;
3239 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCs & X86_SEL_RPL, &pCtx->ds);
3240 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCs & X86_SEL_RPL, &pCtx->es);
3241 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCs & X86_SEL_RPL, &pCtx->fs);
3242 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCs & X86_SEL_RPL, &pCtx->gs);
3257 return iemRaiseSelectorBoundsBySelector(pIemCpu, uNewCs);
3265 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewCs);
3272 NewEfl.u = IEMMISC_GET_EFL(pIemCpu, pCtx);
3277 if (pIemCpu->uCpl == 0)
3279 else if (pIemCpu->uCpl <= NewEfl.Bits.u2IOPL)
3284 RTTraceBufAddMsgF(IEMCPU_TO_VM(pIemCpu)->CTX_SUFF(hTraceBuf), "iret/%up %04x:%08x -> %04x:%04x %x %04x:%04llx",
3285 pIemCpu->uCpl, pCtx->cs.Sel, pCtx->eip,
3289 IEMMISC_SET_EFL(pIemCpu, pCtx, NewEfl.u);
3311 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
3320 return iemRaiseGeneralProtectionFault0(pIemCpu);
3338 rcStrict = iemMemStackPopBeginSpecial(pIemCpu, 5*8, &uFrame.pv, &uNewRsp);
3349 rcStrict = iemMemStackPopBeginSpecial(pIemCpu, 5*4, &uFrame.pv, &uNewRsp);
3361 rcStrict = iemMemStackPopBeginSpecial(pIemCpu, 5*2, &uFrame.pv, &uNewRsp);
3370 rcStrict = iemMemCommitAndUnmap(pIemCpu, (void *)uFrame.pv, IEM_ACCESS_STACK_R); /* don't use iemMemStackPopCommitSpecial here. */
3383 return iemRaiseGeneralProtectionFault0(pIemCpu);
3387 rcStrict = iemMemFetchSelDesc(pIemCpu, &DescCS, uNewCs, X86_XCPT_GP);
3401 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
3406 if ((uNewCs & X86_SEL_RPL) < pIemCpu->uCpl)
3408 Log(("iret %04x:%016RX64/%04x:%016RX64 - RPL < CPL (%d) -> #GP\n", uNewCs, uNewRip, uNewSs, uNewRsp, pIemCpu->uCpl));
3409 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
3416 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewCs);
3423 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uNewCs);
3437 return iemRaiseGeneralProtectionFault0(pIemCpu);
3443 rcStrict = iemMemFetchSelDesc(pIemCpu, &DescSS, uNewSs, X86_XCPT_GP); /** @todo Correct exception? */
3456 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewSs);
3468 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewSs);
3476 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewSs);
3482 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewSs);
3489 return iemRaiseStackSelectorNotPresentBySelector(pIemCpu, uNewSs);
3501 return iemRaiseSelectorBoundsBySelector(pIemCpu, uNewCs);
3511 return iemRaiseSelectorBoundsBySelector(pIemCpu, uNewCs);
3522 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewCs);
3529 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uNewSs);
3539 if (pIemCpu->uCpl == 0)
3541 else if (pIemCpu->uCpl <= pCtx->eflags.Bits.u2IOPL)
3543 uint32_t fEFlagsNew = IEMMISC_GET_EFL(pIemCpu, pCtx);
3547 RTTraceBufAddMsgF(IEMCPU_TO_VM(pIemCpu)->CTX_SUFF(hTraceBuf), "iret/%ul%u %08llx -> %04x:%04llx %llx %04x:%04llx",
3548 pIemCpu->uCpl, uNewCpl, pCtx->rip, uNewCs, uNewRip, uNewFlags, uNewSs, uNewRsp);
3551 IEMMISC_SET_EFL(pIemCpu, pCtx, fEFlagsNew);
3582 if (pIemCpu->uCpl != uNewCpl)
3584 pIemCpu->uCpl = uNewCpl;
3585 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCpl, &pCtx->ds);
3586 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCpl, &pCtx->es);
3587 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCpl, &pCtx->fs);
3588 iemHlpAdjustSelectorForNewCpl(pIemCpu, uNewCpl, &pCtx->gs);
3605 PVMCPU pVCpu = IEMCPU_TO_VMCPU(pIemCpu);
3611 if (IEM_IS_REAL_OR_V86_MODE(pIemCpu))
3613 if (IEM_IS_LONG_MODE(pIemCpu))
3627 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
3639 return iemRaiseUndefinedOpcode(pIemCpu);
3644 return iemRaiseGeneralProtectionFault0(pIemCpu);
3646 if (IEM_IS_GUEST_CPU_INTEL(pIemCpu) && !CPUMIsGuestInLongModeEx(pCtx))
3649 return iemRaiseUndefinedOpcode(pIemCpu);
3659 return iemRaiseGeneralProtectionFault0(pIemCpu);
3665 uint64_t uNewRip = pIemCpu->enmCpuMode == IEMMODE_64BIT ? pCtx->msrLSTAR : pCtx-> msrCSTAR;
3672 return iemRaiseUndefinedOpcode(pIemCpu);
3726 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
3738 return iemRaiseUndefinedOpcode(pIemCpu);
3740 if (IEM_IS_GUEST_CPU_INTEL(pIemCpu) && !CPUMIsGuestInLongModeEx(pCtx))
3743 return iemRaiseUndefinedOpcode(pIemCpu);
3748 return iemRaiseGeneralProtectionFault0(pIemCpu);
3750 if (pIemCpu->uCpl != 0)
3752 Log(("sysret: CPL must be 0 not %u -> #GP(0)\n", pIemCpu->uCpl));
3753 return iemRaiseGeneralProtectionFault0(pIemCpu);
3759 if (pIemCpu->enmEffOpSize == IEMMODE_64BIT)
3764 return iemRaiseGeneralProtectionFault0(pIemCpu);
3772 if (pIemCpu->enmEffOpSize == IEMMODE_64BIT)
3829 /*PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);*/
3830 uint16_t *pSel = iemSRegRef(pIemCpu, iSegReg);
3831 PCPUMSELREGHID pHid = iemSRegGetHid(pIemCpu, iSegReg);
3838 if ( pIemCpu->enmCpuMode == IEMMODE_16BIT
3839 && IEM_IS_REAL_OR_V86_MODE(pIemCpu))
3857 CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_HIDDEN_SEL_REGS);
3858 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
3877 if ( pIemCpu->enmCpuMode != IEMMODE_64BIT
3878 || pIemCpu->uCpl > 2
3879 || ( uSel != pIemCpu->uCpl
3880 && !IEM_IS_GUEST_CPU_AMD(pIemCpu)) )
3883 return iemRaiseGeneralProtectionFault0(pIemCpu);
3888 iemHlpLoadNullDataSelectorProt(pIemCpu, pHid, uSel);
3890 pHid->Attr.u |= pIemCpu->uCpl << X86DESCATTR_DPL_SHIFT;
3892 Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(IEMCPU_TO_VMCPU(pIemCpu), pHid));
3893 CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_HIDDEN_SEL_REGS);
3895 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
3901 VBOXSTRICTRC rcStrict = iemMemFetchSelDesc(pIemCpu, &Desc, uSel, X86_XCPT_GP); /** @todo Correct exception? */
3909 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
3917 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
3919 if ((uSel & X86_SEL_RPL) != pIemCpu->uCpl)
3921 Log(("load sreg SS, %#x - RPL and CPL (%d) differs -> #GP\n", uSel, pIemCpu->uCpl));
3922 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
3924 if (Desc.Legacy.Gen.u2Dpl != pIemCpu->uCpl)
3926 Log(("load sreg SS, %#x - DPL (%d) and CPL (%d) differs -> #GP\n", uSel, Desc.Legacy.Gen.u2Dpl, pIemCpu->uCpl));
3927 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
3935 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
3942 && pIemCpu->uCpl > Desc.Legacy.Gen.u2Dpl)
3945 iSegReg, uSel, (uSel & X86_SEL_RPL), pIemCpu->uCpl, Desc.Legacy.Gen.u2Dpl));
3946 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
3953 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
3955 if (pIemCpu->uCpl > Desc.Legacy.Gen.u2Dpl)
3958 iSegReg, uSel, pIemCpu->uCpl, Desc.Legacy.Gen.u2Dpl));
3959 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uSel);
3969 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uSel);
3975 if ( pIemCpu->enmCpuMode == IEMMODE_64BIT
3987 rcStrict = iemMemMarkSelDescAccessed(pIemCpu, uSel);
4003 Assert(CPUMSELREG_ARE_HIDDEN_PARTS_VALID(IEMCPU_TO_VMCPU(pIemCpu), pHid));
4005 CPUMSetChangedFlags(IEMCPU_TO_VMCPU(pIemCpu), CPUM_CHANGED_HIDDEN_SEL_REGS);
4006 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4024 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4025 EMSetInhibitInterruptsPC(IEMCPU_TO_VMCPU(pIemCpu), pCtx->rip);
4040 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4053 rcStrict = iemMemStackPopU16Ex(pIemCpu, &uSel, &TmpRsp);
4062 rcStrict = iemMemStackPopU32Ex(pIemCpu, &u32Value, &TmpRsp);
4071 rcStrict = iemMemStackPopU64Ex(pIemCpu, &u64Value, &TmpRsp);
4086 EMSetInhibitInterruptsPC(IEMCPU_TO_VMCPU(pIemCpu), pCtx->rip);
4102 /*PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);*/
4116 *(uint16_t *)iemGRegRef(pIemCpu, iGReg) = offSeg;
4119 *(uint64_t *)iemGRegRef(pIemCpu, iGReg) = offSeg;
4122 *(uint64_t *)iemGRegRef(pIemCpu, iGReg) = offSeg;
4139 * @param pIemCpu The IEM state of the calling EMT.
4144 static VBOXSTRICTRC iemCImpl_LoadDescHelper(PIEMCPU pIemCpu, uint16_t uSel, bool fAllowSysDesc, PIEMSELDESC pDesc)
4153 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4170 VBOXSTRICTRC rcStrict = iemMemFetchSysU64(pIemCpu, &pDesc->Legacy.u, UINT8_MAX, GCPtrBase + (uSel & X86_SEL_MASK));
4179 rcStrict = iemMemFetchSysU64(pIemCpu, &pDesc->Long.au64[1], UINT8_MAX, GCPtrBase + (uSel & X86_SEL_MASK) + 8);
4195 Assert(!IEM_IS_REAL_OR_V86_MODE(pIemCpu));
4201 VBOXSTRICTRC rcStrict = iemCImpl_LoadDescHelper(pIemCpu, uSel, false /*fAllowSysDesc*/, &Desc);
4221 else if (pIemCpu->uCpl > Desc.Legacy.Gen.u2Dpl)
4233 pIemCpu->CTX_SUFF(pCtx)->eflags.Bits.u1ZF = fAccessible;
4235 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4251 Assert(!IEM_IS_REAL_OR_V86_MODE(pIemCpu));
4257 VBOXSTRICTRC rcStrict = iemCImpl_LoadDescHelper(pIemCpu, uSel, false /*fAllowSysDesc*/, &Desc);
4265 if (CPUMIsGuestInLongModeEx(pIemCpu->CTX_SUFF(pCtx)))
4317 else if (pIemCpu->uCpl > Desc.Legacy.Gen.u2Dpl)
4340 pIemCpu->CTX_SUFF(pCtx)->eflags.Bits.u1ZF = fDescOk;
4341 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4374 if (pIemCpu->uCpl != 0)
4375 return iemRaiseGeneralProtectionFault0(pIemCpu);
4376 Assert(!pIemCpu->CTX_SUFF(pCtx)->eflags.Bits.u1VM);
4383 VBOXSTRICTRC rcStrict = iemMemFetchDataXdtr(pIemCpu, &cbLimit, &GCPtrBase, iEffSeg, GCPtrEffSrc, enmEffOpSize);
4386 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
4387 rcStrict = CPUMSetGuestGDTR(IEMCPU_TO_VMCPU(pIemCpu), GCPtrBase, cbLimit);
4390 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4395 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4415 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4416 VBOXSTRICTRC rcStrict = iemMemStoreDataXdtr(pIemCpu, pCtx->gdtr.cbGdt, pCtx->gdtr.pGdt, iEffSeg, GCPtrEffDst, enmEffOpSize);
4418 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4432 if (pIemCpu->uCpl != 0)
4433 return iemRaiseGeneralProtectionFault0(pIemCpu);
4434 Assert(!pIemCpu->CTX_SUFF(pCtx)->eflags.Bits.u1VM);
4441 VBOXSTRICTRC rcStrict = iemMemFetchDataXdtr(pIemCpu, &cbLimit, &GCPtrBase, iEffSeg, GCPtrEffSrc, enmEffOpSize);
4444 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
4445 CPUMSetGuestIDTR(IEMCPU_TO_VMCPU(pIemCpu), GCPtrBase, cbLimit);
4448 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4452 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4472 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4473 VBOXSTRICTRC rcStrict = iemMemStoreDataXdtr(pIemCpu, pCtx->idtr.cbIdt, pCtx->idtr.pIdt, iEffSeg, GCPtrEffDst, enmEffOpSize);
4475 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4487 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4492 if (IEM_IS_REAL_OR_V86_MODE(pIemCpu))
4495 return iemRaiseUndefinedOpcode(pIemCpu);
4497 if (pIemCpu->uCpl != 0)
4499 Log(("lldt %04x - CPL is %d -> #GP(0)\n", uNewLdt, pIemCpu->uCpl));
4500 return iemRaiseGeneralProtectionFault0(pIemCpu);
4505 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewLdt);
4514 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
4515 CPUMSetGuestLDTR(IEMCPU_TO_VMCPU(pIemCpu), uNewLdt);
4520 if (IEM_FULL_VERIFICATION_REM_ENABLED(pIemCpu))
4525 else if (IEM_IS_GUEST_CPU_AMD(pIemCpu))
4530 else if (!IEM_FULL_VERIFICATION_REM_ENABLED(pIemCpu))
4538 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4546 VBOXSTRICTRC rcStrict = iemMemFetchSelDesc(pIemCpu, &Desc, uNewLdt, X86_XCPT_GP); /** @todo Correct exception? */
4554 return iemRaiseGeneralProtectionFault(pIemCpu, uNewLdt & X86_SEL_MASK_OFF_RPL);
4559 return iemRaiseGeneralProtectionFault(pIemCpu, uNewLdt & X86_SEL_MASK_OFF_RPL);
4562 if (!IEM_IS_LONG_MODE(pIemCpu))
4569 return iemRaiseGeneralProtectionFault(pIemCpu, uNewLdt & X86_SEL_MASK_OFF_RPL);
4576 return iemRaiseGeneralProtectionFault(pIemCpu, uNewLdt & X86_SEL_MASK_OFF_RPL);
4584 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uNewLdt);
4591 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
4592 CPUMSetGuestLDTR(IEMCPU_TO_VMCPU(pIemCpu), uNewLdt & X86_SEL_MASK_OFF_RPL);
4601 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4613 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4618 if (IEM_IS_REAL_OR_V86_MODE(pIemCpu))
4621 return iemRaiseUndefinedOpcode(pIemCpu);
4623 if (pIemCpu->uCpl != 0)
4625 Log(("ltr %04x - CPL is %d -> #GP(0)\n", uNewTr, pIemCpu->uCpl));
4626 return iemRaiseGeneralProtectionFault0(pIemCpu);
4631 return iemRaiseGeneralProtectionFaultBySelector(pIemCpu, uNewTr);
4636 return iemRaiseGeneralProtectionFault0(pIemCpu);
4643 VBOXSTRICTRC rcStrict = iemMemFetchSelDesc(pIemCpu, &Desc, uNewTr, X86_XCPT_GP); /** @todo Correct exception? */
4651 return iemRaiseGeneralProtectionFault(pIemCpu, uNewTr & X86_SEL_MASK_OFF_RPL);
4655 || IEM_IS_LONG_MODE(pIemCpu)) )
4658 return iemRaiseGeneralProtectionFault(pIemCpu, uNewTr & X86_SEL_MASK_OFF_RPL);
4661 if (!IEM_IS_LONG_MODE(pIemCpu))
4668 return iemRaiseGeneralProtectionFault(pIemCpu, uNewTr & X86_SEL_MASK_OFF_RPL);
4675 return iemRaiseGeneralProtectionFault(pIemCpu, uNewTr & X86_SEL_MASK_OFF_RPL);
4683 return iemRaiseSelectorNotPresentBySelector(pIemCpu, uNewTr);
4693 rcStrict = iemMemMap(pIemCpu, &pvDesc, 8, UINT8_MAX, pCtx->gdtr.pGdt + (uNewTr & X86_SEL_MASK_OFF_RPL), IEM_ACCESS_DATA_RW);
4703 rcStrict = iemMemCommitAndUnmap(pIemCpu, pvDesc, IEM_ACCESS_DATA_RW);
4712 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
4713 CPUMSetGuestTR(IEMCPU_TO_VMCPU(pIemCpu), uNewTr & X86_SEL_MASK_OFF_RPL);
4722 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4735 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4736 if (pIemCpu->uCpl != 0)
4737 return iemRaiseGeneralProtectionFault0(pIemCpu);
4751 int rc = PDMApicGetTPR(IEMCPU_TO_VMCPU(pIemCpu), &uTpr, NULL, NULL);
4762 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
4763 *(uint64_t *)iemGRegRef(pIemCpu, iGReg) = crX;
4765 *(uint64_t *)iemGRegRef(pIemCpu, iGReg) = (uint32_t)crX;
4767 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
4780 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
4781 PVMCPU pVCpu = IEMCPU_TO_VMCPU(pIemCpu);
4806 return iemRaiseGeneralProtectionFault0(pIemCpu);
4814 return iemRaiseGeneralProtectionFault0(pIemCpu);
4821 return iemRaiseGeneralProtectionFault0(pIemCpu);
4832 return iemRaiseGeneralProtectionFault0(pIemCpu);
4837 return iemRaiseGeneralProtectionFault0(pIemCpu);
4846 if (!IEM_VERIFICATION_ENABLED(pIemCpu))
4864 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
4874 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
4919 return iemRaiseGeneralProtectionFault0(pIemCpu);
4941 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
4950 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
4983 if (IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fXSaveRstor)
4988 return iemRaiseGeneralProtectionFault0(pIemCpu);
4997 return iemRaiseGeneralProtectionFault0(pIemCpu);
5004 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
5016 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
5024 if (!HMIsEnabled(IEMCPU_TO_VM(pIemCpu)))
5050 return iemRaiseGeneralProtectionFault0(pIemCpu);
5053 if (!IEM_FULL_VERIFICATION_ENABLED(pIemCpu))
5054 PDMApicSetTPR(IEMCPU_TO_VMCPU(pIemCpu), (uint8_t)uNewCrX << 4);
5067 rcStrict = iemSetPassUpStatus(pIemCpu, rcStrict);
5068 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5083 if (pIemCpu->uCpl != 0)
5084 return iemRaiseGeneralProtectionFault0(pIemCpu);
5085 Assert(!pIemCpu->CTX_SUFF(pCtx)->eflags.Bits.u1VM);
5091 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
5092 uNewCrX = iemGRegFetchU64(pIemCpu, iGReg);
5094 uNewCrX = iemGRegFetchU32(pIemCpu, iGReg);
5106 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5108 if (pIemCpu->uCpl != 0)
5109 return iemRaiseGeneralProtectionFault0(pIemCpu);
5126 if (pIemCpu->uCpl != 0)
5127 return iemRaiseGeneralProtectionFault0(pIemCpu);
5129 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5144 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5151 if (pIemCpu->uCpl != 0)
5152 return iemRaiseGeneralProtectionFault0(pIemCpu);
5159 return iemRaiseGeneralProtectionFault0(pIemCpu);
5166 return iemRaiseDebugException(pIemCpu);
5194 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
5195 *(uint64_t *)iemGRegRef(pIemCpu, iGReg) = drX;
5197 *(uint64_t *)iemGRegRef(pIemCpu, iGReg) = (uint32_t)drX;
5199 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5212 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5217 if (pIemCpu->uCpl != 0)
5218 return iemRaiseGeneralProtectionFault0(pIemCpu);
5226 return iemRaiseGeneralProtectionFault0(pIemCpu);
5237 return iemRaiseDebugException(pIemCpu);
5244 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
5245 uNewDrX = iemGRegFetchU64(pIemCpu, iGReg);
5247 uNewDrX = iemGRegFetchU32(pIemCpu, iGReg);
5265 return iemRaiseGeneralProtectionFault0(pIemCpu);
5275 return iemRaiseGeneralProtectionFault0(pIemCpu);
5287 if (!IEM_VERIFICATION_ENABLED(pIemCpu))
5289 int rc = CPUMSetGuestDRx(IEMCPU_TO_VMCPU(pIemCpu), iDrReg, uNewDrX);
5295 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5309 if (pIemCpu->uCpl != 0)
5310 return iemRaiseGeneralProtectionFault0(pIemCpu);
5311 Assert(!pIemCpu->CTX_SUFF(pCtx)->eflags.Bits.u1VM);
5313 int rc = PGMInvalidatePage(IEMCPU_TO_VMCPU(pIemCpu), GCPtrPage);
5314 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5319 return iemSetPassUpStatus(pIemCpu, rc);
5332 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5337 if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fTsc)
5338 return iemRaiseUndefinedOpcode(pIemCpu);
5341 && pIemCpu->uCpl != 0)
5343 Log(("rdtsc: CR4.TSD and CPL=%u -> #GP(0)\n", pIemCpu->uCpl));
5344 return iemRaiseGeneralProtectionFault0(pIemCpu);
5350 uint64_t uTicks = TMCpuTickGet(IEMCPU_TO_VMCPU(pIemCpu));
5354 pIemCpu->fIgnoreRaxRdx = true;
5357 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5367 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5372 if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fMsr)
5373 return iemRaiseUndefinedOpcode(pIemCpu);
5374 if (pIemCpu->uCpl != 0)
5375 return iemRaiseGeneralProtectionFault0(pIemCpu);
5381 VBOXSTRICTRC rcStrict = CPUMQueryGuestMsr(IEMCPU_TO_VMCPU(pIemCpu), pCtx->ecx, &uValue.u);
5387 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5407 return iemRaiseGeneralProtectionFault0(pIemCpu);
5416 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5421 if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fMsr)
5422 return iemRaiseUndefinedOpcode(pIemCpu);
5423 if (pIemCpu->uCpl != 0)
5424 return iemRaiseGeneralProtectionFault0(pIemCpu);
5434 if (!IEM_VERIFICATION_ENABLED(pIemCpu))
5435 rcStrict = CPUMSetGuestMsr(IEMCPU_TO_VMCPU(pIemCpu), pCtx->ecx, uValue.u);
5440 rcStrict = CPUMSetGuestMsr(IEMCPU_TO_VMCPU(pIemCpu), pCtx->ecx, uValue.u);
5441 PCPUMCTX pCtx2 = CPUMQueryGuestCtxPtr(IEMCPU_TO_VMCPU(pIemCpu));
5450 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5470 return iemRaiseGeneralProtectionFault0(pIemCpu);
5482 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5487 VBOXSTRICTRC rcStrict = iemHlpCheckPortIOPermission(pIemCpu, pCtx, u16Port, cbReg);
5495 if (!IEM_VERIFICATION_ENABLED(pIemCpu))
5496 rcStrict = IOMIOPortRead(IEMCPU_TO_VM(pIemCpu), IEMCPU_TO_VMCPU(pIemCpu), u16Port, &u32Value, cbReg);
5498 rcStrict = iemVerifyFakeIOPortRead(pIemCpu, u16Port, &u32Value, cbReg);
5508 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5509 pIemCpu->cPotentialExits++;
5511 rcStrict = iemSetPassUpStatus(pIemCpu, rcStrict);
5521 || DBGFBpIsHwIoArmed(IEMCPU_TO_VM(pIemCpu))))
5523 rcStrict = DBGFBpCheckIo(IEMCPU_TO_VM(pIemCpu), IEMCPU_TO_VMCPU(pIemCpu), pCtx, u16Port, cbReg);
5525 rcStrict = iemRaiseDebugException(pIemCpu);
5540 return IEM_CIMPL_CALL_2(iemCImpl_in, pIemCpu->CTX_SUFF(pCtx)->dx, cbReg);
5552 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5557 VBOXSTRICTRC rcStrict = iemHlpCheckPortIOPermission(pIemCpu, pCtx, u16Port, cbReg);
5572 if (!IEM_VERIFICATION_ENABLED(pIemCpu))
5573 rcStrict = IOMIOPortWrite(IEMCPU_TO_VM(pIemCpu), IEMCPU_TO_VMCPU(pIemCpu), u16Port, u32Value, cbReg);
5575 rcStrict = iemVerifyFakeIOPortWrite(pIemCpu, u16Port, u32Value, cbReg);
5578 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5579 pIemCpu->cPotentialExits++;
5581 rcStrict = iemSetPassUpStatus(pIemCpu, rcStrict);
5591 || DBGFBpIsHwIoArmed(IEMCPU_TO_VM(pIemCpu))))
5593 rcStrict = DBGFBpCheckIo(IEMCPU_TO_VM(pIemCpu), IEMCPU_TO_VMCPU(pIemCpu), pCtx, u16Port, cbReg);
5595 rcStrict = iemRaiseDebugException(pIemCpu);
5609 return IEM_CIMPL_CALL_2(iemCImpl_out, pIemCpu->CTX_SUFF(pCtx)->dx, cbReg);
5618 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5619 uint32_t fEfl = IEMMISC_GET_EFL(pIemCpu, pCtx);
5626 if (pIemCpu->uCpl <= uIopl)
5628 else if ( pIemCpu->uCpl == 3
5632 return iemRaiseGeneralProtectionFault0(pIemCpu);
5641 return iemRaiseGeneralProtectionFault0(pIemCpu);
5648 IEMMISC_SET_EFL(pIemCpu, pCtx, fEfl);
5649 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5660 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5661 uint32_t fEfl = IEMMISC_GET_EFL(pIemCpu, pCtx);
5669 if (pIemCpu->uCpl <= uIopl)
5671 else if ( pIemCpu->uCpl == 3
5676 return iemRaiseGeneralProtectionFault0(pIemCpu);
5686 return iemRaiseGeneralProtectionFault0(pIemCpu);
5693 IEMMISC_SET_EFL(pIemCpu, pCtx, fEfl);
5694 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5695 if ((!(fEflOld & X86_EFL_IF) && (fEfl & X86_EFL_IF)) || IEM_FULL_VERIFICATION_REM_ENABLED(pIemCpu))
5696 EMSetInhibitInterruptsPC(IEMCPU_TO_VMCPU(pIemCpu), pCtx->rip);
5707 if (pIemCpu->uCpl != 0)
5708 return iemRaiseGeneralProtectionFault0(pIemCpu);
5709 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5722 if (pIemCpu->uCpl != 0)
5725 return iemRaiseUndefinedOpcode(pIemCpu); /** @todo MSR[0xC0010015].MonMwaitUserEn if we care. */
5727 if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fMonitorMWait)
5730 return iemRaiseUndefinedOpcode(pIemCpu);
5736 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5737 RTGCPTR GCPtrMem = pIemCpu->enmCpuMode == IEMMODE_64BIT ? pCtx->rax : pCtx->eax;
5745 return iemRaiseGeneralProtectionFault0(pIemCpu);
5748 VBOXSTRICTRC rcStrict = iemMemApplySegment(pIemCpu, IEM_ACCESS_TYPE_READ | IEM_ACCESS_WHAT_DATA, iEffSeg, 1, &GCPtrMem);
5753 rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, GCPtrMem, IEM_ACCESS_TYPE_READ | IEM_ACCESS_WHAT_DATA, &GCPhysMem);
5760 rcStrict = EMMonitorWaitPrepare(IEMCPU_TO_VMCPU(pIemCpu), pCtx->rax, pCtx->rcx, pCtx->rdx, GCPhysMem);
5763 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5776 if (pIemCpu->uCpl != 0)
5781 return iemRaiseUndefinedOpcode(pIemCpu);
5783 if (!IEM_GET_GUEST_CPU_FEATURES(pIemCpu)->fMonitorMWait)
5786 return iemRaiseUndefinedOpcode(pIemCpu);
5792 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5801 return iemRaiseGeneralProtectionFault0(pIemCpu);
5805 CPUMGetGuestCpuId(IEMCPU_TO_VMCPU(pIemCpu), 5, 0, &uIgnore, &uIgnore, &fMWaitFeatures, &uIgnore);
5810 return iemRaiseGeneralProtectionFault0(pIemCpu);
5817 VBOXSTRICTRC rcStrict = EMMonitorWaitPerform(IEMCPU_TO_VMCPU(pIemCpu), uEax, uEcx);
5819 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5829 Assert(pIemCpu->enmCpuMode == IEMMODE_64BIT); /* Caller checks this. */
5834 if (pIemCpu->uCpl != 0)
5837 return iemRaiseUndefinedOpcode(pIemCpu);
5843 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5848 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5858 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5860 CPUMGetGuestCpuId(IEMCPU_TO_VMCPU(pIemCpu), pCtx->eax, pCtx->ecx, &pCtx->eax, &pCtx->ebx, &pCtx->ecx, &pCtx->edx);
5866 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5878 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5883 iemHlpUpdateArithEFlagsU8(pIemCpu, al,
5887 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5899 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5906 iemHlpUpdateArithEFlagsU8(pIemCpu, al,
5910 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5920 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5942 iemHlpUpdateArithEFlagsU8(pIemCpu, pCtx->al, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
5943 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
5953 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
5978 iemHlpUpdateArithEFlagsU8(pIemCpu, pCtx->al, X86_EFL_SF | X86_EFL_ZF | X86_EFL_PF, X86_EFL_OF);
5979 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6032 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6044 return iemRaiseGeneralProtectionFault0(pIemCpu);
6050 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6054 return iemRaiseUndefinedOpcode(pIemCpu);
6063 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6066 if (pIemCpu->uCpl == 0)
6074 int rc = CPUMSetGuestXcr0(IEMCPU_TO_VMCPU(pIemCpu), uNewValue);
6079 return iemRaiseGeneralProtectionFault0(pIemCpu);
6085 return iemRaiseGeneralProtectionFault0(pIemCpu);
6089 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6093 Log(("xsetbv cpl=%u -> GP(0)\n", pIemCpu->uCpl));
6094 return iemRaiseGeneralProtectionFault0(pIemCpu);
6097 return iemRaiseUndefinedOpcode(pIemCpu);
6110 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6113 return iemRaiseDeviceNotAvailable(pIemCpu);
6117 return iemRaiseMathFault(pIemCpu);
6132 iemHlpUsedFpu(pIemCpu);
6133 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6147 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6153 return iemRaiseUndefinedOpcode(pIemCpu);
6155 return iemRaiseDeviceNotAvailable(pIemCpu);
6162 && pIemCpu->uCpl == 3)
6163 return iemRaiseAlignmentCheckException(pIemCpu);
6164 return iemRaiseGeneralProtectionFault0(pIemCpu);
6171 VBOXSTRICTRC rcStrict = iemMemMap(pIemCpu, &pvMem512, 512, iEffSeg, GCPtrEff, IEM_ACCESS_DATA_W | IEM_ACCESS_PARTIAL_WRITE);
6221 || pIemCpu->enmCpuMode != IEMMODE_64BIT
6222 || pIemCpu->uCpl != 0)
6234 rcStrict = iemMemCommitAndUnmap(pIemCpu, pvMem512, IEM_ACCESS_DATA_W | IEM_ACCESS_PARTIAL_WRITE);
6238 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6251 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6257 return iemRaiseUndefinedOpcode(pIemCpu);
6259 return iemRaiseDeviceNotAvailable(pIemCpu);
6266 && pIemCpu->uCpl == 3)
6267 return iemRaiseAlignmentCheckException(pIemCpu);
6268 return iemRaiseGeneralProtectionFault0(pIemCpu);
6275 VBOXSTRICTRC rcStrict = iemMemMap(pIemCpu, &pvMem512, 512, iEffSeg, GCPtrEff, IEM_ACCESS_DATA_R);
6289 return iemRaiseGeneralProtectionFault0(pIemCpu);
6314 if (pIemCpu->enmCpuMode == IEMMODE_64BIT)
6335 || pIemCpu->enmCpuMode != IEMMODE_64BIT
6336 || pIemCpu->uCpl != 0)
6346 rcStrict = iemMemCommitAndUnmap(pIemCpu, pvMem512, IEM_ACCESS_DATA_R);
6350 iemHlpUsedFpu(pIemCpu);
6351 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6362 static void iemCImplCommonFpuStoreEnv(PIEMCPU pIemCpu, IEMMODE enmEffOpSize, RTPTRUNION uPtr, PCCPUMCTX pCtx)
6370 if (IEM_IS_REAL_OR_V86_MODE(pIemCpu))
6396 if (IEM_IS_REAL_OR_V86_MODE(pIemCpu))
6421 static void iemCImplCommonFpuRestoreEnv(PIEMCPU pIemCpu, IEMMODE enmEffOpSize, RTCPTRUNION uPtr, PCPUMCTX pCtx)
6429 if (IEM_IS_REAL_OR_V86_MODE(pIemCpu))
6455 if (IEM_IS_REAL_OR_V86_MODE(pIemCpu))
6495 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6497 VBOXSTRICTRC rcStrict = iemMemMap(pIemCpu, &uPtr.pv, enmEffOpSize == IEMMODE_16BIT ? 14 : 28,
6502 iemCImplCommonFpuStoreEnv(pIemCpu, enmEffOpSize, uPtr, pCtx);
6504 rcStrict = iemMemCommitAndUnmap(pIemCpu, uPtr.pv, IEM_ACCESS_DATA_W | IEM_ACCESS_PARTIAL_WRITE);
6509 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6522 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6524 VBOXSTRICTRC rcStrict = iemMemMap(pIemCpu, &uPtr.pv, enmEffOpSize == IEMMODE_16BIT ? 94 : 108,
6530 iemCImplCommonFpuStoreEnv(pIemCpu, enmEffOpSize, uPtr, pCtx);
6539 rcStrict = iemMemCommitAndUnmap(pIemCpu, uPtr.pv, IEM_ACCESS_DATA_W | IEM_ACCESS_PARTIAL_WRITE);
6557 iemHlpUsedFpu(pIemCpu);
6558 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6573 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6575 VBOXSTRICTRC rcStrict = iemMemMap(pIemCpu, (void **)&uPtr.pv, enmEffOpSize == IEMMODE_16BIT ? 14 : 28,
6580 iemCImplCommonFpuRestoreEnv(pIemCpu, enmEffOpSize, uPtr, pCtx);
6582 rcStrict = iemMemCommitAndUnmap(pIemCpu, (void *)uPtr.pv, IEM_ACCESS_DATA_R);
6586 iemHlpUsedFpu(pIemCpu);
6587 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6600 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6602 VBOXSTRICTRC rcStrict = iemMemMap(pIemCpu, (void **)&uPtr.pv, enmEffOpSize == IEMMODE_16BIT ? 94 : 108,
6608 iemCImplCommonFpuRestoreEnv(pIemCpu, enmEffOpSize, uPtr, pCtx);
6618 rcStrict = iemMemCommitAndUnmap(pIemCpu, (void *)uPtr.pv, IEM_ACCESS_DATA_R);
6622 iemHlpUsedFpu(pIemCpu);
6623 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6635 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6647 iemHlpUsedFpu(pIemCpu);
6648 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6661 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6696 iemFpuUpdateOpcodeAndIpWorker(pIemCpu, pCtx, pFpuCtx);
6697 iemHlpUsedFpu(pIemCpu);
6698 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);
6710 PCPUMCTX pCtx = pIemCpu->CTX_SUFF(pCtx);
6717 return iemRaiseDeviceNotAvailable(pIemCpu);
6722 return iemRaiseMathFault(pIemCpu);
6769 iemFpuUpdateOpcodeAndIpWorker(pIemCpu, pCtx, pFpuCtx);
6770 iemHlpUsedFpu(pIemCpu);
6771 iemRegAddToRipAndClearRF(pIemCpu, cbInstr);