EMAll.cpp@ 65504

Last change on this file since 65504 was 64655, checked in by vboxsync, 8 years ago
VMM,recompiler: Get rid of PDM APIC interfaces reducing one level of indirection, cleaned up some unused stuff in recompiler.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 142.2 KB

Line
1	/* $Id: EMAll.cpp 64655 2016-11-14 10:46:07Z vboxsync $ */
2	/** @file
3	* EM - Execution Monitor(/Manager) - All contexts
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define VBOX_WITH_IEM
23	#define LOG_GROUP LOG_GROUP_EM
24	#include <VBox/vmm/em.h>
25	#include <VBox/vmm/mm.h>
26	#include <VBox/vmm/selm.h>
27	#include <VBox/vmm/patm.h>
28	#include <VBox/vmm/csam.h>
29	#include <VBox/vmm/pgm.h>
30	#ifdef VBOX_WITH_IEM
31	# include <VBox/vmm/iem.h>
32	#endif
33	#include <VBox/vmm/iom.h>
34	#include <VBox/vmm/stam.h>
35	#include "EMInternal.h"
36	#include <VBox/vmm/vm.h>
37	#include <VBox/vmm/vmm.h>
38	#include <VBox/vmm/hm.h>
39	#include <VBox/vmm/tm.h>
40	#include <VBox/vmm/pdmapi.h>
41	#include <VBox/param.h>
42	#include <VBox/err.h>
43	#include <VBox/dis.h>
44	#include <VBox/disopcode.h>
45	#include <VBox/log.h>
46	#include <iprt/assert.h>
47	#include <iprt/asm.h>
48	#include <iprt/string.h>
49
50	#ifdef VBOX_WITH_IEM
51	//# define VBOX_COMPARE_IEM_AND_EM /* debugging... */
52	//# define VBOX_SAME_AS_EM
53	//# define VBOX_COMPARE_IEM_LAST
54	#endif
55
56	#ifdef VBOX_WITH_RAW_RING1
57	# define EM_EMULATE_SMSW
58	#endif
59
60
61	/*********************************************************************************************************************************
62	* Defined Constants And Macros *
63	*********************************************************************************************************************************/
64	/** @def EM_ASSERT_FAULT_RETURN
65	* Safety check.
66	*
67	* Could in theory misfire on a cross page boundary access...
68	*
69	* Currently disabled because the CSAM (+ PATM) patch monitoring occasionally
70	* turns up an alias page instead of the original faulting one and annoying the
71	* heck out of anyone running a debug build. See @bugref{2609} and @bugref{1931}.
72	*/
73	#if 0
74	# define EM_ASSERT_FAULT_RETURN(expr, rc) AssertReturn(expr, rc)
75	#else
76	# define EM_ASSERT_FAULT_RETURN(expr, rc) do { } while (0)
77	#endif
78
79
80	/*********************************************************************************************************************************
81	* Internal Functions *
82	*********************************************************************************************************************************/
83	#if !defined(VBOX_WITH_IEM) \|\| defined(VBOX_COMPARE_IEM_AND_EM)
84	DECLINLINE(VBOXSTRICTRC) emInterpretInstructionCPUOuter(PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame,
85	RTGCPTR pvFault, EMCODETYPE enmCodeType, uint32_t *pcbSize);
86	#endif
87
88
89	/*********************************************************************************************************************************
90	* Global Variables *
91	*********************************************************************************************************************************/
92	#ifdef VBOX_COMPARE_IEM_AND_EM
93	static const uint32_t g_fInterestingFFs = VMCPU_FF_TO_R3
94	\| VMCPU_FF_CSAM_PENDING_ACTION \| VMCPU_FF_CSAM_SCAN_PAGE \| VMCPU_FF_INHIBIT_INTERRUPTS
95	\| VMCPU_FF_SELM_SYNC_LDT \| VMCPU_FF_SELM_SYNC_GDT \| VMCPU_FF_SELM_SYNC_TSS \| VMCPU_FF_TRPM_SYNC_IDT
96	\| VMCPU_FF_TLB_FLUSH \| VMCPU_FF_PGM_SYNC_CR3 \| VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL;
97	static uint32_t g_fIncomingFFs;
98	static CPUMCTX g_IncomingCtx;
99	static bool g_fIgnoreRaxRdx = false;
100
101	static uint32_t g_fEmFFs;
102	static CPUMCTX g_EmCtx;
103	static uint8_t g_abEmWrote[256];
104	static size_t g_cbEmWrote;
105
106	static uint32_t g_fIemFFs;
107	static CPUMCTX g_IemCtx;
108	extern uint8_t g_abIemWrote[256];
109	#if defined(VBOX_COMPARE_IEM_FIRST) \|\| defined(VBOX_COMPARE_IEM_LAST)
110	extern size_t g_cbIemWrote;
111	#else
112	static size_t g_cbIemWrote;
113	#endif
114	#endif
115
116
117	/**
118	* Get the current execution manager status.
119	*
120	* @returns Current status.
121	* @param pVCpu The cross context virtual CPU structure.
122	*/
123	VMM_INT_DECL(EMSTATE) EMGetState(PVMCPU pVCpu)
124	{
125	return pVCpu->em.s.enmState;
126	}
127
128
129	/**
130	* Sets the current execution manager status. (use only when you know what you're doing!)
131	*
132	* @param pVCpu The cross context virtual CPU structure.
133	* @param enmNewState The new state, EMSTATE_WAIT_SIPI or EMSTATE_HALTED.
134	*/
135	VMM_INT_DECL(void) EMSetState(PVMCPU pVCpu, EMSTATE enmNewState)
136	{
137	/* Only allowed combination: */
138	Assert(pVCpu->em.s.enmState == EMSTATE_WAIT_SIPI && enmNewState == EMSTATE_HALTED);
139	pVCpu->em.s.enmState = enmNewState;
140	}
141
142
143	/**
144	* Sets the PC for which interrupts should be inhibited.
145	*
146	* @param pVCpu The cross context virtual CPU structure.
147	* @param PC The PC.
148	*/
149	VMMDECL(void) EMSetInhibitInterruptsPC(PVMCPU pVCpu, RTGCUINTPTR PC)
150	{
151	pVCpu->em.s.GCPtrInhibitInterrupts = PC;
152	VMCPU_FF_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
153	}
154
155
156	/**
157	* Gets the PC for which interrupts should be inhibited.
158	*
159	* There are a few instructions which inhibits or delays interrupts
160	* for the instruction following them. These instructions are:
161	* - STI
162	* - MOV SS, r/m16
163	* - POP SS
164	*
165	* @returns The PC for which interrupts should be inhibited.
166	* @param pVCpu The cross context virtual CPU structure.
167	*
168	*/
169	VMMDECL(RTGCUINTPTR) EMGetInhibitInterruptsPC(PVMCPU pVCpu)
170	{
171	return pVCpu->em.s.GCPtrInhibitInterrupts;
172	}
173
174
175	/**
176	* Prepare an MWAIT - essentials of the MONITOR instruction.
177	*
178	* @returns VINF_SUCCESS
179	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
180	* @param rax The content of RAX.
181	* @param rcx The content of RCX.
182	* @param rdx The content of RDX.
183	* @param GCPhys The physical address corresponding to rax.
184	*/
185	VMM_INT_DECL(int) EMMonitorWaitPrepare(PVMCPU pVCpu, uint64_t rax, uint64_t rcx, uint64_t rdx, RTGCPHYS GCPhys)
186	{
187	pVCpu->em.s.MWait.uMonitorRAX = rax;
188	pVCpu->em.s.MWait.uMonitorRCX = rcx;
189	pVCpu->em.s.MWait.uMonitorRDX = rdx;
190	pVCpu->em.s.MWait.fWait \|= EMMWAIT_FLAG_MONITOR_ACTIVE;
191	/** @todo Make use of GCPhys. */
192	NOREF(GCPhys);
193	/** @todo Complete MONITOR implementation. */
194	return VINF_SUCCESS;
195	}
196
197
198	/**
199	* Performs an MWAIT.
200	*
201	* @returns VINF_SUCCESS
202	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
203	* @param rax The content of RAX.
204	* @param rcx The content of RCX.
205	*/
206	VMM_INT_DECL(int) EMMonitorWaitPerform(PVMCPU pVCpu, uint64_t rax, uint64_t rcx)
207	{
208	pVCpu->em.s.MWait.uMWaitRAX = rax;
209	pVCpu->em.s.MWait.uMWaitRCX = rcx;
210	pVCpu->em.s.MWait.fWait \|= EMMWAIT_FLAG_ACTIVE;
211	if (rcx)
212	pVCpu->em.s.MWait.fWait \|= EMMWAIT_FLAG_BREAKIRQIF0;
213	else
214	pVCpu->em.s.MWait.fWait &= ~EMMWAIT_FLAG_BREAKIRQIF0;
215	/** @todo not completely correct?? */
216	return VINF_EM_HALT;
217	}
218
219
220
221	/**
222	* Determine if we should continue execution in HM after encountering an mwait
223	* instruction.
224	*
225	* Clears MWAIT flags if returning @c true.
226	*
227	* @returns true if we should continue, false if we should halt.
228	* @param pVCpu The cross context virtual CPU structure.
229	* @param pCtx Current CPU context.
230	*/
231	VMM_INT_DECL(bool) EMMonitorWaitShouldContinue(PVMCPU pVCpu, PCPUMCTX pCtx)
232	{
233	if ( pCtx->eflags.Bits.u1IF
234	\|\| ( (pVCpu->em.s.MWait.fWait & (EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0))
235	== (EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0)) )
236	{
237	if (VMCPU_FF_IS_PENDING(pVCpu, (VMCPU_FF_UPDATE_APIC \| VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC)))
238	{
239	pVCpu->em.s.MWait.fWait &= ~(EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0);
240	return true;
241	}
242	}
243
244	return false;
245	}
246
247
248	/**
249	* Determine if we should continue execution in HM after encountering a hlt
250	* instruction.
251	*
252	* @returns true if we should continue, false if we should halt.
253	* @param pVCpu The cross context virtual CPU structure.
254	* @param pCtx Current CPU context.
255	*/
256	VMM_INT_DECL(bool) EMShouldContinueAfterHalt(PVMCPU pVCpu, PCPUMCTX pCtx)
257	{
258	if (pCtx->eflags.Bits.u1IF)
259	return !!VMCPU_FF_IS_PENDING(pVCpu, (VMCPU_FF_UPDATE_APIC \| VMCPU_FF_INTERRUPT_APIC \| VMCPU_FF_INTERRUPT_PIC));
260	return false;
261	}
262
263
264	/**
265	* Locks REM execution to a single VCPU.
266	*
267	* @param pVM The cross context VM structure.
268	*/
269	VMMDECL(void) EMRemLock(PVM pVM)
270	{
271	#ifdef VBOX_WITH_REM
272	if (!PDMCritSectIsInitialized(&pVM->em.s.CritSectREM))
273	return; /* early init */
274
275	Assert(!PGMIsLockOwner(pVM));
276	Assert(!IOMIsLockWriteOwner(pVM));
277	int rc = PDMCritSectEnter(&pVM->em.s.CritSectREM, VERR_SEM_BUSY);
278	AssertRCSuccess(rc);
279	#else
280	RT_NOREF(pVM);
281	#endif
282	}
283
284
285	/**
286	* Unlocks REM execution
287	*
288	* @param pVM The cross context VM structure.
289	*/
290	VMMDECL(void) EMRemUnlock(PVM pVM)
291	{
292	#ifdef VBOX_WITH_REM
293	if (!PDMCritSectIsInitialized(&pVM->em.s.CritSectREM))
294	return; /* early init */
295
296	PDMCritSectLeave(&pVM->em.s.CritSectREM);
297	#else
298	RT_NOREF(pVM);
299	#endif
300	}
301
302
303	/**
304	* Check if this VCPU currently owns the REM lock.
305	*
306	* @returns bool owner/not owner
307	* @param pVM The cross context VM structure.
308	*/
309	VMMDECL(bool) EMRemIsLockOwner(PVM pVM)
310	{
311	#ifdef VBOX_WITH_REM
312	if (!PDMCritSectIsInitialized(&pVM->em.s.CritSectREM))
313	return true; /* early init */
314
315	return PDMCritSectIsOwner(&pVM->em.s.CritSectREM);
316	#else
317	RT_NOREF(pVM);
318	return true;
319	#endif
320	}
321
322
323	/**
324	* Try to acquire the REM lock.
325	*
326	* @returns VBox status code
327	* @param pVM The cross context VM structure.
328	*/
329	VMM_INT_DECL(int) EMRemTryLock(PVM pVM)
330	{
331	#ifdef VBOX_WITH_REM
332	if (!PDMCritSectIsInitialized(&pVM->em.s.CritSectREM))
333	return VINF_SUCCESS; /* early init */
334
335	return PDMCritSectTryEnter(&pVM->em.s.CritSectREM);
336	#else
337	RT_NOREF(pVM);
338	return VINF_SUCCESS;
339	#endif
340	}
341
342
343	/**
344	* @callback_method_impl{FNDISREADBYTES}
345	*/
346	static DECLCALLBACK(int) emReadBytes(PDISCPUSTATE pDis, uint8_t offInstr, uint8_t cbMinRead, uint8_t cbMaxRead)
347	{
348	PVMCPU pVCpu = (PVMCPU)pDis->pvUser;
349	#if defined(VBOX_WITH_RAW_MODE) && (defined(IN_RC) \|\| defined(IN_RING3))
350	PVM pVM = pVCpu->CTX_SUFF(pVM);
351	#endif
352	RTUINTPTR uSrcAddr = pDis->uInstrAddr + offInstr;
353	int rc;
354
355	/*
356	* Figure how much we can or must read.
357	*/
358	size_t cbToRead = PAGE_SIZE - (uSrcAddr & PAGE_OFFSET_MASK);
359	if (cbToRead > cbMaxRead)
360	cbToRead = cbMaxRead;
361	else if (cbToRead < cbMinRead)
362	cbToRead = cbMinRead;
363
364	#if defined(VBOX_WITH_RAW_MODE) && (defined(IN_RC) \|\| defined(IN_RING3))
365	/*
366	* We might be called upon to interpret an instruction in a patch.
367	*/
368	if (PATMIsPatchGCAddr(pVM, uSrcAddr))
369	{
370	# ifdef IN_RC
371	memcpy(&pDis->abInstr[offInstr], (void *)(uintptr_t)uSrcAddr, cbToRead);
372	# else
373	memcpy(&pDis->abInstr[offInstr], PATMR3GCPtrToHCPtr(pVM, uSrcAddr), cbToRead);
374	# endif
375	rc = VINF_SUCCESS;
376	}
377	else
378	#endif
379	{
380	# ifdef IN_RC
381	/*
382	* Try access it thru the shadow page tables first. Fall back on the
383	* slower PGM method if it fails because the TLB or page table was
384	* modified recently.
385	*/
386	rc = MMGCRamRead(pVCpu->pVMRC, &pDis->abInstr[offInstr], (void *)(uintptr_t)uSrcAddr, cbToRead);
387	if (rc == VERR_ACCESS_DENIED && cbToRead > cbMinRead)
388	{
389	cbToRead = cbMinRead;
390	rc = MMGCRamRead(pVCpu->pVMRC, &pDis->abInstr[offInstr], (void *)(uintptr_t)uSrcAddr, cbToRead);
391	}
392	if (rc == VERR_ACCESS_DENIED)
393	#endif
394	{
395	rc = PGMPhysSimpleReadGCPtr(pVCpu, &pDis->abInstr[offInstr], uSrcAddr, cbToRead);
396	if (RT_FAILURE(rc))
397	{
398	if (cbToRead > cbMinRead)
399	{
400	cbToRead = cbMinRead;
401	rc = PGMPhysSimpleReadGCPtr(pVCpu, &pDis->abInstr[offInstr], uSrcAddr, cbToRead);
402	}
403	if (RT_FAILURE(rc))
404	{
405	#ifndef IN_RC
406	/*
407	* If we fail to find the page via the guest's page tables
408	* we invalidate the page in the host TLB (pertaining to
409	* the guest in the NestedPaging case). See @bugref{6043}.
410	*/
411	if (rc == VERR_PAGE_TABLE_NOT_PRESENT \|\| rc == VERR_PAGE_NOT_PRESENT)
412	{
413	HMInvalidatePage(pVCpu, uSrcAddr);
414	if (((uSrcAddr + cbToRead - 1) >> PAGE_SHIFT) != (uSrcAddr >> PAGE_SHIFT))
415	HMInvalidatePage(pVCpu, uSrcAddr + cbToRead - 1);
416	}
417	#endif
418	}
419	}
420	}
421	}
422
423	pDis->cbCachedInstr = offInstr + (uint8_t)cbToRead;
424	return rc;
425	}
426
427
428	#if !defined(VBOX_WITH_IEM) \|\| defined(VBOX_COMPARE_IEM_AND_EM)
429	DECLINLINE(int) emDisCoreOne(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, RTGCUINTPTR InstrGC, uint32_t *pOpsize)
430	{
431	NOREF(pVM);
432	return DISInstrWithReader(InstrGC, (DISCPUMODE)pDis->uCpuMode, emReadBytes, pVCpu, pDis, pOpsize);
433	}
434	#endif
435
436
437	/**
438	* Disassembles the current instruction.
439	*
440	* @returns VBox status code, see SELMToFlatEx and EMInterpretDisasOneEx for
441	* details.
442	*
443	* @param pVM The cross context VM structure.
444	* @param pVCpu The cross context virtual CPU structure.
445	* @param pDis Where to return the parsed instruction info.
446	* @param pcbInstr Where to return the instruction size. (optional)
447	*/
448	VMM_INT_DECL(int) EMInterpretDisasCurrent(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, unsigned *pcbInstr)
449	{
450	PCPUMCTXCORE pCtxCore = CPUMCTX2CORE(CPUMQueryGuestCtxPtr(pVCpu));
451	RTGCPTR GCPtrInstr;
452	#if 0
453	int rc = SELMToFlatEx(pVCpu, DISSELREG_CS, pCtxCore, pCtxCore->rip, 0, &GCPtrInstr);
454	#else
455	/** @todo Get the CPU mode as well while we're at it! */
456	int rc = SELMValidateAndConvertCSAddr(pVCpu, pCtxCore->eflags, pCtxCore->ss.Sel, pCtxCore->cs.Sel, &pCtxCore->cs,
457	pCtxCore->rip, &GCPtrInstr);
458	#endif
459	if (RT_FAILURE(rc))
460	{
461	Log(("EMInterpretDisasOne: Failed to convert %RTsel:%RGv (cpl=%d) - rc=%Rrc !!\n",
462	pCtxCore->cs.Sel, (RTGCPTR)pCtxCore->rip, pCtxCore->ss.Sel & X86_SEL_RPL, rc));
463	return rc;
464	}
465	return EMInterpretDisasOneEx(pVM, pVCpu, (RTGCUINTPTR)GCPtrInstr, pCtxCore, pDis, pcbInstr);
466	}
467
468
469	/**
470	* Disassembles one instruction.
471	*
472	* This is used by internally by the interpreter and by trap/access handlers.
473	*
474	* @returns VBox status code.
475	*
476	* @param pVM The cross context VM structure.
477	* @param pVCpu The cross context virtual CPU structure.
478	* @param GCPtrInstr The flat address of the instruction.
479	* @param pCtxCore The context core (used to determine the cpu mode).
480	* @param pDis Where to return the parsed instruction info.
481	* @param pcbInstr Where to return the instruction size. (optional)
482	*/
483	VMM_INT_DECL(int) EMInterpretDisasOneEx(PVM pVM, PVMCPU pVCpu, RTGCUINTPTR GCPtrInstr, PCCPUMCTXCORE pCtxCore,
484	PDISCPUSTATE pDis, unsigned *pcbInstr)
485	{
486	NOREF(pVM);
487	Assert(pCtxCore == CPUMGetGuestCtxCore(pVCpu)); NOREF(pCtxCore);
488	DISCPUMODE enmCpuMode = CPUMGetGuestDisMode(pVCpu);
489	/** @todo Deal with too long instruction (=> \#GP), opcode read errors (=>
490	* \#PF, \#GP, \#??), undefined opcodes (=> \#UD), and such. */
491	int rc = DISInstrWithReader(GCPtrInstr, enmCpuMode, emReadBytes, pVCpu, pDis, pcbInstr);
492	if (RT_SUCCESS(rc))
493	return VINF_SUCCESS;
494	AssertMsg(rc == VERR_PAGE_NOT_PRESENT \|\| rc == VERR_PAGE_TABLE_NOT_PRESENT, ("DISCoreOne failed to GCPtrInstr=%RGv rc=%Rrc\n", GCPtrInstr, rc));
495	return rc;
496	}
497
498
499	#if defined(VBOX_COMPARE_IEM_FIRST) \|\| defined(VBOX_COMPARE_IEM_LAST)
500	static void emCompareWithIem(PVMCPU pVCpu, PCCPUMCTX pEmCtx, PCCPUMCTX pIemCtx,
501	VBOXSTRICTRC rcEm, VBOXSTRICTRC rcIem,
502	uint32_t cbEm, uint32_t cbIem)
503	{
504	/* Quick compare. */
505	if ( rcEm == rcIem
506	&& cbEm == cbIem
507	&& g_cbEmWrote == g_cbIemWrote
508	&& memcmp(g_abIemWrote, g_abEmWrote, g_cbIemWrote) == 0
509	&& memcmp(pIemCtx, pEmCtx, sizeof(*pIemCtx)) == 0
510	&& (g_fEmFFs & g_fInterestingFFs) == (g_fIemFFs & g_fInterestingFFs)
511	)
512	return;
513
514	/* Report exact differences. */
515	RTLogPrintf("! EM and IEM differs at %04x:%08RGv !\n", g_IncomingCtx.cs.Sel, g_IncomingCtx.rip);
516	if (rcEm != rcIem)
517	RTLogPrintf(" * rcIem=%Rrc rcEm=%Rrc\n", VBOXSTRICTRC_VAL(rcIem), VBOXSTRICTRC_VAL(rcEm));
518	else if (cbEm != cbIem)
519	RTLogPrintf(" * cbIem=%#x cbEm=%#x\n", cbIem, cbEm);
520
521	if (RT_SUCCESS(rcEm) && RT_SUCCESS(rcIem))
522	{
523	if (g_cbIemWrote != g_cbEmWrote)
524	RTLogPrintf("!! g_cbIemWrote=%#x g_cbEmWrote=%#x\n", g_cbIemWrote, g_cbEmWrote);
525	else if (memcmp(g_abIemWrote, g_abEmWrote, g_cbIemWrote))
526	{
527	RTLogPrintf("!! IemWrote %.*Rhxs\n", RT_MIN(RT_MAX(1, g_cbIemWrote), 64), g_abIemWrote);
528	RTLogPrintf("!! EemWrote %.*Rhxs\n", RT_MIN(RT_MAX(1, g_cbIemWrote), 64), g_abIemWrote);
529	}
530
531	if ((g_fEmFFs & g_fInterestingFFs) != (g_fIemFFs & g_fInterestingFFs))
532	RTLogPrintf("!! g_fIemFFs=%#x g_fEmFFs=%#x (diff=%#x)\n", g_fIemFFs & g_fInterestingFFs,
533	g_fEmFFs & g_fInterestingFFs, (g_fIemFFs ^ g_fEmFFs) & g_fInterestingFFs);
534
535	# define CHECK_FIELD(a_Field) \
536	do \
537	{ \
538	if (pEmCtx->a_Field != pIemCtx->a_Field) \
539	{ \
540	switch (sizeof(pEmCtx->a_Field)) \
541	{ \
542	case 1: RTLogPrintf("!! %8s differs - iem=%02x - em=%02x\n", #a_Field, pIemCtx->a_Field, pEmCtx->a_Field); break; \
543	case 2: RTLogPrintf("!! %8s differs - iem=%04x - em=%04x\n", #a_Field, pIemCtx->a_Field, pEmCtx->a_Field); break; \
544	case 4: RTLogPrintf("!! %8s differs - iem=%08x - em=%08x\n", #a_Field, pIemCtx->a_Field, pEmCtx->a_Field); break; \
545	case 8: RTLogPrintf("!! %8s differs - iem=%016llx - em=%016llx\n", #a_Field, pIemCtx->a_Field, pEmCtx->a_Field); break; \
546	default: RTLogPrintf("!! %8s differs\n", #a_Field); break; \
547	} \
548	cDiffs++; \
549	} \
550	} while (0)
551
552	# define CHECK_BIT_FIELD(a_Field) \
553	do \
554	{ \
555	if (pEmCtx->a_Field != pIemCtx->a_Field) \
556	{ \
557	RTLogPrintf("!! %8s differs - iem=%02x - em=%02x\n", #a_Field, pIemCtx->a_Field, pEmCtx->a_Field); \
558	cDiffs++; \
559	} \
560	} while (0)
561
562	# define CHECK_SEL(a_Sel) \
563	do \
564	{ \
565	CHECK_FIELD(a_Sel.Sel); \
566	CHECK_FIELD(a_Sel.Attr.u); \
567	CHECK_FIELD(a_Sel.u64Base); \
568	CHECK_FIELD(a_Sel.u32Limit); \
569	CHECK_FIELD(a_Sel.fFlags); \
570	} while (0)
571
572	unsigned cDiffs = 0;
573	if (memcmp(&pEmCtx->fpu, &pIemCtx->fpu, sizeof(pIemCtx->fpu)))
574	{
575	RTLogPrintf(" the FPU state differs\n");
576	cDiffs++;
577	CHECK_FIELD(fpu.FCW);
578	CHECK_FIELD(fpu.FSW);
579	CHECK_FIELD(fpu.FTW);
580	CHECK_FIELD(fpu.FOP);
581	CHECK_FIELD(fpu.FPUIP);
582	CHECK_FIELD(fpu.CS);
583	CHECK_FIELD(fpu.Rsrvd1);
584	CHECK_FIELD(fpu.FPUDP);
585	CHECK_FIELD(fpu.DS);
586	CHECK_FIELD(fpu.Rsrvd2);
587	CHECK_FIELD(fpu.MXCSR);
588	CHECK_FIELD(fpu.MXCSR_MASK);
589	CHECK_FIELD(fpu.aRegs[0].au64[0]); CHECK_FIELD(fpu.aRegs[0].au64[1]);
590	CHECK_FIELD(fpu.aRegs[1].au64[0]); CHECK_FIELD(fpu.aRegs[1].au64[1]);
591	CHECK_FIELD(fpu.aRegs[2].au64[0]); CHECK_FIELD(fpu.aRegs[2].au64[1]);
592	CHECK_FIELD(fpu.aRegs[3].au64[0]); CHECK_FIELD(fpu.aRegs[3].au64[1]);
593	CHECK_FIELD(fpu.aRegs[4].au64[0]); CHECK_FIELD(fpu.aRegs[4].au64[1]);
594	CHECK_FIELD(fpu.aRegs[5].au64[0]); CHECK_FIELD(fpu.aRegs[5].au64[1]);
595	CHECK_FIELD(fpu.aRegs[6].au64[0]); CHECK_FIELD(fpu.aRegs[6].au64[1]);
596	CHECK_FIELD(fpu.aRegs[7].au64[0]); CHECK_FIELD(fpu.aRegs[7].au64[1]);
597	CHECK_FIELD(fpu.aXMM[ 0].au64[0]); CHECK_FIELD(fpu.aXMM[ 0].au64[1]);
598	CHECK_FIELD(fpu.aXMM[ 1].au64[0]); CHECK_FIELD(fpu.aXMM[ 1].au64[1]);
599	CHECK_FIELD(fpu.aXMM[ 2].au64[0]); CHECK_FIELD(fpu.aXMM[ 2].au64[1]);
600	CHECK_FIELD(fpu.aXMM[ 3].au64[0]); CHECK_FIELD(fpu.aXMM[ 3].au64[1]);
601	CHECK_FIELD(fpu.aXMM[ 4].au64[0]); CHECK_FIELD(fpu.aXMM[ 4].au64[1]);
602	CHECK_FIELD(fpu.aXMM[ 5].au64[0]); CHECK_FIELD(fpu.aXMM[ 5].au64[1]);
603	CHECK_FIELD(fpu.aXMM[ 6].au64[0]); CHECK_FIELD(fpu.aXMM[ 6].au64[1]);
604	CHECK_FIELD(fpu.aXMM[ 7].au64[0]); CHECK_FIELD(fpu.aXMM[ 7].au64[1]);
605	CHECK_FIELD(fpu.aXMM[ 8].au64[0]); CHECK_FIELD(fpu.aXMM[ 8].au64[1]);
606	CHECK_FIELD(fpu.aXMM[ 9].au64[0]); CHECK_FIELD(fpu.aXMM[ 9].au64[1]);
607	CHECK_FIELD(fpu.aXMM[10].au64[0]); CHECK_FIELD(fpu.aXMM[10].au64[1]);
608	CHECK_FIELD(fpu.aXMM[11].au64[0]); CHECK_FIELD(fpu.aXMM[11].au64[1]);
609	CHECK_FIELD(fpu.aXMM[12].au64[0]); CHECK_FIELD(fpu.aXMM[12].au64[1]);
610	CHECK_FIELD(fpu.aXMM[13].au64[0]); CHECK_FIELD(fpu.aXMM[13].au64[1]);
611	CHECK_FIELD(fpu.aXMM[14].au64[0]); CHECK_FIELD(fpu.aXMM[14].au64[1]);
612	CHECK_FIELD(fpu.aXMM[15].au64[0]); CHECK_FIELD(fpu.aXMM[15].au64[1]);
613	for (unsigned i = 0; i < RT_ELEMENTS(pEmCtx->fpu.au32RsrvdRest); i++)
614	CHECK_FIELD(fpu.au32RsrvdRest[i]);
615	}
616	CHECK_FIELD(rip);
617	if (pEmCtx->rflags.u != pIemCtx->rflags.u)
618	{
619	RTLogPrintf("!! rflags differs - iem=%08llx em=%08llx\n", pIemCtx->rflags.u, pEmCtx->rflags.u);
620	CHECK_BIT_FIELD(rflags.Bits.u1CF);
621	CHECK_BIT_FIELD(rflags.Bits.u1Reserved0);
622	CHECK_BIT_FIELD(rflags.Bits.u1PF);
623	CHECK_BIT_FIELD(rflags.Bits.u1Reserved1);
624	CHECK_BIT_FIELD(rflags.Bits.u1AF);
625	CHECK_BIT_FIELD(rflags.Bits.u1Reserved2);
626	CHECK_BIT_FIELD(rflags.Bits.u1ZF);
627	CHECK_BIT_FIELD(rflags.Bits.u1SF);
628	CHECK_BIT_FIELD(rflags.Bits.u1TF);
629	CHECK_BIT_FIELD(rflags.Bits.u1IF);
630	CHECK_BIT_FIELD(rflags.Bits.u1DF);
631	CHECK_BIT_FIELD(rflags.Bits.u1OF);
632	CHECK_BIT_FIELD(rflags.Bits.u2IOPL);
633	CHECK_BIT_FIELD(rflags.Bits.u1NT);
634	CHECK_BIT_FIELD(rflags.Bits.u1Reserved3);
635	CHECK_BIT_FIELD(rflags.Bits.u1RF);
636	CHECK_BIT_FIELD(rflags.Bits.u1VM);
637	CHECK_BIT_FIELD(rflags.Bits.u1AC);
638	CHECK_BIT_FIELD(rflags.Bits.u1VIF);
639	CHECK_BIT_FIELD(rflags.Bits.u1VIP);
640	CHECK_BIT_FIELD(rflags.Bits.u1ID);
641	}
642
643	if (!g_fIgnoreRaxRdx)
644	CHECK_FIELD(rax);
645	CHECK_FIELD(rcx);
646	if (!g_fIgnoreRaxRdx)
647	CHECK_FIELD(rdx);
648	CHECK_FIELD(rbx);
649	CHECK_FIELD(rsp);
650	CHECK_FIELD(rbp);
651	CHECK_FIELD(rsi);
652	CHECK_FIELD(rdi);
653	CHECK_FIELD(r8);
654	CHECK_FIELD(r9);
655	CHECK_FIELD(r10);
656	CHECK_FIELD(r11);
657	CHECK_FIELD(r12);
658	CHECK_FIELD(r13);
659	CHECK_SEL(cs);
660	CHECK_SEL(ss);
661	CHECK_SEL(ds);
662	CHECK_SEL(es);
663	CHECK_SEL(fs);
664	CHECK_SEL(gs);
665	CHECK_FIELD(cr0);
666	CHECK_FIELD(cr2);
667	CHECK_FIELD(cr3);
668	CHECK_FIELD(cr4);
669	CHECK_FIELD(dr[0]);
670	CHECK_FIELD(dr[1]);
671	CHECK_FIELD(dr[2]);
672	CHECK_FIELD(dr[3]);
673	CHECK_FIELD(dr[6]);
674	CHECK_FIELD(dr[7]);
675	CHECK_FIELD(gdtr.cbGdt);
676	CHECK_FIELD(gdtr.pGdt);
677	CHECK_FIELD(idtr.cbIdt);
678	CHECK_FIELD(idtr.pIdt);
679	CHECK_SEL(ldtr);
680	CHECK_SEL(tr);
681	CHECK_FIELD(SysEnter.cs);
682	CHECK_FIELD(SysEnter.eip);
683	CHECK_FIELD(SysEnter.esp);
684	CHECK_FIELD(msrEFER);
685	CHECK_FIELD(msrSTAR);
686	CHECK_FIELD(msrPAT);
687	CHECK_FIELD(msrLSTAR);
688	CHECK_FIELD(msrCSTAR);
689	CHECK_FIELD(msrSFMASK);
690	CHECK_FIELD(msrKERNELGSBASE);
691
692	# undef CHECK_FIELD
693	# undef CHECK_BIT_FIELD
694	}
695	}
696	#endif /* VBOX_COMPARE_IEM_AND_EM */
697
698
699	/**
700	* Interprets the current instruction.
701	*
702	* @returns VBox status code.
703	* @retval VINF_* Scheduling instructions.
704	* @retval VERR_EM_INTERPRETER Something we can't cope with.
705	* @retval VERR_* Fatal errors.
706	*
707	* @param pVCpu The cross context virtual CPU structure.
708	* @param pRegFrame The register frame.
709	* Updates the EIP if an instruction was executed successfully.
710	* @param pvFault The fault address (CR2).
711	*
712	* @remark Invalid opcode exceptions have a higher priority than GP (see Intel
713	* Architecture System Developers Manual, Vol 3, 5.5) so we don't need
714	* to worry about e.g. invalid modrm combinations (!)
715	*/
716	VMM_INT_DECL(VBOXSTRICTRC) EMInterpretInstruction(PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault)
717	{
718	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
719	LogFlow(("EMInterpretInstruction %RGv fault %RGv\n", (RTGCPTR)pRegFrame->rip, pvFault));
720	#ifdef VBOX_WITH_IEM
721	NOREF(pvFault);
722
723	# ifdef VBOX_COMPARE_IEM_AND_EM
724	PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(pVCpu);
725	g_IncomingCtx = *pCtx;
726	g_fIncomingFFs = pVCpu->fLocalForcedActions;
727	g_cbEmWrote = g_cbIemWrote = 0;
728
729	# ifdef VBOX_COMPARE_IEM_FIRST
730	/* IEM */
731	VBOXSTRICTRC rcIem = IEMExecOneBypassEx(pVCpu, pRegFrame, NULL);
732	if (RT_UNLIKELY( rcIem == VERR_IEM_ASPECT_NOT_IMPLEMENTED
733	\|\| rcIem == VERR_IEM_INSTR_NOT_IMPLEMENTED))
734	rcIem = VERR_EM_INTERPRETER;
735	g_IemCtx = *pCtx;
736	g_fIemFFs = pVCpu->fLocalForcedActions;
737	pVCpu->fLocalForcedActions = (pVCpu->fLocalForcedActions & ~g_fInterestingFFs) \| (g_fIncomingFFs & g_fInterestingFFs);
738	*pCtx = g_IncomingCtx;
739	# endif
740
741	/* EM */
742	RTGCPTR pbCode;
743	VBOXSTRICTRC rcEm = SELMToFlatEx(pVCpu, DISSELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
744	if (RT_SUCCESS(rcEm))
745	{
746	uint32_t cbOp;
747	PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
748	pDis->uCpuMode = CPUMGetGuestDisMode(pVCpu);
749	rcEm = emDisCoreOne(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
750	if (RT_SUCCESS(rcEm))
751	{
752	Assert(cbOp == pDis->cbInstr);
753	uint32_t cbIgnored;
754	rcEm = emInterpretInstructionCPUOuter(pVCpu, pDis, pRegFrame, pvFault, EMCODETYPE_SUPERVISOR, &cbIgnored);
755	if (RT_SUCCESS(rcEm))
756	pRegFrame->rip += cbOp; /* Move on to the next instruction. */
757
758	}
759	rcEm = VERR_EM_INTERPRETER;
760	}
761	else
762	rcEm = VERR_EM_INTERPRETER;
763	# ifdef VBOX_SAME_AS_EM
764	if (rcEm == VERR_EM_INTERPRETER)
765	{
766	Log(("EMInterpretInstruction: returns %Rrc\n", VBOXSTRICTRC_VAL(rcEm)));
767	return rcEm;
768	}
769	# endif
770	g_EmCtx = *pCtx;
771	g_fEmFFs = pVCpu->fLocalForcedActions;
772	VBOXSTRICTRC rc = rcEm;
773
774	# ifdef VBOX_COMPARE_IEM_LAST
775	/* IEM */
776	pVCpu->fLocalForcedActions = (pVCpu->fLocalForcedActions & ~g_fInterestingFFs) \| (g_fIncomingFFs & g_fInterestingFFs);
777	*pCtx = g_IncomingCtx;
778	VBOXSTRICTRC rcIem = IEMExecOneBypassEx(pVCpu, pRegFrame, NULL);
779	if (RT_UNLIKELY( rcIem == VERR_IEM_ASPECT_NOT_IMPLEMENTED
780	\|\| rcIem == VERR_IEM_INSTR_NOT_IMPLEMENTED))
781	rcIem = VERR_EM_INTERPRETER;
782	g_IemCtx = *pCtx;
783	g_fIemFFs = pVCpu->fLocalForcedActions;
784	rc = rcIem;
785	# endif
786
787	# if defined(VBOX_COMPARE_IEM_LAST) \|\| defined(VBOX_COMPARE_IEM_FIRST)
788	emCompareWithIem(pVCpu, &g_EmCtx, &g_IemCtx, rcEm, rcIem, 0, 0);
789	# endif
790
791	# else
792	VBOXSTRICTRC rc = IEMExecOneBypassEx(pVCpu, pRegFrame, NULL);
793	if (RT_UNLIKELY( rc == VERR_IEM_ASPECT_NOT_IMPLEMENTED
794	\|\| rc == VERR_IEM_INSTR_NOT_IMPLEMENTED))
795	rc = VERR_EM_INTERPRETER;
796	# endif
797	if (rc != VINF_SUCCESS)
798	Log(("EMInterpretInstruction: returns %Rrc\n", VBOXSTRICTRC_VAL(rc)));
799
800	return rc;
801	#else
802	RTGCPTR pbCode;
803	VBOXSTRICTRC rc = SELMToFlatEx(pVCpu, DISSELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
804	if (RT_SUCCESS(rc))
805	{
806	uint32_t cbOp;
807	PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
808	pDis->uCpuMode = CPUMGetGuestDisMode(pVCpu);
809	rc = emDisCoreOne(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
810	if (RT_SUCCESS(rc))
811	{
812	Assert(cbOp == pDis->cbInstr);
813	uint32_t cbIgnored;
814	rc = emInterpretInstructionCPUOuter(pVCpu, pDis, pRegFrame, pvFault, EMCODETYPE_SUPERVISOR, &cbIgnored);
815	if (RT_SUCCESS(rc))
816	pRegFrame->rip += cbOp; /* Move on to the next instruction. */
817
818	return rc;
819	}
820	}
821	return VERR_EM_INTERPRETER;
822	#endif
823	}
824
825
826	/**
827	* Interprets the current instruction.
828	*
829	* @returns VBox status code.
830	* @retval VINF_* Scheduling instructions.
831	* @retval VERR_EM_INTERPRETER Something we can't cope with.
832	* @retval VERR_* Fatal errors.
833	*
834	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
835	* @param pRegFrame The register frame.
836	* Updates the EIP if an instruction was executed successfully.
837	* @param pvFault The fault address (CR2).
838	* @param pcbWritten Size of the write (if applicable).
839	*
840	* @remark Invalid opcode exceptions have a higher priority than GP (see Intel
841	* Architecture System Developers Manual, Vol 3, 5.5) so we don't need
842	* to worry about e.g. invalid modrm combinations (!)
843	*/
844	VMM_INT_DECL(VBOXSTRICTRC) EMInterpretInstructionEx(PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbWritten)
845	{
846	LogFlow(("EMInterpretInstructionEx %RGv fault %RGv\n", (RTGCPTR)pRegFrame->rip, pvFault));
847	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
848	#ifdef VBOX_WITH_IEM
849	NOREF(pvFault);
850
851	# ifdef VBOX_COMPARE_IEM_AND_EM
852	PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(pVCpu);
853	g_IncomingCtx = *pCtx;
854	g_fIncomingFFs = pVCpu->fLocalForcedActions;
855	g_cbEmWrote = g_cbIemWrote = 0;
856
857	# ifdef VBOX_COMPARE_IEM_FIRST
858	/* IEM */
859	uint32_t cbIemWritten = 0;
860	VBOXSTRICTRC rcIem = IEMExecOneBypassEx(pVCpu, pRegFrame, &cbIemWritten);
861	if (RT_UNLIKELY( rcIem == VERR_IEM_ASPECT_NOT_IMPLEMENTED
862	\|\| rcIem == VERR_IEM_INSTR_NOT_IMPLEMENTED))
863	rcIem = VERR_EM_INTERPRETER;
864	g_IemCtx = *pCtx;
865	g_fIemFFs = pVCpu->fLocalForcedActions;
866	pVCpu->fLocalForcedActions = (pVCpu->fLocalForcedActions & ~g_fInterestingFFs) \| (g_fIncomingFFs & g_fInterestingFFs);
867	*pCtx = g_IncomingCtx;
868	# endif
869
870	/* EM */
871	uint32_t cbEmWritten = 0;
872	RTGCPTR pbCode;
873	VBOXSTRICTRC rcEm = SELMToFlatEx(pVCpu, DISSELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
874	if (RT_SUCCESS(rcEm))
875	{
876	uint32_t cbOp;
877	PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
878	pDis->uCpuMode = CPUMGetGuestDisMode(pVCpu);
879	rcEm = emDisCoreOne(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
880	if (RT_SUCCESS(rcEm))
881	{
882	Assert(cbOp == pDis->cbInstr);
883	rcEm = emInterpretInstructionCPUOuter(pVCpu, pDis, pRegFrame, pvFault, EMCODETYPE_SUPERVISOR, &cbEmWritten);
884	if (RT_SUCCESS(rcEm))
885	pRegFrame->rip += cbOp; /* Move on to the next instruction. */
886
887	}
888	else
889	rcEm = VERR_EM_INTERPRETER;
890	}
891	else
892	rcEm = VERR_EM_INTERPRETER;
893	# ifdef VBOX_SAME_AS_EM
894	if (rcEm == VERR_EM_INTERPRETER)
895	{
896	Log(("EMInterpretInstruction: returns %Rrc\n", VBOXSTRICTRC_VAL(rcEm)));
897	return rcEm;
898	}
899	# endif
900	g_EmCtx = *pCtx;
901	g_fEmFFs = pVCpu->fLocalForcedActions;
902	*pcbWritten = cbEmWritten;
903	VBOXSTRICTRC rc = rcEm;
904
905	# ifdef VBOX_COMPARE_IEM_LAST
906	/* IEM */
907	pVCpu->fLocalForcedActions = (pVCpu->fLocalForcedActions & ~g_fInterestingFFs) \| (g_fIncomingFFs & g_fInterestingFFs);
908	*pCtx = g_IncomingCtx;
909	uint32_t cbIemWritten = 0;
910	VBOXSTRICTRC rcIem = IEMExecOneBypassEx(pVCpu, pRegFrame, &cbIemWritten);
911	if (RT_UNLIKELY( rcIem == VERR_IEM_ASPECT_NOT_IMPLEMENTED
912	\|\| rcIem == VERR_IEM_INSTR_NOT_IMPLEMENTED))
913	rcIem = VERR_EM_INTERPRETER;
914	g_IemCtx = *pCtx;
915	g_fIemFFs = pVCpu->fLocalForcedActions;
916	*pcbWritten = cbIemWritten;
917	rc = rcIem;
918	# endif
919
920	# if defined(VBOX_COMPARE_IEM_LAST) \|\| defined(VBOX_COMPARE_IEM_FIRST)
921	emCompareWithIem(pVCpu, &g_EmCtx, &g_IemCtx, rcEm, rcIem, cbEmWritten, cbIemWritten);
922	# endif
923
924	# else
925	VBOXSTRICTRC rc = IEMExecOneBypassEx(pVCpu, pRegFrame, pcbWritten);
926	if (RT_UNLIKELY( rc == VERR_IEM_ASPECT_NOT_IMPLEMENTED
927	\|\| rc == VERR_IEM_INSTR_NOT_IMPLEMENTED))
928	rc = VERR_EM_INTERPRETER;
929	# endif
930	if (rc != VINF_SUCCESS)
931	Log(("EMInterpretInstructionEx: returns %Rrc\n", VBOXSTRICTRC_VAL(rc)));
932
933	return rc;
934	#else
935	RTGCPTR pbCode;
936	VBOXSTRICTRC rc = SELMToFlatEx(pVCpu, DISSELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
937	if (RT_SUCCESS(rc))
938	{
939	uint32_t cbOp;
940	PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
941	pDis->uCpuMode = CPUMGetGuestDisMode(pVCpu);
942	rc = emDisCoreOne(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
943	if (RT_SUCCESS(rc))
944	{
945	Assert(cbOp == pDis->cbInstr);
946	rc = emInterpretInstructionCPUOuter(pVCpu, pDis, pRegFrame, pvFault, EMCODETYPE_SUPERVISOR, pcbWritten);
947	if (RT_SUCCESS(rc))
948	pRegFrame->rip += cbOp; /* Move on to the next instruction. */
949
950	return rc;
951	}
952	}
953	return VERR_EM_INTERPRETER;
954	#endif
955	}
956
957
958	/**
959	* Interprets the current instruction using the supplied DISCPUSTATE structure.
960	*
961	* IP/EIP/RIP IS updated!
962	*
963	* @returns VBox strict status code.
964	* @retval VINF_* Scheduling instructions. When these are returned, it
965	* starts to get a bit tricky to know whether code was
966	* executed or not... We'll address this when it becomes a problem.
967	* @retval VERR_EM_INTERPRETER Something we can't cope with.
968	* @retval VERR_* Fatal errors.
969	*
970	* @param pVCpu The cross context virtual CPU structure of the calling EMT.
971	* @param pDis The disassembler cpu state for the instruction to be
972	* interpreted.
973	* @param pRegFrame The register frame. IP/EIP/RIP IS changed!
974	* @param pvFault The fault address (CR2).
975	* @param enmCodeType Code type (user/supervisor)
976	*
977	* @remark Invalid opcode exceptions have a higher priority than GP (see Intel
978	* Architecture System Developers Manual, Vol 3, 5.5) so we don't need
979	* to worry about e.g. invalid modrm combinations (!)
980	*
981	* @todo At this time we do NOT check if the instruction overwrites vital information.
982	* Make sure this can't happen!! (will add some assertions/checks later)
983	*/
984	VMM_INT_DECL(VBOXSTRICTRC) EMInterpretInstructionDisasState(PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame,
985	RTGCPTR pvFault, EMCODETYPE enmCodeType)
986	{
987	LogFlow(("EMInterpretInstructionDisasState %RGv fault %RGv\n", (RTGCPTR)pRegFrame->rip, pvFault));
988	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
989	#ifdef VBOX_WITH_IEM
990	NOREF(pDis); NOREF(pvFault); NOREF(enmCodeType);
991
992	# ifdef VBOX_COMPARE_IEM_AND_EM
993	PCPUMCTX pCtx = CPUMQueryGuestCtxPtr(pVCpu);
994	g_IncomingCtx = *pCtx;
995	g_fIncomingFFs = pVCpu->fLocalForcedActions;
996	g_cbEmWrote = g_cbIemWrote = 0;
997
998	# ifdef VBOX_COMPARE_IEM_FIRST
999	VBOXSTRICTRC rcIem = IEMExecOneBypassWithPrefetchedByPC(pVCpu, pRegFrame, pRegFrame->rip, pDis->abInstr, pDis->cbCachedInstr);
1000	if (RT_UNLIKELY( rcIem == VERR_IEM_ASPECT_NOT_IMPLEMENTED
1001	\|\| rcIem == VERR_IEM_INSTR_NOT_IMPLEMENTED))
1002	rcIem = VERR_EM_INTERPRETER;
1003	g_IemCtx = *pCtx;
1004	g_fIemFFs = pVCpu->fLocalForcedActions;
1005	pVCpu->fLocalForcedActions = (pVCpu->fLocalForcedActions & ~g_fInterestingFFs) \| (g_fIncomingFFs & g_fInterestingFFs);
1006	*pCtx = g_IncomingCtx;
1007	# endif
1008
1009	/* EM */
1010	uint32_t cbIgnored;
1011	VBOXSTRICTRC rcEm = emInterpretInstructionCPUOuter(pVCpu, pDis, pRegFrame, pvFault, enmCodeType, &cbIgnored);
1012	if (RT_SUCCESS(rcEm))
1013	pRegFrame->rip += pDis->cbInstr; /* Move on to the next instruction. */
1014	# ifdef VBOX_SAME_AS_EM
1015	if (rcEm == VERR_EM_INTERPRETER)
1016	{
1017	Log(("EMInterpretInstruction: returns %Rrc\n", VBOXSTRICTRC_VAL(rcEm)));
1018	return rcEm;
1019	}
1020	# endif
1021	g_EmCtx = *pCtx;
1022	g_fEmFFs = pVCpu->fLocalForcedActions;
1023	VBOXSTRICTRC rc = rcEm;
1024
1025	# ifdef VBOX_COMPARE_IEM_LAST
1026	/* IEM */
1027	pVCpu->fLocalForcedActions = (pVCpu->fLocalForcedActions & ~g_fInterestingFFs) \| (g_fIncomingFFs & g_fInterestingFFs);
1028	*pCtx = g_IncomingCtx;
1029	VBOXSTRICTRC rcIem = IEMExecOneBypassWithPrefetchedByPC(pVCpu, pRegFrame, pRegFrame->rip, pDis->abInstr, pDis->cbCachedInstr);
1030	if (RT_UNLIKELY( rcIem == VERR_IEM_ASPECT_NOT_IMPLEMENTED
1031	\|\| rcIem == VERR_IEM_INSTR_NOT_IMPLEMENTED))
1032	rcIem = VERR_EM_INTERPRETER;
1033	g_IemCtx = *pCtx;
1034	g_fIemFFs = pVCpu->fLocalForcedActions;
1035	rc = rcIem;
1036	# endif
1037
1038	# if defined(VBOX_COMPARE_IEM_LAST) \|\| defined(VBOX_COMPARE_IEM_FIRST)
1039	emCompareWithIem(pVCpu, &g_EmCtx, &g_IemCtx, rcEm, rcIem, 0, 0);
1040	# endif
1041
1042	# else
1043	VBOXSTRICTRC rc = IEMExecOneBypassWithPrefetchedByPC(pVCpu, pRegFrame, pRegFrame->rip, pDis->abInstr, pDis->cbCachedInstr);
1044	if (RT_UNLIKELY( rc == VERR_IEM_ASPECT_NOT_IMPLEMENTED
1045	\|\| rc == VERR_IEM_INSTR_NOT_IMPLEMENTED))
1046	rc = VERR_EM_INTERPRETER;
1047	# endif
1048
1049	if (rc != VINF_SUCCESS)
1050	Log(("EMInterpretInstructionDisasState: returns %Rrc\n", VBOXSTRICTRC_VAL(rc)));
1051
1052	return rc;
1053	#else
1054	uint32_t cbIgnored;
1055	VBOXSTRICTRC rc = emInterpretInstructionCPUOuter(pVCpu, pDis, pRegFrame, pvFault, enmCodeType, &cbIgnored);
1056	if (RT_SUCCESS(rc))
1057	pRegFrame->rip += pDis->cbInstr; /* Move on to the next instruction. */
1058	return rc;
1059	#endif
1060	}
1061
1062	#ifdef IN_RC
1063
1064	DECLINLINE(int) emRCStackRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCPTR GCPtrSrc, uint32_t cb)
1065	{
1066	int rc = MMGCRamRead(pVM, pvDst, (void *)(uintptr_t)GCPtrSrc, cb);
1067	if (RT_LIKELY(rc != VERR_ACCESS_DENIED))
1068	return rc;
1069	return PGMPhysInterpretedReadNoHandlers(pVCpu, pCtxCore, pvDst, GCPtrSrc, cb, /fMayTrap/ false);
1070	}
1071
1072
1073	/**
1074	* Interpret IRET (currently only to V86 code) - PATM only.
1075	*
1076	* @returns VBox status code.
1077	* @param pVM The cross context VM structure.
1078	* @param pVCpu The cross context virtual CPU structure.
1079	* @param pRegFrame The register frame.
1080	*
1081	*/
1082	VMM_INT_DECL(int) EMInterpretIretV86ForPatm(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1083	{
1084	RTGCUINTPTR pIretStack = (RTGCUINTPTR)pRegFrame->esp;
1085	RTGCUINTPTR eip, cs, esp, ss, eflags, ds, es, fs, gs, uMask;
1086	int rc;
1087
1088	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1089	Assert(!CPUMIsGuestIn64BitCode(pVCpu));
1090	/** @todo Rainy day: Test what happens when VERR_EM_INTERPRETER is returned by
1091	* this function. Fear that it may guru on us, thus not converted to
1092	* IEM. */
1093
1094	rc = emRCStackRead(pVM, pVCpu, pRegFrame, &eip, (RTGCPTR)pIretStack , 4);
1095	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &cs, (RTGCPTR)(pIretStack + 4), 4);
1096	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &eflags, (RTGCPTR)(pIretStack + 8), 4);
1097	AssertRCReturn(rc, VERR_EM_INTERPRETER);
1098	AssertReturn(eflags & X86_EFL_VM, VERR_EM_INTERPRETER);
1099
1100	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &esp, (RTGCPTR)(pIretStack + 12), 4);
1101	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &ss, (RTGCPTR)(pIretStack + 16), 4);
1102	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &es, (RTGCPTR)(pIretStack + 20), 4);
1103	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &ds, (RTGCPTR)(pIretStack + 24), 4);
1104	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &fs, (RTGCPTR)(pIretStack + 28), 4);
1105	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &gs, (RTGCPTR)(pIretStack + 32), 4);
1106	AssertRCReturn(rc, VERR_EM_INTERPRETER);
1107
1108	pRegFrame->eip = eip & 0xffff;
1109	pRegFrame->cs.Sel = cs;
1110
1111	/* Mask away all reserved bits */
1112	uMask = X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_TF \| X86_EFL_IF \| X86_EFL_DF \| X86_EFL_OF \| X86_EFL_IOPL \| X86_EFL_NT \| X86_EFL_RF \| X86_EFL_VM \| X86_EFL_AC \| X86_EFL_VIF \| X86_EFL_VIP \| X86_EFL_ID;
1113	eflags &= uMask;
1114
1115	CPUMRawSetEFlags(pVCpu, eflags);
1116	Assert((pRegFrame->eflags.u32 & (X86_EFL_IF\|X86_EFL_IOPL)) == X86_EFL_IF);
1117
1118	pRegFrame->esp = esp;
1119	pRegFrame->ss.Sel = ss;
1120	pRegFrame->ds.Sel = ds;
1121	pRegFrame->es.Sel = es;
1122	pRegFrame->fs.Sel = fs;
1123	pRegFrame->gs.Sel = gs;
1124
1125	return VINF_SUCCESS;
1126	}
1127
1128	# ifndef VBOX_WITH_IEM
1129	/**
1130	* IRET Emulation.
1131	*/
1132	static int emInterpretIret(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1133	{
1134	#ifdef VBOX_WITH_RAW_RING1
1135	NOREF(pvFault); NOREF(pcbSize); NOREF(pDis);
1136	if (EMIsRawRing1Enabled(pVM))
1137	{
1138	RTGCUINTPTR pIretStack = (RTGCUINTPTR)pRegFrame->esp;
1139	RTGCUINTPTR eip, cs, esp, ss, eflags, uMask;
1140	int rc;
1141	uint32_t cpl, rpl;
1142
1143	/* We only execute 32-bits protected mode code in raw mode, so no need to bother to check for 16-bits code here. */
1144	/** @todo we don't verify all the edge cases that generate #GP faults */
1145
1146	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1147	Assert(!CPUMIsGuestIn64BitCode(pVCpu));
1148	/** @todo Rainy day: Test what happens when VERR_EM_INTERPRETER is returned by
1149	* this function. Fear that it may guru on us, thus not converted to
1150	* IEM. */
1151
1152	rc = emRCStackRead(pVM, pVCpu, pRegFrame, &eip, (RTGCPTR)pIretStack , 4);
1153	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &cs, (RTGCPTR)(pIretStack + 4), 4);
1154	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &eflags, (RTGCPTR)(pIretStack + 8), 4);
1155	AssertRCReturn(rc, VERR_EM_INTERPRETER);
1156	AssertReturn(eflags & X86_EFL_VM, VERR_EM_INTERPRETER);
1157
1158	/* Deal with V86 above. */
1159	if (eflags & X86_EFL_VM)
1160	return EMInterpretIretV86ForPatm(pVM, pVCpu, pRegFrame);
1161
1162	cpl = CPUMRCGetGuestCPL(pVCpu, pRegFrame);
1163	rpl = cs & X86_SEL_RPL;
1164
1165	Log(("emInterpretIret: iret to CS:EIP=%04X:%08X eflags=%x\n", cs, eip, eflags));
1166	if (rpl != cpl)
1167	{
1168	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &esp, (RTGCPTR)(pIretStack + 12), 4);
1169	rc \|= emRCStackRead(pVM, pVCpu, pRegFrame, &ss, (RTGCPTR)(pIretStack + 16), 4);
1170	AssertRCReturn(rc, VERR_EM_INTERPRETER);
1171	Log(("emInterpretIret: return to different privilege level (rpl=%d cpl=%d)\n", rpl, cpl));
1172	Log(("emInterpretIret: SS:ESP=%04x:%08x\n", ss, esp));
1173	pRegFrame->ss.Sel = ss;
1174	pRegFrame->esp = esp;
1175	}
1176	pRegFrame->cs.Sel = cs;
1177	pRegFrame->eip = eip;
1178
1179	/* Adjust CS & SS as required. */
1180	CPUMRCRecheckRawState(pVCpu, pRegFrame);
1181
1182	/* Mask away all reserved bits */
1183	uMask = X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_TF \| X86_EFL_IF \| X86_EFL_DF \| X86_EFL_OF \| X86_EFL_IOPL \| X86_EFL_NT \| X86_EFL_RF \| X86_EFL_VM \| X86_EFL_AC \| X86_EFL_VIF \| X86_EFL_VIP \| X86_EFL_ID;
1184	eflags &= uMask;
1185
1186	CPUMRawSetEFlags(pVCpu, eflags);
1187	Assert((pRegFrame->eflags.u32 & (X86_EFL_IF\|X86_EFL_IOPL)) == X86_EFL_IF);
1188	return VINF_SUCCESS;
1189	}
1190	#else
1191	NOREF(pVM); NOREF(pVCpu); NOREF(pDis); NOREF(pRegFrame); NOREF(pvFault); NOREF(pcbSize);
1192	#endif
1193	return VERR_EM_INTERPRETER;
1194	}
1195	# endif /* !VBOX_WITH_IEM */
1196
1197	#endif /* IN_RC */
1198
1199
1200
1201	/*
1202	*
1203	* Old interpreter primitives used by HM, move/eliminate later.
1204	* Old interpreter primitives used by HM, move/eliminate later.
1205	* Old interpreter primitives used by HM, move/eliminate later.
1206	* Old interpreter primitives used by HM, move/eliminate later.
1207	* Old interpreter primitives used by HM, move/eliminate later.
1208	*
1209	*/
1210
1211
1212	/**
1213	* Interpret CPUID given the parameters in the CPU context.
1214	*
1215	* @returns VBox status code.
1216	* @param pVM The cross context VM structure.
1217	* @param pVCpu The cross context virtual CPU structure.
1218	* @param pRegFrame The register frame.
1219	*
1220	*/
1221	VMM_INT_DECL(int) EMInterpretCpuId(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1222	{
1223	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1224	uint32_t iLeaf = pRegFrame->eax;
1225	uint32_t iSubLeaf = pRegFrame->ecx;
1226	NOREF(pVM);
1227
1228	/* cpuid clears the high dwords of the affected 64 bits registers. */
1229	pRegFrame->rax = 0;
1230	pRegFrame->rbx = 0;
1231	pRegFrame->rcx = 0;
1232	pRegFrame->rdx = 0;
1233
1234	/* Note: operates the same in 64 and non-64 bits mode. */
1235	CPUMGetGuestCpuId(pVCpu, iLeaf, iSubLeaf, &pRegFrame->eax, &pRegFrame->ebx, &pRegFrame->ecx, &pRegFrame->edx);
1236	Log(("Emulate: CPUID %x -> %08x %08x %08x %08x\n", iLeaf, pRegFrame->eax, pRegFrame->ebx, pRegFrame->ecx, pRegFrame->edx));
1237	return VINF_SUCCESS;
1238	}
1239
1240
1241	/**
1242	* Interpret RDTSC.
1243	*
1244	* @returns VBox status code.
1245	* @param pVM The cross context VM structure.
1246	* @param pVCpu The cross context virtual CPU structure.
1247	* @param pRegFrame The register frame.
1248	*
1249	*/
1250	VMM_INT_DECL(int) EMInterpretRdtsc(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1251	{
1252	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1253	unsigned uCR4 = CPUMGetGuestCR4(pVCpu);
1254
1255	if (uCR4 & X86_CR4_TSD)
1256	return VERR_EM_INTERPRETER; /* genuine #GP */
1257
1258	uint64_t uTicks = TMCpuTickGet(pVCpu);
1259
1260	/* Same behaviour in 32 & 64 bits mode */
1261	pRegFrame->rax = (uint32_t)uTicks;
1262	pRegFrame->rdx = (uTicks >> 32ULL);
1263	#ifdef VBOX_COMPARE_IEM_AND_EM
1264	g_fIgnoreRaxRdx = true;
1265	#endif
1266
1267	NOREF(pVM);
1268	return VINF_SUCCESS;
1269	}
1270
1271	/**
1272	* Interpret RDTSCP.
1273	*
1274	* @returns VBox status code.
1275	* @param pVM The cross context VM structure.
1276	* @param pVCpu The cross context virtual CPU structure.
1277	* @param pCtx The CPU context.
1278	*
1279	*/
1280	VMM_INT_DECL(int) EMInterpretRdtscp(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
1281	{
1282	Assert(pCtx == CPUMQueryGuestCtxPtr(pVCpu));
1283	uint32_t uCR4 = CPUMGetGuestCR4(pVCpu);
1284
1285	if (!pVM->cpum.ro.GuestFeatures.fRdTscP)
1286	{
1287	AssertFailed();
1288	return VERR_EM_INTERPRETER; /* genuine #UD */
1289	}
1290
1291	if (uCR4 & X86_CR4_TSD)
1292	return VERR_EM_INTERPRETER; /* genuine #GP */
1293
1294	uint64_t uTicks = TMCpuTickGet(pVCpu);
1295
1296	/* Same behaviour in 32 & 64 bits mode */
1297	pCtx->rax = (uint32_t)uTicks;
1298	pCtx->rdx = (uTicks >> 32ULL);
1299	#ifdef VBOX_COMPARE_IEM_AND_EM
1300	g_fIgnoreRaxRdx = true;
1301	#endif
1302	/* Low dword of the TSC_AUX msr only. */
1303	VBOXSTRICTRC rc2 = CPUMQueryGuestMsr(pVCpu, MSR_K8_TSC_AUX, &pCtx->rcx); Assert(rc2 == VINF_SUCCESS); NOREF(rc2);
1304	pCtx->rcx &= UINT32_C(0xffffffff);
1305
1306	return VINF_SUCCESS;
1307	}
1308
1309	/**
1310	* Interpret RDPMC.
1311	*
1312	* @returns VBox status code.
1313	* @param pVM The cross context VM structure.
1314	* @param pVCpu The cross context virtual CPU structure.
1315	* @param pRegFrame The register frame.
1316	*
1317	*/
1318	VMM_INT_DECL(int) EMInterpretRdpmc(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1319	{
1320	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1321	uint32_t uCR4 = CPUMGetGuestCR4(pVCpu);
1322
1323	/* If X86_CR4_PCE is not set, then CPL must be zero. */
1324	if ( !(uCR4 & X86_CR4_PCE)
1325	&& CPUMGetGuestCPL(pVCpu) != 0)
1326	{
1327	Assert(CPUMGetGuestCR0(pVCpu) & X86_CR0_PE);
1328	return VERR_EM_INTERPRETER; /* genuine #GP */
1329	}
1330
1331	/* Just return zero here; rather tricky to properly emulate this, especially as the specs are a mess. */
1332	pRegFrame->rax = 0;
1333	pRegFrame->rdx = 0;
1334	/** @todo We should trigger a \#GP here if the CPU doesn't support the index in
1335	* ecx but see @bugref{3472}! */
1336
1337	NOREF(pVM);
1338	return VINF_SUCCESS;
1339	}
1340
1341
1342	/**
1343	* MWAIT Emulation.
1344	*/
1345	VMM_INT_DECL(VBOXSTRICTRC) EMInterpretMWait(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1346	{
1347	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1348	uint32_t u32Dummy, u32ExtFeatures, cpl, u32MWaitFeatures;
1349	NOREF(pVM);
1350
1351	/* Get the current privilege level. */
1352	cpl = CPUMGetGuestCPL(pVCpu);
1353	if (cpl != 0)
1354	return VERR_EM_INTERPRETER; /* supervisor only */
1355
1356	CPUMGetGuestCpuId(pVCpu, 1, 0, &u32Dummy, &u32Dummy, &u32ExtFeatures, &u32Dummy);
1357	if (!(u32ExtFeatures & X86_CPUID_FEATURE_ECX_MONITOR))
1358	return VERR_EM_INTERPRETER; /* not supported */
1359
1360	/*
1361	* CPUID.05H.ECX[0] defines support for power management extensions (eax)
1362	* CPUID.05H.ECX[1] defines support for interrupts as break events for mwait even when IF=0
1363	*/
1364	CPUMGetGuestCpuId(pVCpu, 5, 0, &u32Dummy, &u32Dummy, &u32MWaitFeatures, &u32Dummy);
1365	if (pRegFrame->ecx > 1)
1366	{
1367	Log(("EMInterpretMWait: unexpected ecx value %x -> recompiler\n", pRegFrame->ecx));
1368	return VERR_EM_INTERPRETER; /* illegal value. */
1369	}
1370
1371	if (pRegFrame->ecx && !(u32MWaitFeatures & X86_CPUID_MWAIT_ECX_BREAKIRQIF0))
1372	{
1373	Log(("EMInterpretMWait: unsupported X86_CPUID_MWAIT_ECX_BREAKIRQIF0 -> recompiler\n"));
1374	return VERR_EM_INTERPRETER; /* illegal value. */
1375	}
1376
1377	return EMMonitorWaitPerform(pVCpu, pRegFrame->rax, pRegFrame->rcx);
1378	}
1379
1380
1381	/**
1382	* MONITOR Emulation.
1383	*/
1384	VMM_INT_DECL(int) EMInterpretMonitor(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1385	{
1386	uint32_t u32Dummy, u32ExtFeatures, cpl;
1387	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1388	NOREF(pVM);
1389
1390	if (pRegFrame->ecx != 0)
1391	{
1392	Log(("emInterpretMonitor: unexpected ecx=%x -> recompiler!!\n", pRegFrame->ecx));
1393	return VERR_EM_INTERPRETER; /* illegal value. */
1394	}
1395
1396	/* Get the current privilege level. */
1397	cpl = CPUMGetGuestCPL(pVCpu);
1398	if (cpl != 0)
1399	return VERR_EM_INTERPRETER; /* supervisor only */
1400
1401	CPUMGetGuestCpuId(pVCpu, 1, 0, &u32Dummy, &u32Dummy, &u32ExtFeatures, &u32Dummy);
1402	if (!(u32ExtFeatures & X86_CPUID_FEATURE_ECX_MONITOR))
1403	return VERR_EM_INTERPRETER; /* not supported */
1404
1405	EMMonitorWaitPrepare(pVCpu, pRegFrame->rax, pRegFrame->rcx, pRegFrame->rdx, NIL_RTGCPHYS);
1406	return VINF_SUCCESS;
1407	}
1408
1409
1410	/* VT-x only: */
1411
1412	/**
1413	* Interpret INVLPG.
1414	*
1415	* @returns VBox status code.
1416	* @param pVM The cross context VM structure.
1417	* @param pVCpu The cross context virtual CPU structure.
1418	* @param pRegFrame The register frame.
1419	* @param pAddrGC Operand address.
1420	*
1421	*/
1422	VMM_INT_DECL(VBOXSTRICTRC) EMInterpretInvlpg(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pAddrGC)
1423	{
1424	/** @todo is addr always a flat linear address or ds based
1425	* (in absence of segment override prefixes)????
1426	*/
1427	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1428	NOREF(pVM); NOREF(pRegFrame);
1429	#ifdef IN_RC
1430	LogFlow(("RC: EMULATE: invlpg %RGv\n", pAddrGC));
1431	#endif
1432	VBOXSTRICTRC rc = PGMInvalidatePage(pVCpu, pAddrGC);
1433	if ( rc == VINF_SUCCESS
1434	\|\| rc == VINF_PGM_SYNC_CR3 /* we can rely on the FF */)
1435	return VINF_SUCCESS;
1436	AssertMsgReturn(rc == VINF_EM_RAW_EMULATE_INSTR,
1437	("%Rrc addr=%RGv\n", VBOXSTRICTRC_VAL(rc), pAddrGC),
1438	VERR_EM_INTERPRETER);
1439	return rc;
1440	}
1441
1442
1443	#ifdef LOG_ENABLED
1444	static const char *emMSRtoString(uint32_t uMsr)
1445	{
1446	switch (uMsr)
1447	{
1448	case MSR_IA32_APICBASE: return "MSR_IA32_APICBASE";
1449	case MSR_IA32_CR_PAT: return "MSR_IA32_CR_PAT";
1450	case MSR_IA32_SYSENTER_CS: return "MSR_IA32_SYSENTER_CS";
1451	case MSR_IA32_SYSENTER_EIP: return "MSR_IA32_SYSENTER_EIP";
1452	case MSR_IA32_SYSENTER_ESP: return "MSR_IA32_SYSENTER_ESP";
1453	case MSR_K6_EFER: return "MSR_K6_EFER";
1454	case MSR_K8_SF_MASK: return "MSR_K8_SF_MASK";
1455	case MSR_K6_STAR: return "MSR_K6_STAR";
1456	case MSR_K8_LSTAR: return "MSR_K8_LSTAR";
1457	case MSR_K8_CSTAR: return "MSR_K8_CSTAR";
1458	case MSR_K8_FS_BASE: return "MSR_K8_FS_BASE";
1459	case MSR_K8_GS_BASE: return "MSR_K8_GS_BASE";
1460	case MSR_K8_KERNEL_GS_BASE: return "MSR_K8_KERNEL_GS_BASE";
1461	case MSR_K8_TSC_AUX: return "MSR_K8_TSC_AUX";
1462	case MSR_IA32_BIOS_SIGN_ID: return "Unsupported MSR_IA32_BIOS_SIGN_ID";
1463	case MSR_IA32_PLATFORM_ID: return "Unsupported MSR_IA32_PLATFORM_ID";
1464	case MSR_IA32_BIOS_UPDT_TRIG: return "Unsupported MSR_IA32_BIOS_UPDT_TRIG";
1465	case MSR_IA32_TSC: return "MSR_IA32_TSC";
1466	case MSR_IA32_MISC_ENABLE: return "MSR_IA32_MISC_ENABLE";
1467	case MSR_IA32_MTRR_CAP: return "MSR_IA32_MTRR_CAP";
1468	case MSR_IA32_MCG_CAP: return "Unsupported MSR_IA32_MCG_CAP";
1469	case MSR_IA32_MCG_STATUS: return "Unsupported MSR_IA32_MCG_STATUS";
1470	case MSR_IA32_MCG_CTRL: return "Unsupported MSR_IA32_MCG_CTRL";
1471	case MSR_IA32_MTRR_DEF_TYPE: return "MSR_IA32_MTRR_DEF_TYPE";
1472	case MSR_K7_EVNTSEL0: return "Unsupported MSR_K7_EVNTSEL0";
1473	case MSR_K7_EVNTSEL1: return "Unsupported MSR_K7_EVNTSEL1";
1474	case MSR_K7_EVNTSEL2: return "Unsupported MSR_K7_EVNTSEL2";
1475	case MSR_K7_EVNTSEL3: return "Unsupported MSR_K7_EVNTSEL3";
1476	case MSR_IA32_MC0_CTL: return "Unsupported MSR_IA32_MC0_CTL";
1477	case MSR_IA32_MC0_STATUS: return "Unsupported MSR_IA32_MC0_STATUS";
1478	case MSR_IA32_PERFEVTSEL0: return "Unsupported MSR_IA32_PERFEVTSEL0";
1479	case MSR_IA32_PERFEVTSEL1: return "Unsupported MSR_IA32_PERFEVTSEL1";
1480	case MSR_IA32_PERF_STATUS: return "MSR_IA32_PERF_STATUS";
1481	case MSR_IA32_PLATFORM_INFO: return "MSR_IA32_PLATFORM_INFO";
1482	case MSR_IA32_PERF_CTL: return "Unsupported MSR_IA32_PERF_CTL";
1483	case MSR_K7_PERFCTR0: return "Unsupported MSR_K7_PERFCTR0";
1484	case MSR_K7_PERFCTR1: return "Unsupported MSR_K7_PERFCTR1";
1485	case MSR_K7_PERFCTR2: return "Unsupported MSR_K7_PERFCTR2";
1486	case MSR_K7_PERFCTR3: return "Unsupported MSR_K7_PERFCTR3";
1487	case MSR_IA32_PMC0: return "Unsupported MSR_IA32_PMC0";
1488	case MSR_IA32_PMC1: return "Unsupported MSR_IA32_PMC1";
1489	case MSR_IA32_PMC2: return "Unsupported MSR_IA32_PMC2";
1490	case MSR_IA32_PMC3: return "Unsupported MSR_IA32_PMC3";
1491	}
1492	return "Unknown MSR";
1493	}
1494	#endif /* LOG_ENABLED */
1495
1496
1497	/**
1498	* Interpret RDMSR
1499	*
1500	* @returns VBox status code.
1501	* @param pVM The cross context VM structure.
1502	* @param pVCpu The cross context virtual CPU structure.
1503	* @param pRegFrame The register frame.
1504	*/
1505	VMM_INT_DECL(int) EMInterpretRdmsr(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1506	{
1507	NOREF(pVM);
1508
1509	/* Get the current privilege level. */
1510	if (CPUMGetGuestCPL(pVCpu) != 0)
1511	{
1512	Log4(("EM: Refuse RDMSR: CPL != 0\n"));
1513	return VERR_EM_INTERPRETER; /* supervisor only */
1514	}
1515
1516	uint64_t uValue;
1517	VBOXSTRICTRC rcStrict = CPUMQueryGuestMsr(pVCpu, pRegFrame->ecx, &uValue);
1518	if (RT_UNLIKELY(rcStrict != VINF_SUCCESS))
1519	{
1520	Log4(("EM: Refuse RDMSR: rc=%Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
1521	Assert(rcStrict == VERR_CPUM_RAISE_GP_0 \|\| rcStrict == VERR_EM_INTERPRETER \|\| rcStrict == VINF_CPUM_R3_MSR_READ);
1522	return VERR_EM_INTERPRETER;
1523	}
1524	pRegFrame->rax = (uint32_t) uValue;
1525	pRegFrame->rdx = (uint32_t)(uValue >> 32);
1526	LogFlow(("EMInterpretRdmsr %s (%x) -> %RX64\n", emMSRtoString(pRegFrame->ecx), pRegFrame->ecx, uValue));
1527	return VINF_SUCCESS;
1528	}
1529
1530
1531	/**
1532	* Interpret WRMSR
1533	*
1534	* @returns VBox status code.
1535	* @param pVM The cross context VM structure.
1536	* @param pVCpu The cross context virtual CPU structure.
1537	* @param pRegFrame The register frame.
1538	*/
1539	VMM_INT_DECL(int) EMInterpretWrmsr(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1540	{
1541	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1542
1543	/* Check the current privilege level, this instruction is supervisor only. */
1544	if (CPUMGetGuestCPL(pVCpu) != 0)
1545	{
1546	Log4(("EM: Refuse WRMSR: CPL != 0\n"));
1547	return VERR_EM_INTERPRETER; /** @todo raise \#GP(0) */
1548	}
1549
1550	VBOXSTRICTRC rcStrict = CPUMSetGuestMsr(pVCpu, pRegFrame->ecx, RT_MAKE_U64(pRegFrame->eax, pRegFrame->edx));
1551	if (rcStrict != VINF_SUCCESS)
1552	{
1553	Log4(("EM: Refuse WRMSR: CPUMSetGuestMsr returned %Rrc\n", VBOXSTRICTRC_VAL(rcStrict)));
1554	Assert(rcStrict == VERR_CPUM_RAISE_GP_0 \|\| rcStrict == VERR_EM_INTERPRETER \|\| rcStrict == VINF_CPUM_R3_MSR_WRITE);
1555	return VERR_EM_INTERPRETER;
1556	}
1557	LogFlow(("EMInterpretWrmsr %s (%x) val=%RX64\n", emMSRtoString(pRegFrame->ecx), pRegFrame->ecx,
1558	RT_MAKE_U64(pRegFrame->eax, pRegFrame->edx)));
1559	NOREF(pVM);
1560	return VINF_SUCCESS;
1561	}
1562
1563
1564	/**
1565	* Interpret DRx write.
1566	*
1567	* @returns VBox status code.
1568	* @param pVM The cross context VM structure.
1569	* @param pVCpu The cross context virtual CPU structure.
1570	* @param pRegFrame The register frame.
1571	* @param DestRegDrx DRx register index (USE_REG_DR*)
1572	* @param SrcRegGen General purpose register index (USE_REG_E**))
1573	*
1574	*/
1575	VMM_INT_DECL(int) EMInterpretDRxWrite(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegDrx, uint32_t SrcRegGen)
1576	{
1577	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1578	uint64_t uNewDrX;
1579	int rc;
1580	NOREF(pVM);
1581
1582	if (CPUMIsGuestIn64BitCode(pVCpu))
1583	rc = DISFetchReg64(pRegFrame, SrcRegGen, &uNewDrX);
1584	else
1585	{
1586	uint32_t val32;
1587	rc = DISFetchReg32(pRegFrame, SrcRegGen, &val32);
1588	uNewDrX = val32;
1589	}
1590
1591	if (RT_SUCCESS(rc))
1592	{
1593	if (DestRegDrx == 6)
1594	{
1595	uNewDrX \|= X86_DR6_RA1_MASK;
1596	uNewDrX &= ~X86_DR6_RAZ_MASK;
1597	}
1598	else if (DestRegDrx == 7)
1599	{
1600	uNewDrX \|= X86_DR7_RA1_MASK;
1601	uNewDrX &= ~X86_DR7_RAZ_MASK;
1602	}
1603
1604	/** @todo we don't fail if illegal bits are set/cleared for e.g. dr7 */
1605	rc = CPUMSetGuestDRx(pVCpu, DestRegDrx, uNewDrX);
1606	if (RT_SUCCESS(rc))
1607	return rc;
1608	AssertMsgFailed(("CPUMSetGuestDRx %d failed\n", DestRegDrx));
1609	}
1610	return VERR_EM_INTERPRETER;
1611	}
1612
1613
1614	/**
1615	* Interpret DRx read.
1616	*
1617	* @returns VBox status code.
1618	* @param pVM The cross context VM structure.
1619	* @param pVCpu The cross context virtual CPU structure.
1620	* @param pRegFrame The register frame.
1621	* @param DestRegGen General purpose register index (USE_REG_E**))
1622	* @param SrcRegDrx DRx register index (USE_REG_DR*)
1623	*/
1624	VMM_INT_DECL(int) EMInterpretDRxRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegGen, uint32_t SrcRegDrx)
1625	{
1626	uint64_t val64;
1627	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
1628	NOREF(pVM);
1629
1630	int rc = CPUMGetGuestDRx(pVCpu, SrcRegDrx, &val64);
1631	AssertMsgRCReturn(rc, ("CPUMGetGuestDRx %d failed\n", SrcRegDrx), VERR_EM_INTERPRETER);
1632	if (CPUMIsGuestIn64BitCode(pVCpu))
1633	rc = DISWriteReg64(pRegFrame, DestRegGen, val64);
1634	else
1635	rc = DISWriteReg32(pRegFrame, DestRegGen, (uint32_t)val64);
1636
1637	if (RT_SUCCESS(rc))
1638	return VINF_SUCCESS;
1639
1640	return VERR_EM_INTERPRETER;
1641	}
1642
1643
1644	#if !defined(VBOX_WITH_IEM) \|\| defined(VBOX_COMPARE_IEM_AND_EM)
1645
1646
1647
1648
1649
1650
1651	/*
1652	*
1653	* The old interpreter.
1654	* The old interpreter.
1655	* The old interpreter.
1656	* The old interpreter.
1657	* The old interpreter.
1658	*
1659	*/
1660
1661	DECLINLINE(int) emRamRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCPTR GCPtrSrc, uint32_t cb)
1662	{
1663	#ifdef IN_RC
1664	int rc = MMGCRamRead(pVM, pvDst, (void *)(uintptr_t)GCPtrSrc, cb);
1665	if (RT_LIKELY(rc != VERR_ACCESS_DENIED))
1666	return rc;
1667	/*
1668	* The page pool cache may end up here in some cases because it
1669	* flushed one of the shadow mappings used by the trapping
1670	* instruction and it either flushed the TLB or the CPU reused it.
1671	*/
1672	#else
1673	NOREF(pVM);
1674	#endif
1675	return PGMPhysInterpretedReadNoHandlers(pVCpu, pCtxCore, pvDst, GCPtrSrc, cb, /fMayTrap/ false);
1676	}
1677
1678
1679	DECLINLINE(int) emRamWrite(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, RTGCPTR GCPtrDst, const void *pvSrc, uint32_t cb)
1680	{
1681	/* Don't use MMGCRamWrite here as it does not respect zero pages, shared
1682	pages or write monitored pages. */
1683	NOREF(pVM);
1684	#if !defined(VBOX_COMPARE_IEM_AND_EM) \|\| !defined(VBOX_COMPARE_IEM_LAST)
1685	int rc = PGMPhysInterpretedWriteNoHandlers(pVCpu, pCtxCore, GCPtrDst, pvSrc, cb, /fMayTrap/ false);
1686	#else
1687	int rc = VINF_SUCCESS;
1688	#endif
1689	#ifdef VBOX_COMPARE_IEM_AND_EM
1690	Log(("EM Wrote: %RGv %.*Rhxs rc=%Rrc\n", GCPtrDst, RT_MAX(RT_MIN(cb, 64), 1), pvSrc, rc));
1691	g_cbEmWrote = cb;
1692	memcpy(g_abEmWrote, pvSrc, RT_MIN(cb, sizeof(g_abEmWrote)));
1693	#endif
1694	return rc;
1695	}
1696
1697
1698	/** Convert sel:addr to a flat GC address. */
1699	DECLINLINE(RTGCPTR) emConvertToFlatAddr(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pDis, PDISOPPARAM pParam, RTGCPTR pvAddr)
1700	{
1701	DISSELREG enmPrefixSeg = DISDetectSegReg(pDis, pParam);
1702	return SELMToFlat(pVM, enmPrefixSeg, pRegFrame, pvAddr);
1703	}
1704
1705
1706	#if defined(VBOX_STRICT) \|\| defined(LOG_ENABLED)
1707	/**
1708	* Get the mnemonic for the disassembled instruction.
1709	*
1710	* GC/R0 doesn't include the strings in the DIS tables because
1711	* of limited space.
1712	*/
1713	static const char *emGetMnemonic(PDISCPUSTATE pDis)
1714	{
1715	switch (pDis->pCurInstr->uOpcode)
1716	{
1717	case OP_XCHG: return "Xchg";
1718	case OP_DEC: return "Dec";
1719	case OP_INC: return "Inc";
1720	case OP_POP: return "Pop";
1721	case OP_OR: return "Or";
1722	case OP_AND: return "And";
1723	case OP_MOV: return "Mov";
1724	case OP_INVLPG: return "InvlPg";
1725	case OP_CPUID: return "CpuId";
1726	case OP_MOV_CR: return "MovCRx";
1727	case OP_MOV_DR: return "MovDRx";
1728	case OP_LLDT: return "LLdt";
1729	case OP_LGDT: return "LGdt";
1730	case OP_LIDT: return "LIdt";
1731	case OP_CLTS: return "Clts";
1732	case OP_MONITOR: return "Monitor";
1733	case OP_MWAIT: return "MWait";
1734	case OP_RDMSR: return "Rdmsr";
1735	case OP_WRMSR: return "Wrmsr";
1736	case OP_ADD: return "Add";
1737	case OP_ADC: return "Adc";
1738	case OP_SUB: return "Sub";
1739	case OP_SBB: return "Sbb";
1740	case OP_RDTSC: return "Rdtsc";
1741	case OP_STI: return "Sti";
1742	case OP_CLI: return "Cli";
1743	case OP_XADD: return "XAdd";
1744	case OP_HLT: return "Hlt";
1745	case OP_IRET: return "Iret";
1746	case OP_MOVNTPS: return "MovNTPS";
1747	case OP_STOSWD: return "StosWD";
1748	case OP_WBINVD: return "WbInvd";
1749	case OP_XOR: return "Xor";
1750	case OP_BTR: return "Btr";
1751	case OP_BTS: return "Bts";
1752	case OP_BTC: return "Btc";
1753	case OP_LMSW: return "Lmsw";
1754	case OP_SMSW: return "Smsw";
1755	case OP_CMPXCHG: return pDis->fPrefix & DISPREFIX_LOCK ? "Lock CmpXchg" : "CmpXchg";
1756	case OP_CMPXCHG8B: return pDis->fPrefix & DISPREFIX_LOCK ? "Lock CmpXchg8b" : "CmpXchg8b";
1757
1758	default:
1759	Log(("Unknown opcode %d\n", pDis->pCurInstr->uOpcode));
1760	return "???";
1761	}
1762	}
1763	#endif /* VBOX_STRICT \|\| LOG_ENABLED */
1764
1765
1766	/**
1767	* XCHG instruction emulation.
1768	*/
1769	static int emInterpretXchg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1770	{
1771	DISQPVPARAMVAL param1, param2;
1772	NOREF(pvFault);
1773
1774	/* Source to make DISQueryParamVal read the register value - ugly hack */
1775	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_SRC);
1776	if(RT_FAILURE(rc))
1777	return VERR_EM_INTERPRETER;
1778
1779	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param2, &param2, DISQPVWHICH_SRC);
1780	if(RT_FAILURE(rc))
1781	return VERR_EM_INTERPRETER;
1782
1783	#ifdef IN_RC
1784	if (TRPMHasTrap(pVCpu))
1785	{
1786	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1787	{
1788	#endif
1789	RTGCPTR pParam1 = 0, pParam2 = 0;
1790	uint64_t valpar1, valpar2;
1791
1792	AssertReturn(pDis->Param1.cb == pDis->Param2.cb, VERR_EM_INTERPRETER);
1793	switch(param1.type)
1794	{
1795	case DISQPV_TYPE_IMMEDIATE: /* register type is translated to this one too */
1796	valpar1 = param1.val.val64;
1797	break;
1798
1799	case DISQPV_TYPE_ADDRESS:
1800	pParam1 = (RTGCPTR)param1.val.val64;
1801	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, pParam1);
1802	EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
1803	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
1804	if (RT_FAILURE(rc))
1805	{
1806	AssertMsgFailed(("MMGCRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
1807	return VERR_EM_INTERPRETER;
1808	}
1809	break;
1810
1811	default:
1812	AssertFailed();
1813	return VERR_EM_INTERPRETER;
1814	}
1815
1816	switch(param2.type)
1817	{
1818	case DISQPV_TYPE_ADDRESS:
1819	pParam2 = (RTGCPTR)param2.val.val64;
1820	pParam2 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param2, pParam2);
1821	EM_ASSERT_FAULT_RETURN(pParam2 == pvFault, VERR_EM_INTERPRETER);
1822	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar2, pParam2, param2.size);
1823	if (RT_FAILURE(rc))
1824	{
1825	AssertMsgFailed(("MMGCRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
1826	}
1827	break;
1828
1829	case DISQPV_TYPE_IMMEDIATE:
1830	valpar2 = param2.val.val64;
1831	break;
1832
1833	default:
1834	AssertFailed();
1835	return VERR_EM_INTERPRETER;
1836	}
1837
1838	/* Write value of parameter 2 to parameter 1 (reg or memory address) */
1839	if (pParam1 == 0)
1840	{
1841	Assert(param1.type == DISQPV_TYPE_IMMEDIATE); /* register actually */
1842	switch(param1.size)
1843	{
1844	case 1: //special case for AH etc
1845	rc = DISWriteReg8(pRegFrame, pDis->Param1.Base.idxGenReg, (uint8_t )valpar2); break;
1846	case 2: rc = DISWriteReg16(pRegFrame, pDis->Param1.Base.idxGenReg, (uint16_t)valpar2); break;
1847	case 4: rc = DISWriteReg32(pRegFrame, pDis->Param1.Base.idxGenReg, (uint32_t)valpar2); break;
1848	case 8: rc = DISWriteReg64(pRegFrame, pDis->Param1.Base.idxGenReg, valpar2); break;
1849	default: AssertFailedReturn(VERR_EM_INTERPRETER);
1850	}
1851	if (RT_FAILURE(rc))
1852	return VERR_EM_INTERPRETER;
1853	}
1854	else
1855	{
1856	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar2, param1.size);
1857	if (RT_FAILURE(rc))
1858	{
1859	AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
1860	return VERR_EM_INTERPRETER;
1861	}
1862	}
1863
1864	/* Write value of parameter 1 to parameter 2 (reg or memory address) */
1865	if (pParam2 == 0)
1866	{
1867	Assert(param2.type == DISQPV_TYPE_IMMEDIATE); /* register actually */
1868	switch(param2.size)
1869	{
1870	case 1: //special case for AH etc
1871	rc = DISWriteReg8(pRegFrame, pDis->Param2.Base.idxGenReg, (uint8_t )valpar1); break;
1872	case 2: rc = DISWriteReg16(pRegFrame, pDis->Param2.Base.idxGenReg, (uint16_t)valpar1); break;
1873	case 4: rc = DISWriteReg32(pRegFrame, pDis->Param2.Base.idxGenReg, (uint32_t)valpar1); break;
1874	case 8: rc = DISWriteReg64(pRegFrame, pDis->Param2.Base.idxGenReg, valpar1); break;
1875	default: AssertFailedReturn(VERR_EM_INTERPRETER);
1876	}
1877	if (RT_FAILURE(rc))
1878	return VERR_EM_INTERPRETER;
1879	}
1880	else
1881	{
1882	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam2, &valpar1, param2.size);
1883	if (RT_FAILURE(rc))
1884	{
1885	AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
1886	return VERR_EM_INTERPRETER;
1887	}
1888	}
1889
1890	*pcbSize = param2.size;
1891	return VINF_SUCCESS;
1892	#ifdef IN_RC
1893	}
1894	}
1895	return VERR_EM_INTERPRETER;
1896	#endif
1897	}
1898
1899
1900	/**
1901	* INC and DEC emulation.
1902	*/
1903	static int emInterpretIncDec(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
1904	PFNEMULATEPARAM2 pfnEmulate)
1905	{
1906	DISQPVPARAMVAL param1;
1907	NOREF(pvFault);
1908
1909	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_DST);
1910	if(RT_FAILURE(rc))
1911	return VERR_EM_INTERPRETER;
1912
1913	#ifdef IN_RC
1914	if (TRPMHasTrap(pVCpu))
1915	{
1916	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1917	{
1918	#endif
1919	RTGCPTR pParam1 = 0;
1920	uint64_t valpar1;
1921
1922	if (param1.type == DISQPV_TYPE_ADDRESS)
1923	{
1924	pParam1 = (RTGCPTR)param1.val.val64;
1925	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, pParam1);
1926	#ifdef IN_RC
1927	/* Safety check (in theory it could cross a page boundary and fault there though) */
1928	EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
1929	#endif
1930	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
1931	if (RT_FAILURE(rc))
1932	{
1933	AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
1934	return VERR_EM_INTERPRETER;
1935	}
1936	}
1937	else
1938	{
1939	AssertFailed();
1940	return VERR_EM_INTERPRETER;
1941	}
1942
1943	uint32_t eflags;
1944
1945	eflags = pfnEmulate(&valpar1, param1.size);
1946
1947	/* Write result back */
1948	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
1949	if (RT_FAILURE(rc))
1950	{
1951	AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
1952	return VERR_EM_INTERPRETER;
1953	}
1954
1955	/* Update guest's eflags and finish. */
1956	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
1957	\| (eflags & (X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
1958
1959	/* All done! */
1960	*pcbSize = param1.size;
1961	return VINF_SUCCESS;
1962	#ifdef IN_RC
1963	}
1964	}
1965	return VERR_EM_INTERPRETER;
1966	#endif
1967	}
1968
1969
1970	/**
1971	* POP Emulation.
1972	*/
1973	static int emInterpretPop(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1974	{
1975	Assert(pDis->uCpuMode != DISCPUMODE_64BIT); /** @todo check */
1976	DISQPVPARAMVAL param1;
1977	NOREF(pvFault);
1978
1979	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_DST);
1980	if(RT_FAILURE(rc))
1981	return VERR_EM_INTERPRETER;
1982
1983	#ifdef IN_RC
1984	if (TRPMHasTrap(pVCpu))
1985	{
1986	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1987	{
1988	#endif
1989	RTGCPTR pParam1 = 0;
1990	uint32_t valpar1;
1991	RTGCPTR pStackVal;
1992
1993	/* Read stack value first */
1994	if (CPUMGetGuestCodeBits(pVCpu) == 16)
1995	return VERR_EM_INTERPRETER; /* No legacy 16 bits stuff here, please. */
1996
1997	/* Convert address; don't bother checking limits etc, as we only read here */
1998	pStackVal = SELMToFlat(pVM, DISSELREG_SS, pRegFrame, (RTGCPTR)pRegFrame->esp);
1999	if (pStackVal == 0)
2000	return VERR_EM_INTERPRETER;
2001
2002	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pStackVal, param1.size);
2003	if (RT_FAILURE(rc))
2004	{
2005	AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
2006	return VERR_EM_INTERPRETER;
2007	}
2008
2009	if (param1.type == DISQPV_TYPE_ADDRESS)
2010	{
2011	pParam1 = (RTGCPTR)param1.val.val64;
2012
2013	/* pop [esp+xx] uses esp after the actual pop! */
2014	AssertCompile(DISGREG_ESP == DISGREG_SP);
2015	if ( (pDis->Param1.fUse & DISUSE_BASE)
2016	&& (pDis->Param1.fUse & (DISUSE_REG_GEN16\|DISUSE_REG_GEN32))
2017	&& pDis->Param1.Base.idxGenReg == DISGREG_ESP
2018	)
2019	pParam1 = (RTGCPTR)((RTGCUINTPTR)pParam1 + param1.size);
2020
2021	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, pParam1);
2022	EM_ASSERT_FAULT_RETURN(pParam1 == pvFault \|\| (RTGCPTR)pRegFrame->esp == pvFault, VERR_EM_INTERPRETER);
2023	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
2024	if (RT_FAILURE(rc))
2025	{
2026	AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
2027	return VERR_EM_INTERPRETER;
2028	}
2029
2030	/* Update ESP as the last step */
2031	pRegFrame->esp += param1.size;
2032	}
2033	else
2034	{
2035	#ifndef DEBUG_bird // annoying assertion.
2036	AssertFailed();
2037	#endif
2038	return VERR_EM_INTERPRETER;
2039	}
2040
2041	/* All done! */
2042	*pcbSize = param1.size;
2043	return VINF_SUCCESS;
2044	#ifdef IN_RC
2045	}
2046	}
2047	return VERR_EM_INTERPRETER;
2048	#endif
2049	}
2050
2051
2052	/**
2053	* XOR/OR/AND Emulation.
2054	*/
2055	static int emInterpretOrXorAnd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
2056	PFNEMULATEPARAM3 pfnEmulate)
2057	{
2058	DISQPVPARAMVAL param1, param2;
2059	NOREF(pvFault);
2060
2061	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_DST);
2062	if(RT_FAILURE(rc))
2063	return VERR_EM_INTERPRETER;
2064
2065	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param2, &param2, DISQPVWHICH_SRC);
2066	if(RT_FAILURE(rc))
2067	return VERR_EM_INTERPRETER;
2068
2069	#ifdef IN_RC
2070	if (TRPMHasTrap(pVCpu))
2071	{
2072	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
2073	{
2074	#endif
2075	RTGCPTR pParam1;
2076	uint64_t valpar1, valpar2;
2077
2078	if (pDis->Param1.cb != pDis->Param2.cb)
2079	{
2080	if (pDis->Param1.cb < pDis->Param2.cb)
2081	{
2082	AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->Param1.cb, pDis->Param2.cb)); /* should never happen! */
2083	return VERR_EM_INTERPRETER;
2084	}
2085	/* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
2086	pDis->Param2.cb = pDis->Param1.cb;
2087	param2.size = param1.size;
2088	}
2089
2090	/* The destination is always a virtual address */
2091	if (param1.type == DISQPV_TYPE_ADDRESS)
2092	{
2093	pParam1 = (RTGCPTR)param1.val.val64;
2094	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, pParam1);
2095	EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
2096	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
2097	if (RT_FAILURE(rc))
2098	{
2099	AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
2100	return VERR_EM_INTERPRETER;
2101	}
2102	}
2103	else
2104	{
2105	AssertFailed();
2106	return VERR_EM_INTERPRETER;
2107	}
2108
2109	/* Register or immediate data */
2110	switch(param2.type)
2111	{
2112	case DISQPV_TYPE_IMMEDIATE: /* both immediate data and register (ugly) */
2113	valpar2 = param2.val.val64;
2114	break;
2115
2116	default:
2117	AssertFailed();
2118	return VERR_EM_INTERPRETER;
2119	}
2120
2121	LogFlow(("emInterpretOrXorAnd %s %RGv %RX64 - %RX64 size %d (%d)\n", emGetMnemonic(pDis), pParam1, valpar1, valpar2, param2.size, param1.size));
2122
2123	/* Data read, emulate instruction. */
2124	uint32_t eflags = pfnEmulate(&valpar1, valpar2, param2.size);
2125
2126	LogFlow(("emInterpretOrXorAnd %s result %RX64\n", emGetMnemonic(pDis), valpar1));
2127
2128	/* Update guest's eflags and finish. */
2129	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
2130	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
2131
2132	/* And write it back */
2133	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
2134	if (RT_SUCCESS(rc))
2135	{
2136	/* All done! */
2137	*pcbSize = param2.size;
2138	return VINF_SUCCESS;
2139	}
2140	#ifdef IN_RC
2141	}
2142	}
2143	#endif
2144	return VERR_EM_INTERPRETER;
2145	}
2146
2147
2148	#ifndef VBOX_COMPARE_IEM_AND_EM
2149	/**
2150	* LOCK XOR/OR/AND Emulation.
2151	*/
2152	static int emInterpretLockOrXorAnd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
2153	uint32_t *pcbSize, PFNEMULATELOCKPARAM3 pfnEmulate)
2154	{
2155	void *pvParam1;
2156	DISQPVPARAMVAL param1, param2;
2157	NOREF(pvFault);
2158
2159	#if HC_ARCH_BITS == 32
2160	Assert(pDis->Param1.cb <= 4);
2161	#endif
2162
2163	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_DST);
2164	if(RT_FAILURE(rc))
2165	return VERR_EM_INTERPRETER;
2166
2167	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param2, &param2, DISQPVWHICH_SRC);
2168	if(RT_FAILURE(rc))
2169	return VERR_EM_INTERPRETER;
2170
2171	if (pDis->Param1.cb != pDis->Param2.cb)
2172	{
2173	AssertMsgReturn(pDis->Param1.cb >= pDis->Param2.cb, /* should never happen! */
2174	("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->Param1.cb, pDis->Param2.cb),
2175	VERR_EM_INTERPRETER);
2176
2177	/* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
2178	pDis->Param2.cb = pDis->Param1.cb;
2179	param2.size = param1.size;
2180	}
2181
2182	#ifdef IN_RC
2183	/* Safety check (in theory it could cross a page boundary and fault there though) */
2184	Assert( TRPMHasTrap(pVCpu)
2185	&& (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW));
2186	EM_ASSERT_FAULT_RETURN(GCPtrPar1 == pvFault, VERR_EM_INTERPRETER);
2187	#endif
2188
2189	/* Register and immediate data == DISQPV_TYPE_IMMEDIATE */
2190	AssertReturn(param2.type == DISQPV_TYPE_IMMEDIATE, VERR_EM_INTERPRETER);
2191	RTGCUINTREG ValPar2 = param2.val.val64;
2192
2193	/* The destination is always a virtual address */
2194	AssertReturn(param1.type == DISQPV_TYPE_ADDRESS, VERR_EM_INTERPRETER);
2195
2196	RTGCPTR GCPtrPar1 = param1.val.val64;
2197	GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, GCPtrPar1);
2198	PGMPAGEMAPLOCK Lock;
2199	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
2200	AssertRCReturn(rc, VERR_EM_INTERPRETER);
2201
2202	/* Try emulate it with a one-shot #PF handler in place. (RC) */
2203	Log2(("%s %RGv imm%d=%RX64\n", emGetMnemonic(pDis), GCPtrPar1, pDis->Param2.cb*8, ValPar2));
2204
2205	RTGCUINTREG32 eflags = 0;
2206	rc = pfnEmulate(pvParam1, ValPar2, pDis->Param2.cb, &eflags);
2207	PGMPhysReleasePageMappingLock(pVM, &Lock);
2208	if (RT_FAILURE(rc))
2209	{
2210	Log(("%s %RGv imm%d=%RX64-> emulation failed due to page fault!\n", emGetMnemonic(pDis), GCPtrPar1, pDis->Param2.cb*8, ValPar2));
2211	return VERR_EM_INTERPRETER;
2212	}
2213
2214	/* Update guest's eflags and finish. */
2215	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
2216	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
2217
2218	*pcbSize = param2.size;
2219	return VINF_SUCCESS;
2220	}
2221	#endif /* !VBOX_COMPARE_IEM_AND_EM */
2222
2223
2224	/**
2225	* ADD, ADC & SUB Emulation.
2226	*/
2227	static int emInterpretAddSub(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
2228	PFNEMULATEPARAM3 pfnEmulate)
2229	{
2230	NOREF(pvFault);
2231	DISQPVPARAMVAL param1, param2;
2232	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_DST);
2233	if(RT_FAILURE(rc))
2234	return VERR_EM_INTERPRETER;
2235
2236	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param2, &param2, DISQPVWHICH_SRC);
2237	if(RT_FAILURE(rc))
2238	return VERR_EM_INTERPRETER;
2239
2240	#ifdef IN_RC
2241	if (TRPMHasTrap(pVCpu))
2242	{
2243	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
2244	{
2245	#endif
2246	RTGCPTR pParam1;
2247	uint64_t valpar1, valpar2;
2248
2249	if (pDis->Param1.cb != pDis->Param2.cb)
2250	{
2251	if (pDis->Param1.cb < pDis->Param2.cb)
2252	{
2253	AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->Param1.cb, pDis->Param2.cb)); /* should never happen! */
2254	return VERR_EM_INTERPRETER;
2255	}
2256	/* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
2257	pDis->Param2.cb = pDis->Param1.cb;
2258	param2.size = param1.size;
2259	}
2260
2261	/* The destination is always a virtual address */
2262	if (param1.type == DISQPV_TYPE_ADDRESS)
2263	{
2264	pParam1 = (RTGCPTR)param1.val.val64;
2265	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, pParam1);
2266	EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
2267	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
2268	if (RT_FAILURE(rc))
2269	{
2270	AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
2271	return VERR_EM_INTERPRETER;
2272	}
2273	}
2274	else
2275	{
2276	#ifndef DEBUG_bird
2277	AssertFailed();
2278	#endif
2279	return VERR_EM_INTERPRETER;
2280	}
2281
2282	/* Register or immediate data */
2283	switch(param2.type)
2284	{
2285	case DISQPV_TYPE_IMMEDIATE: /* both immediate data and register (ugly) */
2286	valpar2 = param2.val.val64;
2287	break;
2288
2289	default:
2290	AssertFailed();
2291	return VERR_EM_INTERPRETER;
2292	}
2293
2294	/* Data read, emulate instruction. */
2295	uint32_t eflags = pfnEmulate(&valpar1, valpar2, param2.size);
2296
2297	/* Update guest's eflags and finish. */
2298	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
2299	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
2300
2301	/* And write it back */
2302	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
2303	if (RT_SUCCESS(rc))
2304	{
2305	/* All done! */
2306	*pcbSize = param2.size;
2307	return VINF_SUCCESS;
2308	}
2309	#ifdef IN_RC
2310	}
2311	}
2312	#endif
2313	return VERR_EM_INTERPRETER;
2314	}
2315
2316
2317	/**
2318	* ADC Emulation.
2319	*/
2320	static int emInterpretAdc(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2321	{
2322	if (pRegFrame->eflags.Bits.u1CF)
2323	return emInterpretAddSub(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, EMEmulateAdcWithCarrySet);
2324	else
2325	return emInterpretAddSub(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, EMEmulateAdd);
2326	}
2327
2328
2329	/**
2330	* BTR/C/S Emulation.
2331	*/
2332	static int emInterpretBitTest(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
2333	PFNEMULATEPARAM2UINT32 pfnEmulate)
2334	{
2335	DISQPVPARAMVAL param1, param2;
2336	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_DST);
2337	if(RT_FAILURE(rc))
2338	return VERR_EM_INTERPRETER;
2339
2340	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param2, &param2, DISQPVWHICH_SRC);
2341	if(RT_FAILURE(rc))
2342	return VERR_EM_INTERPRETER;
2343
2344	#ifdef IN_RC
2345	if (TRPMHasTrap(pVCpu))
2346	{
2347	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
2348	{
2349	#endif
2350	RTGCPTR pParam1;
2351	uint64_t valpar1 = 0, valpar2;
2352	uint32_t eflags;
2353
2354	/* The destination is always a virtual address */
2355	if (param1.type != DISQPV_TYPE_ADDRESS)
2356	return VERR_EM_INTERPRETER;
2357
2358	pParam1 = (RTGCPTR)param1.val.val64;
2359	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, pParam1);
2360
2361	/* Register or immediate data */
2362	switch(param2.type)
2363	{
2364	case DISQPV_TYPE_IMMEDIATE: /* both immediate data and register (ugly) */
2365	valpar2 = param2.val.val64;
2366	break;
2367
2368	default:
2369	AssertFailed();
2370	return VERR_EM_INTERPRETER;
2371	}
2372
2373	Log2(("emInterpret%s: pvFault=%RGv pParam1=%RGv val2=%x\n", emGetMnemonic(pDis), pvFault, pParam1, valpar2));
2374	pParam1 = (RTGCPTR)((RTGCUINTPTR)pParam1 + valpar2/8);
2375	EM_ASSERT_FAULT_RETURN((RTGCPTR)((RTGCUINTPTR)pParam1 & ~3) == pvFault, VERR_EM_INTERPRETER); NOREF(pvFault);
2376	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, 1);
2377	if (RT_FAILURE(rc))
2378	{
2379	AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
2380	return VERR_EM_INTERPRETER;
2381	}
2382
2383	Log2(("emInterpretBtx: val=%x\n", valpar1));
2384	/* Data read, emulate bit test instruction. */
2385	eflags = pfnEmulate(&valpar1, valpar2 & 0x7);
2386
2387	Log2(("emInterpretBtx: val=%x CF=%d\n", valpar1, !!(eflags & X86_EFL_CF)));
2388
2389	/* Update guest's eflags and finish. */
2390	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
2391	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
2392
2393	/* And write it back */
2394	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, 1);
2395	if (RT_SUCCESS(rc))
2396	{
2397	/* All done! */
2398	*pcbSize = 1;
2399	return VINF_SUCCESS;
2400	}
2401	#ifdef IN_RC
2402	}
2403	}
2404	#endif
2405	return VERR_EM_INTERPRETER;
2406	}
2407
2408
2409	#ifndef VBOX_COMPARE_IEM_AND_EM
2410	/**
2411	* LOCK BTR/C/S Emulation.
2412	*/
2413	static int emInterpretLockBitTest(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
2414	uint32_t *pcbSize, PFNEMULATELOCKPARAM2 pfnEmulate)
2415	{
2416	void *pvParam1;
2417
2418	DISQPVPARAMVAL param1, param2;
2419	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_DST);
2420	if(RT_FAILURE(rc))
2421	return VERR_EM_INTERPRETER;
2422
2423	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param2, &param2, DISQPVWHICH_SRC);
2424	if(RT_FAILURE(rc))
2425	return VERR_EM_INTERPRETER;
2426
2427	/* The destination is always a virtual address */
2428	if (param1.type != DISQPV_TYPE_ADDRESS)
2429	return VERR_EM_INTERPRETER;
2430
2431	/* Register and immediate data == DISQPV_TYPE_IMMEDIATE */
2432	AssertReturn(param2.type == DISQPV_TYPE_IMMEDIATE, VERR_EM_INTERPRETER);
2433	uint64_t ValPar2 = param2.val.val64;
2434
2435	/* Adjust the parameters so what we're dealing with is a bit within the byte pointed to. */
2436	RTGCPTR GCPtrPar1 = param1.val.val64;
2437	GCPtrPar1 = (GCPtrPar1 + ValPar2 / 8);
2438	ValPar2 &= 7;
2439
2440	GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, GCPtrPar1);
2441	#ifdef IN_RC
2442	Assert(TRPMHasTrap(pVCpu));
2443	EM_ASSERT_FAULT_RETURN((RTGCPTR)((RTGCUINTPTR)GCPtrPar1 & ~(RTGCUINTPTR)3) == pvFault, VERR_EM_INTERPRETER);
2444	#endif
2445
2446	PGMPAGEMAPLOCK Lock;
2447	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
2448	AssertRCReturn(rc, VERR_EM_INTERPRETER);
2449
2450	Log2(("emInterpretLockBitTest %s: pvFault=%RGv GCPtrPar1=%RGv imm=%RX64\n", emGetMnemonic(pDis), pvFault, GCPtrPar1, ValPar2));
2451	NOREF(pvFault);
2452
2453	/* Try emulate it with a one-shot #PF handler in place. (RC) */
2454	RTGCUINTREG32 eflags = 0;
2455	rc = pfnEmulate(pvParam1, ValPar2, &eflags);
2456	PGMPhysReleasePageMappingLock(pVM, &Lock);
2457	if (RT_FAILURE(rc))
2458	{
2459	Log(("emInterpretLockBitTest %s: %RGv imm%d=%RX64 -> emulation failed due to page fault!\n",
2460	emGetMnemonic(pDis), GCPtrPar1, pDis->Param2.cb*8, ValPar2));
2461	return VERR_EM_INTERPRETER;
2462	}
2463
2464	Log2(("emInterpretLockBitTest %s: GCPtrPar1=%RGv imm=%RX64 CF=%d\n", emGetMnemonic(pDis), GCPtrPar1, ValPar2, !!(eflags & X86_EFL_CF)));
2465
2466	/* Update guest's eflags and finish. */
2467	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
2468	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
2469
2470	*pcbSize = 1;
2471	return VINF_SUCCESS;
2472	}
2473	#endif /* !VBOX_COMPARE_IEM_AND_EM */
2474
2475
2476	/**
2477	* MOV emulation.
2478	*/
2479	static int emInterpretMov(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2480	{
2481	NOREF(pvFault);
2482	DISQPVPARAMVAL param1, param2;
2483	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_DST);
2484	if(RT_FAILURE(rc))
2485	return VERR_EM_INTERPRETER;
2486
2487	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param2, &param2, DISQPVWHICH_SRC);
2488	if(RT_FAILURE(rc))
2489	return VERR_EM_INTERPRETER;
2490
2491	/* If destination is a segment register, punt. We can't handle it here.
2492	* NB: Source can be a register and still trigger a #PF!
2493	*/
2494	if (RT_UNLIKELY(pDis->Param1.fUse == DISUSE_REG_SEG))
2495	return VERR_EM_INTERPRETER;
2496
2497	if (param1.type == DISQPV_TYPE_ADDRESS)
2498	{
2499	RTGCPTR pDest;
2500	uint64_t val64;
2501
2502	switch(param1.type)
2503	{
2504	case DISQPV_TYPE_IMMEDIATE:
2505	if(!(param1.flags & (DISQPV_FLAG_32\|DISQPV_FLAG_64)))
2506	return VERR_EM_INTERPRETER;
2507	/* fallthru */
2508
2509	case DISQPV_TYPE_ADDRESS:
2510	pDest = (RTGCPTR)param1.val.val64;
2511	pDest = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, pDest);
2512	break;
2513
2514	default:
2515	AssertFailed();
2516	return VERR_EM_INTERPRETER;
2517	}
2518
2519	switch(param2.type)
2520	{
2521	case DISQPV_TYPE_IMMEDIATE: /* register type is translated to this one too */
2522	val64 = param2.val.val64;
2523	break;
2524
2525	default:
2526	Log(("emInterpretMov: unexpected type=%d rip=%RGv\n", param2.type, (RTGCPTR)pRegFrame->rip));
2527	return VERR_EM_INTERPRETER;
2528	}
2529	#ifdef LOG_ENABLED
2530	if (pDis->uCpuMode == DISCPUMODE_64BIT)
2531	LogFlow(("EMInterpretInstruction at %RGv: OP_MOV %RGv <- %RX64 (%d) &val64=%RHv\n", (RTGCPTR)pRegFrame->rip, pDest, val64, param2.size, &val64));
2532	else
2533	LogFlow(("EMInterpretInstruction at %08RX64: OP_MOV %RGv <- %08X (%d) &val64=%RHv\n", pRegFrame->rip, pDest, (uint32_t)val64, param2.size, &val64));
2534	#endif
2535
2536	Assert(param2.size <= 8 && param2.size > 0);
2537	EM_ASSERT_FAULT_RETURN(pDest == pvFault, VERR_EM_INTERPRETER);
2538	rc = emRamWrite(pVM, pVCpu, pRegFrame, pDest, &val64, param2.size);
2539	if (RT_FAILURE(rc))
2540	return VERR_EM_INTERPRETER;
2541
2542	*pcbSize = param2.size;
2543	}
2544	#if defined(IN_RC) && defined(VBOX_WITH_RAW_RING1)
2545	/* mov xx, cs instruction is dangerous in raw mode and replaced by an 'int3' by csam/patm. */
2546	else if ( param1.type == DISQPV_TYPE_REGISTER
2547	&& param2.type == DISQPV_TYPE_REGISTER)
2548	{
2549	AssertReturn((pDis->Param1.fUse & (DISUSE_REG_GEN8\|DISUSE_REG_GEN16\|DISUSE_REG_GEN32)), VERR_EM_INTERPRETER);
2550	AssertReturn(pDis->Param2.fUse == DISUSE_REG_SEG, VERR_EM_INTERPRETER);
2551	AssertReturn(pDis->Param2.Base.idxSegReg == DISSELREG_CS, VERR_EM_INTERPRETER);
2552
2553	uint32_t u32Cpl = CPUMRCGetGuestCPL(pVCpu, pRegFrame);
2554	uint32_t uValCS = (pRegFrame->cs.Sel & ~X86_SEL_RPL) \| u32Cpl;
2555
2556	Log(("EMInterpretInstruction: OP_MOV cs=%x->%x\n", pRegFrame->cs.Sel, uValCS));
2557	switch (param1.size)
2558	{
2559	case 1: rc = DISWriteReg8(pRegFrame, pDis->Param1.Base.idxGenReg, (uint8_t) uValCS); break;
2560	case 2: rc = DISWriteReg16(pRegFrame, pDis->Param1.Base.idxGenReg, (uint16_t)uValCS); break;
2561	case 4: rc = DISWriteReg32(pRegFrame, pDis->Param1.Base.idxGenReg, (uint32_t)uValCS); break;
2562	default:
2563	AssertFailed();
2564	return VERR_EM_INTERPRETER;
2565	}
2566	AssertRCReturn(rc, rc);
2567	}
2568	#endif
2569	else
2570	{ /* read fault */
2571	RTGCPTR pSrc;
2572	uint64_t val64;
2573
2574	/* Source */
2575	switch(param2.type)
2576	{
2577	case DISQPV_TYPE_IMMEDIATE:
2578	if(!(param2.flags & (DISQPV_FLAG_32\|DISQPV_FLAG_64)))
2579	return VERR_EM_INTERPRETER;
2580	/* fallthru */
2581
2582	case DISQPV_TYPE_ADDRESS:
2583	pSrc = (RTGCPTR)param2.val.val64;
2584	pSrc = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param2, pSrc);
2585	break;
2586
2587	default:
2588	return VERR_EM_INTERPRETER;
2589	}
2590
2591	Assert(param1.size <= 8 && param1.size > 0);
2592	EM_ASSERT_FAULT_RETURN(pSrc == pvFault, VERR_EM_INTERPRETER);
2593	rc = emRamRead(pVM, pVCpu, pRegFrame, &val64, pSrc, param1.size);
2594	if (RT_FAILURE(rc))
2595	return VERR_EM_INTERPRETER;
2596
2597	/* Destination */
2598	switch(param1.type)
2599	{
2600	case DISQPV_TYPE_REGISTER:
2601	switch(param1.size)
2602	{
2603	case 1: rc = DISWriteReg8(pRegFrame, pDis->Param1.Base.idxGenReg, (uint8_t) val64); break;
2604	case 2: rc = DISWriteReg16(pRegFrame, pDis->Param1.Base.idxGenReg, (uint16_t)val64); break;
2605	case 4: rc = DISWriteReg32(pRegFrame, pDis->Param1.Base.idxGenReg, (uint32_t)val64); break;
2606	case 8: rc = DISWriteReg64(pRegFrame, pDis->Param1.Base.idxGenReg, val64); break;
2607	default:
2608	return VERR_EM_INTERPRETER;
2609	}
2610	if (RT_FAILURE(rc))
2611	return rc;
2612	break;
2613
2614	default:
2615	return VERR_EM_INTERPRETER;
2616	}
2617	#ifdef LOG_ENABLED
2618	if (pDis->uCpuMode == DISCPUMODE_64BIT)
2619	LogFlow(("EMInterpretInstruction: OP_MOV %RGv -> %RX64 (%d)\n", pSrc, val64, param1.size));
2620	else
2621	LogFlow(("EMInterpretInstruction: OP_MOV %RGv -> %08X (%d)\n", pSrc, (uint32_t)val64, param1.size));
2622	#endif
2623	}
2624	return VINF_SUCCESS;
2625	}
2626
2627
2628	#ifndef IN_RC
2629	/**
2630	* [REP] STOSWD emulation
2631	*/
2632	static int emInterpretStosWD(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2633	{
2634	int rc;
2635	RTGCPTR GCDest, GCOffset;
2636	uint32_t cbSize;
2637	uint64_t cTransfers;
2638	int offIncrement;
2639	NOREF(pvFault);
2640
2641	/* Don't support any but these three prefix bytes. */
2642	if ((pDis->fPrefix & ~(DISPREFIX_ADDRSIZE\|DISPREFIX_OPSIZE\|DISPREFIX_REP\|DISPREFIX_REX)))
2643	return VERR_EM_INTERPRETER;
2644
2645	switch (pDis->uAddrMode)
2646	{
2647	case DISCPUMODE_16BIT:
2648	GCOffset = pRegFrame->di;
2649	cTransfers = pRegFrame->cx;
2650	break;
2651	case DISCPUMODE_32BIT:
2652	GCOffset = pRegFrame->edi;
2653	cTransfers = pRegFrame->ecx;
2654	break;
2655	case DISCPUMODE_64BIT:
2656	GCOffset = pRegFrame->rdi;
2657	cTransfers = pRegFrame->rcx;
2658	break;
2659	default:
2660	AssertFailed();
2661	return VERR_EM_INTERPRETER;
2662	}
2663
2664	GCDest = SELMToFlat(pVM, DISSELREG_ES, pRegFrame, GCOffset);
2665	switch (pDis->uOpMode)
2666	{
2667	case DISCPUMODE_16BIT:
2668	cbSize = 2;
2669	break;
2670	case DISCPUMODE_32BIT:
2671	cbSize = 4;
2672	break;
2673	case DISCPUMODE_64BIT:
2674	cbSize = 8;
2675	break;
2676	default:
2677	AssertFailed();
2678	return VERR_EM_INTERPRETER;
2679	}
2680
2681	offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
2682
2683	if (!(pDis->fPrefix & DISPREFIX_REP))
2684	{
2685	LogFlow(("emInterpretStosWD dest=%04X:%RGv (%RGv) cbSize=%d\n", pRegFrame->es.Sel, GCOffset, GCDest, cbSize));
2686
2687	rc = emRamWrite(pVM, pVCpu, pRegFrame, GCDest, &pRegFrame->rax, cbSize);
2688	if (RT_FAILURE(rc))
2689	return VERR_EM_INTERPRETER;
2690	Assert(rc == VINF_SUCCESS);
2691
2692	/* Update (e/r)di. */
2693	switch (pDis->uAddrMode)
2694	{
2695	case DISCPUMODE_16BIT:
2696	pRegFrame->di += offIncrement;
2697	break;
2698	case DISCPUMODE_32BIT:
2699	pRegFrame->edi += offIncrement;
2700	break;
2701	case DISCPUMODE_64BIT:
2702	pRegFrame->rdi += offIncrement;
2703	break;
2704	default:
2705	AssertFailed();
2706	return VERR_EM_INTERPRETER;
2707	}
2708
2709	}
2710	else
2711	{
2712	if (!cTransfers)
2713	return VINF_SUCCESS;
2714
2715	/*
2716	* Do not try emulate cross page stuff here because we don't know what might
2717	* be waiting for us on the subsequent pages. The caller has only asked us to
2718	* ignore access handlers fro the current page.
2719	* This also fends off big stores which would quickly kill PGMR0DynMap.
2720	*/
2721	if ( cbSize > PAGE_SIZE
2722	\|\| cTransfers > PAGE_SIZE
2723	\|\| (GCDest >> PAGE_SHIFT) != ((GCDest + offIncrement * cTransfers) >> PAGE_SHIFT))
2724	{
2725	Log(("STOSWD is crosses pages, chicken out to the recompiler; GCDest=%RGv cbSize=%#x offIncrement=%d cTransfers=%#x\n",
2726	GCDest, cbSize, offIncrement, cTransfers));
2727	return VERR_EM_INTERPRETER;
2728	}
2729
2730	LogFlow(("emInterpretStosWD dest=%04X:%RGv (%RGv) cbSize=%d cTransfers=%x DF=%d\n", pRegFrame->es.Sel, GCOffset, GCDest, cbSize, cTransfers, pRegFrame->eflags.Bits.u1DF));
2731	/* Access verification first; we currently can't recover properly from traps inside this instruction */
2732	rc = PGMVerifyAccess(pVCpu, GCDest - ((offIncrement > 0) ? 0 : ((cTransfers-1) * cbSize)),
2733	cTransfers * cbSize,
2734	X86_PTE_RW \| (CPUMGetGuestCPL(pVCpu) == 3 ? X86_PTE_US : 0));
2735	if (rc != VINF_SUCCESS)
2736	{
2737	Log(("STOSWD will generate a trap -> recompiler, rc=%d\n", rc));
2738	return VERR_EM_INTERPRETER;
2739	}
2740
2741	/* REP case */
2742	while (cTransfers)
2743	{
2744	rc = emRamWrite(pVM, pVCpu, pRegFrame, GCDest, &pRegFrame->rax, cbSize);
2745	if (RT_FAILURE(rc))
2746	{
2747	rc = VERR_EM_INTERPRETER;
2748	break;
2749	}
2750
2751	Assert(rc == VINF_SUCCESS);
2752	GCOffset += offIncrement;
2753	GCDest += offIncrement;
2754	cTransfers--;
2755	}
2756
2757	/* Update the registers. */
2758	switch (pDis->uAddrMode)
2759	{
2760	case DISCPUMODE_16BIT:
2761	pRegFrame->di = GCOffset;
2762	pRegFrame->cx = cTransfers;
2763	break;
2764	case DISCPUMODE_32BIT:
2765	pRegFrame->edi = GCOffset;
2766	pRegFrame->ecx = cTransfers;
2767	break;
2768	case DISCPUMODE_64BIT:
2769	pRegFrame->rdi = GCOffset;
2770	pRegFrame->rcx = cTransfers;
2771	break;
2772	default:
2773	AssertFailed();
2774	return VERR_EM_INTERPRETER;
2775	}
2776	}
2777
2778	*pcbSize = cbSize;
2779	return rc;
2780	}
2781	#endif /* !IN_RC */
2782
2783
2784	/**
2785	* [LOCK] CMPXCHG emulation.
2786	*/
2787	static int emInterpretCmpXchg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2788	{
2789	DISQPVPARAMVAL param1, param2;
2790	NOREF(pvFault);
2791
2792	#if HC_ARCH_BITS == 32
2793	Assert(pDis->Param1.cb <= 4);
2794	#endif
2795
2796	/* Source to make DISQueryParamVal read the register value - ugly hack */
2797	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_SRC);
2798	if(RT_FAILURE(rc))
2799	return VERR_EM_INTERPRETER;
2800
2801	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param2, &param2, DISQPVWHICH_SRC);
2802	if(RT_FAILURE(rc))
2803	return VERR_EM_INTERPRETER;
2804
2805	uint64_t valpar;
2806	switch(param2.type)
2807	{
2808	case DISQPV_TYPE_IMMEDIATE: /* register actually */
2809	valpar = param2.val.val64;
2810	break;
2811
2812	default:
2813	return VERR_EM_INTERPRETER;
2814	}
2815
2816	PGMPAGEMAPLOCK Lock;
2817	RTGCPTR GCPtrPar1;
2818	void *pvParam1;
2819	uint64_t eflags;
2820
2821	AssertReturn(pDis->Param1.cb == pDis->Param2.cb, VERR_EM_INTERPRETER);
2822	switch(param1.type)
2823	{
2824	case DISQPV_TYPE_ADDRESS:
2825	GCPtrPar1 = param1.val.val64;
2826	GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, GCPtrPar1);
2827
2828	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
2829	AssertRCReturn(rc, VERR_EM_INTERPRETER);
2830	break;
2831
2832	default:
2833	return VERR_EM_INTERPRETER;
2834	}
2835
2836	LogFlow(("%s %RGv rax=%RX64 %RX64\n", emGetMnemonic(pDis), GCPtrPar1, pRegFrame->rax, valpar));
2837
2838	#ifndef VBOX_COMPARE_IEM_AND_EM
2839	if (pDis->fPrefix & DISPREFIX_LOCK)
2840	eflags = EMEmulateLockCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->Param2.cb);
2841	else
2842	eflags = EMEmulateCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->Param2.cb);
2843	#else /* VBOX_COMPARE_IEM_AND_EM */
2844	uint64_t u64;
2845	switch (pDis->Param2.cb)
2846	{
2847	case 1: u64 = (uint8_t )pvParam1; break;
2848	case 2: u64 = (uint16_t )pvParam1; break;
2849	case 4: u64 = (uint32_t )pvParam1; break;
2850	default:
2851	case 8: u64 = (uint64_t )pvParam1; break;
2852	}
2853	eflags = EMEmulateCmpXchg(&u64, &pRegFrame->rax, valpar, pDis->Param2.cb);
2854	int rc2 = emRamWrite(pVM, pVCpu, pRegFrame, GCPtrPar1, &u64, pDis->Param2.cb); AssertRCSuccess(rc2);
2855	#endif /* VBOX_COMPARE_IEM_AND_EM */
2856
2857	LogFlow(("%s %RGv rax=%RX64 %RX64 ZF=%d\n", emGetMnemonic(pDis), GCPtrPar1, pRegFrame->rax, valpar, !!(eflags & X86_EFL_ZF)));
2858
2859	/* Update guest's eflags and finish. */
2860	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
2861	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
2862
2863	*pcbSize = param2.size;
2864	PGMPhysReleasePageMappingLock(pVM, &Lock);
2865	return VINF_SUCCESS;
2866	}
2867
2868
2869	/**
2870	* [LOCK] CMPXCHG8B emulation.
2871	*/
2872	static int emInterpretCmpXchg8b(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2873	{
2874	DISQPVPARAMVAL param1;
2875	NOREF(pvFault);
2876
2877	/* Source to make DISQueryParamVal read the register value - ugly hack */
2878	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_SRC);
2879	if(RT_FAILURE(rc))
2880	return VERR_EM_INTERPRETER;
2881
2882	RTGCPTR GCPtrPar1;
2883	void *pvParam1;
2884	uint64_t eflags;
2885	PGMPAGEMAPLOCK Lock;
2886
2887	AssertReturn(pDis->Param1.cb == 8, VERR_EM_INTERPRETER);
2888	switch(param1.type)
2889	{
2890	case DISQPV_TYPE_ADDRESS:
2891	GCPtrPar1 = param1.val.val64;
2892	GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, GCPtrPar1);
2893
2894	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
2895	AssertRCReturn(rc, VERR_EM_INTERPRETER);
2896	break;
2897
2898	default:
2899	return VERR_EM_INTERPRETER;
2900	}
2901
2902	LogFlow(("%s %RGv=%p eax=%08x\n", emGetMnemonic(pDis), GCPtrPar1, pvParam1, pRegFrame->eax));
2903
2904	#ifndef VBOX_COMPARE_IEM_AND_EM
2905	if (pDis->fPrefix & DISPREFIX_LOCK)
2906	eflags = EMEmulateLockCmpXchg8b(pvParam1, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx);
2907	else
2908	eflags = EMEmulateCmpXchg8b(pvParam1, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx);
2909	#else /* VBOX_COMPARE_IEM_AND_EM */
2910	uint64_t u64 = (uint64_t )pvParam1;
2911	eflags = EMEmulateCmpXchg8b(&u64, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx);
2912	int rc2 = emRamWrite(pVM, pVCpu, pRegFrame, GCPtrPar1, &u64, sizeof(u64)); AssertRCSuccess(rc2);
2913	#endif /* VBOX_COMPARE_IEM_AND_EM */
2914
2915	LogFlow(("%s %RGv=%p eax=%08x ZF=%d\n", emGetMnemonic(pDis), GCPtrPar1, pvParam1, pRegFrame->eax, !!(eflags & X86_EFL_ZF)));
2916
2917	/* Update guest's eflags and finish; note that only ZF is affected. */
2918	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_ZF))
2919	\| (eflags & (X86_EFL_ZF));
2920
2921	*pcbSize = 8;
2922	PGMPhysReleasePageMappingLock(pVM, &Lock);
2923	return VINF_SUCCESS;
2924	}
2925
2926
2927	#ifdef IN_RC /** @todo test+enable for HM as well. */
2928	/**
2929	* [LOCK] XADD emulation.
2930	*/
2931	static int emInterpretXAdd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2932	{
2933	Assert(pDis->uCpuMode != DISCPUMODE_64BIT); /** @todo check */
2934	DISQPVPARAMVAL param1;
2935	void *pvParamReg2;
2936	size_t cbParamReg2;
2937	NOREF(pvFault);
2938
2939	/* Source to make DISQueryParamVal read the register value - ugly hack */
2940	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_SRC);
2941	if(RT_FAILURE(rc))
2942	return VERR_EM_INTERPRETER;
2943
2944	rc = DISQueryParamRegPtr(pRegFrame, pDis, &pDis->Param2, &pvParamReg2, &cbParamReg2);
2945	Assert(cbParamReg2 <= 4);
2946	if(RT_FAILURE(rc))
2947	return VERR_EM_INTERPRETER;
2948
2949	#ifdef IN_RC
2950	if (TRPMHasTrap(pVCpu))
2951	{
2952	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
2953	{
2954	#endif
2955	RTGCPTR GCPtrPar1;
2956	void *pvParam1;
2957	uint32_t eflags;
2958	PGMPAGEMAPLOCK Lock;
2959
2960	AssertReturn(pDis->Param1.cb == pDis->Param2.cb, VERR_EM_INTERPRETER);
2961	switch(param1.type)
2962	{
2963	case DISQPV_TYPE_ADDRESS:
2964	GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, (RTRCUINTPTR)param1.val.val64);
2965	#ifdef IN_RC
2966	EM_ASSERT_FAULT_RETURN(GCPtrPar1 == pvFault, VERR_EM_INTERPRETER);
2967	#endif
2968
2969	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
2970	AssertRCReturn(rc, VERR_EM_INTERPRETER);
2971	break;
2972
2973	default:
2974	return VERR_EM_INTERPRETER;
2975	}
2976
2977	LogFlow(("XAdd %RGv=%p reg=%08llx\n", GCPtrPar1, pvParam1, (uint64_t )pvParamReg2));
2978
2979	#ifndef VBOX_COMPARE_IEM_AND_EM
2980	if (pDis->fPrefix & DISPREFIX_LOCK)
2981	eflags = EMEmulateLockXAdd(pvParam1, pvParamReg2, cbParamReg2);
2982	else
2983	eflags = EMEmulateXAdd(pvParam1, pvParamReg2, cbParamReg2);
2984	#else /* VBOX_COMPARE_IEM_AND_EM */
2985	uint64_t u64;
2986	switch (cbParamReg2)
2987	{
2988	case 1: u64 = (uint8_t )pvParam1; break;
2989	case 2: u64 = (uint16_t )pvParam1; break;
2990	case 4: u64 = (uint32_t )pvParam1; break;
2991	default:
2992	case 8: u64 = (uint64_t )pvParam1; break;
2993	}
2994	eflags = EMEmulateXAdd(&u64, pvParamReg2, cbParamReg2);
2995	int rc2 = emRamWrite(pVM, pVCpu, pRegFrame, GCPtrPar1, &u64, pDis->Param2.cb); AssertRCSuccess(rc2);
2996	#endif /* VBOX_COMPARE_IEM_AND_EM */
2997
2998	LogFlow(("XAdd %RGv=%p reg=%08llx ZF=%d\n", GCPtrPar1, pvParam1, (uint64_t )pvParamReg2, !!(eflags & X86_EFL_ZF) ));
2999
3000	/* Update guest's eflags and finish. */
3001	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
3002	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
3003
3004	*pcbSize = cbParamReg2;
3005	PGMPhysReleasePageMappingLock(pVM, &Lock);
3006	return VINF_SUCCESS;
3007	#ifdef IN_RC
3008	}
3009	}
3010
3011	return VERR_EM_INTERPRETER;
3012	#endif
3013	}
3014	#endif /* IN_RC */
3015
3016
3017	/**
3018	* WBINVD Emulation.
3019	*/
3020	static int emInterpretWbInvd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3021	{
3022	/* Nothing to do. */
3023	NOREF(pVM); NOREF(pVCpu); NOREF(pDis); NOREF(pRegFrame); NOREF(pvFault); NOREF(pcbSize);
3024	return VINF_SUCCESS;
3025	}
3026
3027
3028	/**
3029	* INVLPG Emulation.
3030	*/
3031	static VBOXSTRICTRC emInterpretInvlPg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3032	{
3033	DISQPVPARAMVAL param1;
3034	RTGCPTR addr;
3035	NOREF(pvFault); NOREF(pVM); NOREF(pcbSize);
3036
3037	VBOXSTRICTRC rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_SRC);
3038	if(RT_FAILURE(rc))
3039	return VERR_EM_INTERPRETER;
3040
3041	switch(param1.type)
3042	{
3043	case DISQPV_TYPE_IMMEDIATE:
3044	case DISQPV_TYPE_ADDRESS:
3045	if(!(param1.flags & (DISQPV_FLAG_32\|DISQPV_FLAG_64)))
3046	return VERR_EM_INTERPRETER;
3047	addr = (RTGCPTR)param1.val.val64;
3048	break;
3049
3050	default:
3051	return VERR_EM_INTERPRETER;
3052	}
3053
3054	/** @todo is addr always a flat linear address or ds based
3055	* (in absence of segment override prefixes)????
3056	*/
3057	#ifdef IN_RC
3058	LogFlow(("RC: EMULATE: invlpg %RGv\n", addr));
3059	#endif
3060	rc = PGMInvalidatePage(pVCpu, addr);
3061	if ( rc == VINF_SUCCESS
3062	\|\| rc == VINF_PGM_SYNC_CR3 /* we can rely on the FF */)
3063	return VINF_SUCCESS;
3064	AssertMsgReturn(rc == VINF_EM_RAW_EMULATE_INSTR,
3065	("%Rrc addr=%RGv\n", VBOXSTRICTRC_VAL(rc), addr),
3066	VERR_EM_INTERPRETER);
3067	return rc;
3068	}
3069
3070	/** @todo change all these EMInterpretXXX methods to VBOXSTRICTRC. */
3071
3072	/**
3073	* CPUID Emulation.
3074	*/
3075	static int emInterpretCpuId(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3076	{
3077	NOREF(pVM); NOREF(pVCpu); NOREF(pDis); NOREF(pRegFrame); NOREF(pvFault); NOREF(pcbSize);
3078	int rc = EMInterpretCpuId(pVM, pVCpu, pRegFrame);
3079	return rc;
3080	}
3081
3082
3083	/**
3084	* CLTS Emulation.
3085	*/
3086	static int emInterpretClts(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3087	{
3088	NOREF(pVM); NOREF(pDis); NOREF(pRegFrame); NOREF(pvFault); NOREF(pcbSize);
3089
3090	uint64_t cr0 = CPUMGetGuestCR0(pVCpu);
3091	if (!(cr0 & X86_CR0_TS))
3092	return VINF_SUCCESS;
3093	return CPUMSetGuestCR0(pVCpu, cr0 & ~X86_CR0_TS);
3094	}
3095
3096
3097	/**
3098	* Update CRx.
3099	*
3100	* @returns VBox status code.
3101	* @param pVM The cross context VM structure.
3102	* @param pVCpu The cross context virtual CPU structure.
3103	* @param pRegFrame The register frame.
3104	* @param DestRegCrx CRx register index (DISUSE_REG_CR*)
3105	* @param val New CRx value
3106	*
3107	*/
3108	static int emUpdateCRx(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegCrx, uint64_t val)
3109	{
3110	uint64_t oldval;
3111	uint64_t msrEFER;
3112	uint32_t fValid;
3113	int rc, rc2;
3114	NOREF(pVM);
3115
3116	/** @todo Clean up this mess. */
3117	LogFlow(("emInterpretCRxWrite at %RGv CR%d <- %RX64\n", (RTGCPTR)pRegFrame->rip, DestRegCrx, val));
3118	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
3119	switch (DestRegCrx)
3120	{
3121	case DISCREG_CR0:
3122	oldval = CPUMGetGuestCR0(pVCpu);
3123	#ifdef IN_RC
3124	/* CR0.WP and CR0.AM changes require a reschedule run in ring 3. */
3125	if ( (val & (X86_CR0_WP \| X86_CR0_AM))
3126	!= (oldval & (X86_CR0_WP \| X86_CR0_AM)))
3127	return VERR_EM_INTERPRETER;
3128	#endif
3129	rc = VINF_SUCCESS;
3130	#if !defined(VBOX_COMPARE_IEM_AND_EM) \|\| !defined(VBOX_COMPARE_IEM_LAST)
3131	CPUMSetGuestCR0(pVCpu, val);
3132	#else
3133	CPUMQueryGuestCtxPtr(pVCpu)->cr0 = val \| X86_CR0_ET;
3134	#endif
3135	val = CPUMGetGuestCR0(pVCpu);
3136	if ( (oldval & (X86_CR0_PG \| X86_CR0_WP \| X86_CR0_PE))
3137	!= (val & (X86_CR0_PG \| X86_CR0_WP \| X86_CR0_PE)))
3138	{
3139	/* global flush */
3140	rc = PGMFlushTLB(pVCpu, CPUMGetGuestCR3(pVCpu), true /* global */);
3141	AssertRCReturn(rc, rc);
3142	}
3143
3144	/* Deal with long mode enabling/disabling. */
3145	msrEFER = CPUMGetGuestEFER(pVCpu);
3146	if (msrEFER & MSR_K6_EFER_LME)
3147	{
3148	if ( !(oldval & X86_CR0_PG)
3149	&& (val & X86_CR0_PG))
3150	{
3151	/* Illegal to have an active 64 bits CS selector (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
3152	if (pRegFrame->cs.Attr.n.u1Long)
3153	{
3154	AssertMsgFailed(("Illegal enabling of paging with CS.u1Long = 1!!\n"));
3155	return VERR_EM_INTERPRETER; /** @todo generate \#GP(0) */
3156	}
3157
3158	/* Illegal to switch to long mode before activating PAE first (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
3159	if (!(CPUMGetGuestCR4(pVCpu) & X86_CR4_PAE))
3160	{
3161	AssertMsgFailed(("Illegal enabling of paging with PAE disabled!!\n"));
3162	return VERR_EM_INTERPRETER; /** @todo generate \#GP(0) */
3163	}
3164	msrEFER \|= MSR_K6_EFER_LMA;
3165	}
3166	else
3167	if ( (oldval & X86_CR0_PG)
3168	&& !(val & X86_CR0_PG))
3169	{
3170	msrEFER &= ~MSR_K6_EFER_LMA;
3171	/** @todo Do we need to cut off rip here? High dword of rip is undefined, so it shouldn't really matter. */
3172	}
3173	CPUMSetGuestEFER(pVCpu, msrEFER);
3174	}
3175	rc2 = PGMChangeMode(pVCpu, CPUMGetGuestCR0(pVCpu), CPUMGetGuestCR4(pVCpu), CPUMGetGuestEFER(pVCpu));
3176	return rc2 == VINF_SUCCESS ? rc : rc2;
3177
3178	case DISCREG_CR2:
3179	rc = CPUMSetGuestCR2(pVCpu, val); AssertRC(rc);
3180	return VINF_SUCCESS;
3181
3182	case DISCREG_CR3:
3183	/* Reloading the current CR3 means the guest just wants to flush the TLBs */
3184	rc = CPUMSetGuestCR3(pVCpu, val); AssertRC(rc);
3185	if (CPUMGetGuestCR0(pVCpu) & X86_CR0_PG)
3186	{
3187	/* flush */
3188	rc = PGMFlushTLB(pVCpu, val, !(CPUMGetGuestCR4(pVCpu) & X86_CR4_PGE));
3189	AssertRC(rc);
3190	}
3191	return rc;
3192
3193	case DISCREG_CR4:
3194	oldval = CPUMGetGuestCR4(pVCpu);
3195	rc = CPUMSetGuestCR4(pVCpu, val); AssertRC(rc);
3196	val = CPUMGetGuestCR4(pVCpu);
3197
3198	/* Illegal to disable PAE when long mode is active. (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
3199	msrEFER = CPUMGetGuestEFER(pVCpu);
3200	if ( (msrEFER & MSR_K6_EFER_LMA)
3201	&& (oldval & X86_CR4_PAE)
3202	&& !(val & X86_CR4_PAE))
3203	{
3204	return VERR_EM_INTERPRETER; /** @todo generate \#GP(0) */
3205	}
3206
3207	/* From IEM iemCImpl_load_CrX. */
3208	/** @todo Check guest CPUID bits for determining corresponding valid bits. */
3209	fValid = X86_CR4_VME \| X86_CR4_PVI
3210	\| X86_CR4_TSD \| X86_CR4_DE
3211	\| X86_CR4_PSE \| X86_CR4_PAE
3212	\| X86_CR4_MCE \| X86_CR4_PGE
3213	\| X86_CR4_PCE \| X86_CR4_OSFXSR
3214	\| X86_CR4_OSXMMEEXCPT;
3215	//if (xxx)
3216	// fValid \|= X86_CR4_VMXE;
3217	//if (xxx)
3218	// fValid \|= X86_CR4_OSXSAVE;
3219	if (val & ~(uint64_t)fValid)
3220	{
3221	Log(("Trying to set reserved CR4 bits: NewCR4=%#llx InvalidBits=%#llx\n", val, val & ~(uint64_t)fValid));
3222	return VERR_EM_INTERPRETER; /** @todo generate \#GP(0) */
3223	}
3224
3225	rc = VINF_SUCCESS;
3226	if ( (oldval & (X86_CR4_PGE\|X86_CR4_PAE\|X86_CR4_PSE))
3227	!= (val & (X86_CR4_PGE\|X86_CR4_PAE\|X86_CR4_PSE)))
3228	{
3229	/* global flush */
3230	rc = PGMFlushTLB(pVCpu, CPUMGetGuestCR3(pVCpu), true /* global */);
3231	AssertRCReturn(rc, rc);
3232	}
3233
3234	/* Feeling extremely lazy. */
3235	# ifdef IN_RC
3236	if ( (oldval & (X86_CR4_OSFXSR\|X86_CR4_OSXMMEEXCPT\|X86_CR4_PCE\|X86_CR4_MCE\|X86_CR4_PAE\|X86_CR4_DE\|X86_CR4_TSD\|X86_CR4_PVI\|X86_CR4_VME))
3237	!= (val & (X86_CR4_OSFXSR\|X86_CR4_OSXMMEEXCPT\|X86_CR4_PCE\|X86_CR4_MCE\|X86_CR4_PAE\|X86_CR4_DE\|X86_CR4_TSD\|X86_CR4_PVI\|X86_CR4_VME)))
3238	{
3239	Log(("emInterpretMovCRx: CR4: %#RX64->%#RX64 => R3\n", oldval, val));
3240	VMCPU_FF_SET(pVCpu, VMCPU_FF_TO_R3);
3241	}
3242	# endif
3243	# ifdef VBOX_WITH_RAW_MODE
3244	if (((val ^ oldval) & X86_CR4_VME) && !HMIsEnabled(pVM))
3245	VMCPU_FF_SET(pVCpu, VMCPU_FF_SELM_SYNC_TSS);
3246	# endif
3247
3248	rc2 = PGMChangeMode(pVCpu, CPUMGetGuestCR0(pVCpu), CPUMGetGuestCR4(pVCpu), CPUMGetGuestEFER(pVCpu));
3249	return rc2 == VINF_SUCCESS ? rc : rc2;
3250
3251	case DISCREG_CR8:
3252	return APICSetTpr(pVCpu, val << 4); /* cr8 bits 3-0 correspond to bits 7-4 of the task priority mmio register. */
3253
3254	default:
3255	AssertFailed();
3256	case DISCREG_CR1: /* illegal op */
3257	break;
3258	}
3259	return VERR_EM_INTERPRETER;
3260	}
3261
3262
3263	/**
3264	* LMSW Emulation.
3265	*/
3266	static int emInterpretLmsw(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3267	{
3268	DISQPVPARAMVAL param1;
3269	uint32_t val;
3270	NOREF(pvFault); NOREF(pcbSize);
3271	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
3272
3273	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_SRC);
3274	if(RT_FAILURE(rc))
3275	return VERR_EM_INTERPRETER;
3276
3277	switch(param1.type)
3278	{
3279	case DISQPV_TYPE_IMMEDIATE:
3280	case DISQPV_TYPE_ADDRESS:
3281	if(!(param1.flags & DISQPV_FLAG_16))
3282	return VERR_EM_INTERPRETER;
3283	val = param1.val.val32;
3284	break;
3285
3286	default:
3287	return VERR_EM_INTERPRETER;
3288	}
3289
3290	LogFlow(("emInterpretLmsw %x\n", val));
3291	uint64_t OldCr0 = CPUMGetGuestCR0(pVCpu);
3292
3293	/* Only PE, MP, EM and TS can be changed; note that PE can't be cleared by this instruction. */
3294	uint64_t NewCr0 = ( OldCr0 & ~( X86_CR0_MP \| X86_CR0_EM \| X86_CR0_TS))
3295	\| (val & (X86_CR0_PE \| X86_CR0_MP \| X86_CR0_EM \| X86_CR0_TS));
3296
3297	return emUpdateCRx(pVM, pVCpu, pRegFrame, DISCREG_CR0, NewCr0);
3298
3299	}
3300
3301	#ifdef EM_EMULATE_SMSW
3302	/**
3303	* SMSW Emulation.
3304	*/
3305	static int emInterpretSmsw(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3306	{
3307	NOREF(pvFault); NOREF(pcbSize);
3308	DISQPVPARAMVAL param1;
3309	uint64_t cr0 = CPUMGetGuestCR0(pVCpu);
3310
3311	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_SRC);
3312	if(RT_FAILURE(rc))
3313	return VERR_EM_INTERPRETER;
3314
3315	switch(param1.type)
3316	{
3317	case DISQPV_TYPE_IMMEDIATE:
3318	if(param1.size != sizeof(uint16_t))
3319	return VERR_EM_INTERPRETER;
3320	LogFlow(("emInterpretSmsw %d <- cr0 (%x)\n", pDis->Param1.Base.idxGenReg, cr0));
3321	rc = DISWriteReg16(pRegFrame, pDis->Param1.Base.idxGenReg, cr0);
3322	break;
3323
3324	case DISQPV_TYPE_ADDRESS:
3325	{
3326	RTGCPTR pParam1;
3327
3328	/* Actually forced to 16 bits regardless of the operand size. */
3329	if(param1.size != sizeof(uint16_t))
3330	return VERR_EM_INTERPRETER;
3331
3332	pParam1 = (RTGCPTR)param1.val.val64;
3333	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, pParam1);
3334	LogFlow(("emInterpretSmsw %RGv <- cr0 (%x)\n", pParam1, cr0));
3335
3336	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &cr0, sizeof(uint16_t));
3337	if (RT_FAILURE(rc))
3338	{
3339	AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
3340	return VERR_EM_INTERPRETER;
3341	}
3342	break;
3343	}
3344
3345	default:
3346	return VERR_EM_INTERPRETER;
3347	}
3348
3349	LogFlow(("emInterpretSmsw %x\n", cr0));
3350	return rc;
3351	}
3352	#endif
3353
3354
3355	/**
3356	* Interpret CRx read.
3357	*
3358	* @returns VBox status code.
3359	* @param pVM The cross context VM structure.
3360	* @param pVCpu The cross context virtual CPU structure.
3361	* @param pRegFrame The register frame.
3362	* @param DestRegGen General purpose register index (USE_REG_E**))
3363	* @param SrcRegCrx CRx register index (DISUSE_REG_CR*)
3364	*
3365	*/
3366	static int emInterpretCRxRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegGen, uint32_t SrcRegCrx)
3367	{
3368	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
3369	uint64_t val64;
3370	int rc = CPUMGetGuestCRx(pVCpu, SrcRegCrx, &val64);
3371	AssertMsgRCReturn(rc, ("CPUMGetGuestCRx %d failed\n", SrcRegCrx), VERR_EM_INTERPRETER);
3372	NOREF(pVM);
3373
3374	if (CPUMIsGuestIn64BitCode(pVCpu))
3375	rc = DISWriteReg64(pRegFrame, DestRegGen, val64);
3376	else
3377	rc = DISWriteReg32(pRegFrame, DestRegGen, val64);
3378
3379	if (RT_SUCCESS(rc))
3380	{
3381	LogFlow(("MOV_CR: gen32=%d CR=%d val=%RX64\n", DestRegGen, SrcRegCrx, val64));
3382	return VINF_SUCCESS;
3383	}
3384	return VERR_EM_INTERPRETER;
3385	}
3386
3387
3388	/**
3389	* Interpret CRx write.
3390	*
3391	* @returns VBox status code.
3392	* @param pVM The cross context VM structure.
3393	* @param pVCpu The cross context virtual CPU structure.
3394	* @param pRegFrame The register frame.
3395	* @param DestRegCrx CRx register index (DISUSE_REG_CR*)
3396	* @param SrcRegGen General purpose register index (USE_REG_E**))
3397	*
3398	*/
3399	static int emInterpretCRxWrite(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegCrx, uint32_t SrcRegGen)
3400	{
3401	uint64_t val;
3402	int rc;
3403	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
3404
3405	if (CPUMIsGuestIn64BitCode(pVCpu))
3406	rc = DISFetchReg64(pRegFrame, SrcRegGen, &val);
3407	else
3408	{
3409	uint32_t val32;
3410	rc = DISFetchReg32(pRegFrame, SrcRegGen, &val32);
3411	val = val32;
3412	}
3413
3414	if (RT_SUCCESS(rc))
3415	return emUpdateCRx(pVM, pVCpu, pRegFrame, DestRegCrx, val);
3416
3417	return VERR_EM_INTERPRETER;
3418	}
3419
3420
3421	/**
3422	* MOV CRx
3423	*/
3424	static int emInterpretMovCRx(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3425	{
3426	NOREF(pvFault); NOREF(pcbSize);
3427	if ((pDis->Param1.fUse == DISUSE_REG_GEN32 \|\| pDis->Param1.fUse == DISUSE_REG_GEN64) && pDis->Param2.fUse == DISUSE_REG_CR)
3428	return emInterpretCRxRead(pVM, pVCpu, pRegFrame, pDis->Param1.Base.idxGenReg, pDis->Param2.Base.idxCtrlReg);
3429
3430	if (pDis->Param1.fUse == DISUSE_REG_CR && (pDis->Param2.fUse == DISUSE_REG_GEN32 \|\| pDis->Param2.fUse == DISUSE_REG_GEN64))
3431	return emInterpretCRxWrite(pVM, pVCpu, pRegFrame, pDis->Param1.Base.idxCtrlReg, pDis->Param2.Base.idxGenReg);
3432
3433	AssertMsgFailedReturn(("Unexpected control register move\n"), VERR_EM_INTERPRETER);
3434	}
3435
3436
3437	/**
3438	* MOV DRx
3439	*/
3440	static int emInterpretMovDRx(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3441	{
3442	int rc = VERR_EM_INTERPRETER;
3443	NOREF(pvFault); NOREF(pcbSize);
3444
3445	if((pDis->Param1.fUse == DISUSE_REG_GEN32 \|\| pDis->Param1.fUse == DISUSE_REG_GEN64) && pDis->Param2.fUse == DISUSE_REG_DBG)
3446	{
3447	rc = EMInterpretDRxRead(pVM, pVCpu, pRegFrame, pDis->Param1.Base.idxGenReg, pDis->Param2.Base.idxDbgReg);
3448	}
3449	else
3450	if(pDis->Param1.fUse == DISUSE_REG_DBG && (pDis->Param2.fUse == DISUSE_REG_GEN32 \|\| pDis->Param2.fUse == DISUSE_REG_GEN64))
3451	{
3452	rc = EMInterpretDRxWrite(pVM, pVCpu, pRegFrame, pDis->Param1.Base.idxDbgReg, pDis->Param2.Base.idxGenReg);
3453	}
3454	else
3455	AssertMsgFailed(("Unexpected debug register move\n"));
3456
3457	return rc;
3458	}
3459
3460
3461	/**
3462	* LLDT Emulation.
3463	*/
3464	static int emInterpretLLdt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3465	{
3466	DISQPVPARAMVAL param1;
3467	RTSEL sel;
3468	NOREF(pVM); NOREF(pvFault); NOREF(pcbSize);
3469
3470	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_SRC);
3471	if(RT_FAILURE(rc))
3472	return VERR_EM_INTERPRETER;
3473
3474	switch(param1.type)
3475	{
3476	case DISQPV_TYPE_ADDRESS:
3477	return VERR_EM_INTERPRETER; //feeling lazy right now
3478
3479	case DISQPV_TYPE_IMMEDIATE:
3480	if(!(param1.flags & DISQPV_FLAG_16))
3481	return VERR_EM_INTERPRETER;
3482	sel = (RTSEL)param1.val.val16;
3483	break;
3484
3485	default:
3486	return VERR_EM_INTERPRETER;
3487	}
3488
3489	#ifdef IN_RING0
3490	/* Only for the VT-x real-mode emulation case. */
3491	AssertReturn(CPUMIsGuestInRealMode(pVCpu), VERR_EM_INTERPRETER);
3492	CPUMSetGuestLDTR(pVCpu, sel);
3493	return VINF_SUCCESS;
3494	#else
3495	if (sel == 0)
3496	{
3497	if (CPUMGetHyperLDTR(pVCpu) == 0)
3498	{
3499	// this simple case is most frequent in Windows 2000 (31k - boot & shutdown)
3500	return VINF_SUCCESS;
3501	}
3502	}
3503	//still feeling lazy
3504	return VERR_EM_INTERPRETER;
3505	#endif
3506	}
3507
3508	#ifdef IN_RING0
3509	/**
3510	* LIDT/LGDT Emulation.
3511	*/
3512	static int emInterpretLIGdt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3513	{
3514	DISQPVPARAMVAL param1;
3515	RTGCPTR pParam1;
3516	X86XDTR32 dtr32;
3517	NOREF(pvFault); NOREF(pcbSize);
3518
3519	Log(("Emulate %s at %RGv\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip));
3520
3521	/* Only for the VT-x real-mode emulation case. */
3522	AssertReturn(CPUMIsGuestInRealMode(pVCpu), VERR_EM_INTERPRETER);
3523
3524	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->Param1, &param1, DISQPVWHICH_SRC);
3525	if(RT_FAILURE(rc))
3526	return VERR_EM_INTERPRETER;
3527
3528	switch(param1.type)
3529	{
3530	case DISQPV_TYPE_ADDRESS:
3531	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->Param1, param1.val.val16);
3532	break;
3533
3534	default:
3535	return VERR_EM_INTERPRETER;
3536	}
3537
3538	rc = emRamRead(pVM, pVCpu, pRegFrame, &dtr32, pParam1, sizeof(dtr32));
3539	AssertRCReturn(rc, VERR_EM_INTERPRETER);
3540
3541	if (!(pDis->fPrefix & DISPREFIX_OPSIZE))
3542	dtr32.uAddr &= 0xffffff; /* 16 bits operand size */
3543
3544	if (pDis->pCurInstr->uOpcode == OP_LIDT)
3545	CPUMSetGuestIDTR(pVCpu, dtr32.uAddr, dtr32.cb);
3546	else
3547	CPUMSetGuestGDTR(pVCpu, dtr32.uAddr, dtr32.cb);
3548
3549	return VINF_SUCCESS;
3550	}
3551	#endif
3552
3553
3554	#ifdef IN_RC
3555	/**
3556	* STI Emulation.
3557	*
3558	* @remark the instruction following sti is guaranteed to be executed before any interrupts are dispatched
3559	*/
3560	static int emInterpretSti(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3561	{
3562	NOREF(pcbSize);
3563	PPATMGCSTATE pGCState = PATMGetGCState(pVM);
3564
3565	if(!pGCState)
3566	{
3567	Assert(pGCState);
3568	return VERR_EM_INTERPRETER;
3569	}
3570	pGCState->uVMFlags \|= X86_EFL_IF;
3571
3572	Assert(pRegFrame->eflags.u32 & X86_EFL_IF);
3573	Assert(pvFault == SELMToFlat(pVM, DISSELREG_CS, pRegFrame, (RTGCPTR)pRegFrame->rip));
3574
3575	pVCpu->em.s.GCPtrInhibitInterrupts = pRegFrame->eip + pDis->cbInstr;
3576	VMCPU_FF_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
3577
3578	return VINF_SUCCESS;
3579	}
3580	#endif /* IN_RC */
3581
3582
3583	/**
3584	* HLT Emulation.
3585	*/
3586	static VBOXSTRICTRC
3587	emInterpretHlt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3588	{
3589	NOREF(pVM); NOREF(pVCpu); NOREF(pDis); NOREF(pRegFrame); NOREF(pvFault); NOREF(pcbSize);
3590	return VINF_EM_HALT;
3591	}
3592
3593
3594	/**
3595	* RDTSC Emulation.
3596	*/
3597	static int emInterpretRdtsc(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3598	{
3599	NOREF(pDis); NOREF(pvFault); NOREF(pcbSize);
3600	return EMInterpretRdtsc(pVM, pVCpu, pRegFrame);
3601	}
3602
3603	/**
3604	* RDPMC Emulation
3605	*/
3606	static int emInterpretRdpmc(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3607	{
3608	NOREF(pDis); NOREF(pvFault); NOREF(pcbSize);
3609	return EMInterpretRdpmc(pVM, pVCpu, pRegFrame);
3610	}
3611
3612
3613	static int emInterpretMonitor(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3614	{
3615	NOREF(pDis); NOREF(pvFault); NOREF(pcbSize);
3616	return EMInterpretMonitor(pVM, pVCpu, pRegFrame);
3617	}
3618
3619
3620	static VBOXSTRICTRC emInterpretMWait(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3621	{
3622	NOREF(pDis); NOREF(pvFault); NOREF(pcbSize);
3623	return EMInterpretMWait(pVM, pVCpu, pRegFrame);
3624	}
3625
3626
3627	/**
3628	* RDMSR Emulation.
3629	*/
3630	static int emInterpretRdmsr(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3631	{
3632	/* Note: The Intel manual claims there's a REX version of RDMSR that's slightly
3633	different, so we play safe by completely disassembling the instruction. */
3634	Assert(!(pDis->fPrefix & DISPREFIX_REX));
3635	NOREF(pDis); NOREF(pvFault); NOREF(pcbSize);
3636	return EMInterpretRdmsr(pVM, pVCpu, pRegFrame);
3637	}
3638
3639
3640	/**
3641	* WRMSR Emulation.
3642	*/
3643	static int emInterpretWrmsr(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
3644	{
3645	NOREF(pDis); NOREF(pvFault); NOREF(pcbSize);
3646	return EMInterpretWrmsr(pVM, pVCpu, pRegFrame);
3647	}
3648
3649
3650	/**
3651	* Internal worker.
3652	* @copydoc emInterpretInstructionCPUOuter
3653	* @param pVM The cross context VM structure.
3654	*/
3655	DECLINLINE(VBOXSTRICTRC) emInterpretInstructionCPU(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame,
3656	RTGCPTR pvFault, EMCODETYPE enmCodeType, uint32_t *pcbSize)
3657	{
3658	Assert(pRegFrame == CPUMGetGuestCtxCore(pVCpu));
3659	Assert(enmCodeType == EMCODETYPE_SUPERVISOR \|\| enmCodeType == EMCODETYPE_ALL);
3660	Assert(pcbSize);
3661	*pcbSize = 0;
3662
3663	if (enmCodeType == EMCODETYPE_SUPERVISOR)
3664	{
3665	/*
3666	* Only supervisor guest code!!
3667	* And no complicated prefixes.
3668	*/
3669	/* Get the current privilege level. */
3670	uint32_t cpl = CPUMGetGuestCPL(pVCpu);
3671	#ifdef VBOX_WITH_RAW_RING1
3672	if ( !EMIsRawRing1Enabled(pVM)
3673	\|\| cpl > 1
3674	\|\| pRegFrame->eflags.Bits.u2IOPL > cpl
3675	)
3676	#endif
3677	{
3678	if ( cpl != 0
3679	&& pDis->pCurInstr->uOpcode != OP_RDTSC) /* rdtsc requires emulation in ring 3 as well */
3680	{
3681	Log(("WARNING: refusing instruction emulation for user-mode code!!\n"));
3682	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedUserMode));
3683	return VERR_EM_INTERPRETER;
3684	}
3685	}
3686	}
3687	else
3688	Log2(("emInterpretInstructionCPU allowed to interpret user-level code!!\n"));
3689
3690	#ifdef IN_RC
3691	if ( (pDis->fPrefix & (DISPREFIX_REPNE \| DISPREFIX_REP))
3692	\|\| ( (pDis->fPrefix & DISPREFIX_LOCK)
3693	&& pDis->pCurInstr->uOpcode != OP_CMPXCHG
3694	&& pDis->pCurInstr->uOpcode != OP_CMPXCHG8B
3695	&& pDis->pCurInstr->uOpcode != OP_XADD
3696	&& pDis->pCurInstr->uOpcode != OP_OR
3697	&& pDis->pCurInstr->uOpcode != OP_AND
3698	&& pDis->pCurInstr->uOpcode != OP_XOR
3699	&& pDis->pCurInstr->uOpcode != OP_BTR
3700	)
3701	)
3702	#else
3703	if ( (pDis->fPrefix & DISPREFIX_REPNE)
3704	\|\| ( (pDis->fPrefix & DISPREFIX_REP)
3705	&& pDis->pCurInstr->uOpcode != OP_STOSWD
3706	)
3707	\|\| ( (pDis->fPrefix & DISPREFIX_LOCK)
3708	&& pDis->pCurInstr->uOpcode != OP_OR
3709	&& pDis->pCurInstr->uOpcode != OP_AND
3710	&& pDis->pCurInstr->uOpcode != OP_XOR
3711	&& pDis->pCurInstr->uOpcode != OP_BTR
3712	&& pDis->pCurInstr->uOpcode != OP_CMPXCHG
3713	&& pDis->pCurInstr->uOpcode != OP_CMPXCHG8B
3714	)
3715	)
3716	#endif
3717	{
3718	//Log(("EMInterpretInstruction: wrong prefix!!\n"));
3719	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedPrefix));
3720	Log4(("EM: Refuse %u on REP/REPNE/LOCK prefix grounds\n", pDis->pCurInstr->uOpcode));
3721	return VERR_EM_INTERPRETER;
3722	}
3723
3724	#if HC_ARCH_BITS == 32
3725	/*
3726	* Unable to emulate most >4 bytes accesses in 32 bits mode.
3727	* Whitelisted instructions are safe.
3728	*/
3729	if ( pDis->Param1.cb > 4
3730	&& CPUMIsGuestIn64BitCode(pVCpu))
3731	{
3732	uint32_t uOpCode = pDis->pCurInstr->uOpcode;
3733	if ( uOpCode != OP_STOSWD
3734	&& uOpCode != OP_MOV
3735	&& uOpCode != OP_CMPXCHG8B
3736	&& uOpCode != OP_XCHG
3737	&& uOpCode != OP_BTS
3738	&& uOpCode != OP_BTR
3739	&& uOpCode != OP_BTC
3740	)
3741	{
3742	# ifdef VBOX_WITH_STATISTICS
3743	switch (pDis->pCurInstr->uOpcode)
3744	{
3745	# define INTERPRET_FAILED_CASE(opcode, Instr) \
3746	case opcode: STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); break;
3747	INTERPRET_FAILED_CASE(OP_XCHG,Xchg);
3748	INTERPRET_FAILED_CASE(OP_DEC,Dec);
3749	INTERPRET_FAILED_CASE(OP_INC,Inc);
3750	INTERPRET_FAILED_CASE(OP_POP,Pop);
3751	INTERPRET_FAILED_CASE(OP_OR, Or);
3752	INTERPRET_FAILED_CASE(OP_XOR,Xor);
3753	INTERPRET_FAILED_CASE(OP_AND,And);
3754	INTERPRET_FAILED_CASE(OP_MOV,Mov);
3755	INTERPRET_FAILED_CASE(OP_STOSWD,StosWD);
3756	INTERPRET_FAILED_CASE(OP_INVLPG,InvlPg);
3757	INTERPRET_FAILED_CASE(OP_CPUID,CpuId);
3758	INTERPRET_FAILED_CASE(OP_MOV_CR,MovCRx);
3759	INTERPRET_FAILED_CASE(OP_MOV_DR,MovDRx);
3760	INTERPRET_FAILED_CASE(OP_LLDT,LLdt);
3761	INTERPRET_FAILED_CASE(OP_LIDT,LIdt);
3762	INTERPRET_FAILED_CASE(OP_LGDT,LGdt);
3763	INTERPRET_FAILED_CASE(OP_LMSW,Lmsw);
3764	INTERPRET_FAILED_CASE(OP_CLTS,Clts);
3765	INTERPRET_FAILED_CASE(OP_MONITOR,Monitor);
3766	INTERPRET_FAILED_CASE(OP_MWAIT,MWait);
3767	INTERPRET_FAILED_CASE(OP_RDMSR,Rdmsr);
3768	INTERPRET_FAILED_CASE(OP_WRMSR,Wrmsr);
3769	INTERPRET_FAILED_CASE(OP_ADD,Add);
3770	INTERPRET_FAILED_CASE(OP_SUB,Sub);
3771	INTERPRET_FAILED_CASE(OP_ADC,Adc);
3772	INTERPRET_FAILED_CASE(OP_BTR,Btr);
3773	INTERPRET_FAILED_CASE(OP_BTS,Bts);
3774	INTERPRET_FAILED_CASE(OP_BTC,Btc);
3775	INTERPRET_FAILED_CASE(OP_RDTSC,Rdtsc);
3776	INTERPRET_FAILED_CASE(OP_CMPXCHG, CmpXchg);
3777	INTERPRET_FAILED_CASE(OP_STI, Sti);
3778	INTERPRET_FAILED_CASE(OP_XADD,XAdd);
3779	INTERPRET_FAILED_CASE(OP_CMPXCHG8B,CmpXchg8b);
3780	INTERPRET_FAILED_CASE(OP_HLT, Hlt);
3781	INTERPRET_FAILED_CASE(OP_IRET,Iret);
3782	INTERPRET_FAILED_CASE(OP_WBINVD,WbInvd);
3783	INTERPRET_FAILED_CASE(OP_MOVNTPS,MovNTPS);
3784	# undef INTERPRET_FAILED_CASE
3785	default:
3786	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedMisc));
3787	break;
3788	}
3789	# endif /* VBOX_WITH_STATISTICS */
3790	Log4(("EM: Refuse %u on grounds of accessing %u bytes\n", pDis->pCurInstr->uOpcode, pDis->Param1.cb));
3791	return VERR_EM_INTERPRETER;
3792	}
3793	}
3794	#endif
3795
3796	VBOXSTRICTRC rc;
3797	#if (defined(VBOX_STRICT) \|\| defined(LOG_ENABLED))
3798	LogFlow(("emInterpretInstructionCPU %s\n", emGetMnemonic(pDis)));
3799	#endif
3800	switch (pDis->pCurInstr->uOpcode)
3801	{
3802	/*
3803	* Macros for generating the right case statements.
3804	*/
3805	# ifndef VBOX_COMPARE_IEM_AND_EM
3806	# define INTERPRET_CASE_EX_LOCK_PARAM3(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock) \
3807	case opcode:\
3808	if (pDis->fPrefix & DISPREFIX_LOCK) \
3809	rc = emInterpretLock##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulateLock); \
3810	else \
3811	rc = emInterpret##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulate); \
3812	if (RT_SUCCESS(rc)) \
3813	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
3814	else \
3815	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
3816	return rc
3817	# else /* VBOX_COMPARE_IEM_AND_EM */
3818	# define INTERPRET_CASE_EX_LOCK_PARAM3(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock) \
3819	case opcode:\
3820	rc = emInterpret##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulate); \
3821	if (RT_SUCCESS(rc)) \
3822	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
3823	else \
3824	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
3825	return rc
3826	# endif /* VBOX_COMPARE_IEM_AND_EM */
3827
3828	#define INTERPRET_CASE_EX_PARAM3(opcode, Instr, InstrFn, pfnEmulate) \
3829	case opcode:\
3830	rc = emInterpret##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulate); \
3831	if (RT_SUCCESS(rc)) \
3832	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
3833	else \
3834	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
3835	return rc
3836
3837	#define INTERPRET_CASE_EX_PARAM2(opcode, Instr, InstrFn, pfnEmulate) \
3838	INTERPRET_CASE_EX_PARAM3(opcode, Instr, InstrFn, pfnEmulate)
3839	#define INTERPRET_CASE_EX_LOCK_PARAM2(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock) \
3840	INTERPRET_CASE_EX_LOCK_PARAM3(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock)
3841
3842	#define INTERPRET_CASE(opcode, Instr) \
3843	case opcode:\
3844	rc = emInterpret##Instr(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize); \
3845	if (RT_SUCCESS(rc)) \
3846	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
3847	else \
3848	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
3849	return rc
3850
3851	#define INTERPRET_CASE_EX_DUAL_PARAM2(opcode, Instr, InstrFn) \
3852	case opcode:\
3853	rc = emInterpret##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize); \
3854	if (RT_SUCCESS(rc)) \
3855	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
3856	else \
3857	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
3858	return rc
3859
3860	#define INTERPRET_STAT_CASE(opcode, Instr) \
3861	case opcode: STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); return VERR_EM_INTERPRETER;
3862
3863	/*
3864	* The actual case statements.
3865	*/
3866	INTERPRET_CASE(OP_XCHG,Xchg);
3867	INTERPRET_CASE_EX_PARAM2(OP_DEC,Dec, IncDec, EMEmulateDec);
3868	INTERPRET_CASE_EX_PARAM2(OP_INC,Inc, IncDec, EMEmulateInc);
3869	INTERPRET_CASE(OP_POP,Pop);
3870	INTERPRET_CASE_EX_LOCK_PARAM3(OP_OR, Or, OrXorAnd, EMEmulateOr, EMEmulateLockOr);
3871	INTERPRET_CASE_EX_LOCK_PARAM3(OP_XOR,Xor, OrXorAnd, EMEmulateXor, EMEmulateLockXor);
3872	INTERPRET_CASE_EX_LOCK_PARAM3(OP_AND,And, OrXorAnd, EMEmulateAnd, EMEmulateLockAnd);
3873	INTERPRET_CASE(OP_MOV,Mov);
3874	#ifndef IN_RC
3875	INTERPRET_CASE(OP_STOSWD,StosWD);
3876	#endif
3877	INTERPRET_CASE(OP_INVLPG,InvlPg);
3878	INTERPRET_CASE(OP_CPUID,CpuId);
3879	INTERPRET_CASE(OP_MOV_CR,MovCRx);
3880	INTERPRET_CASE(OP_MOV_DR,MovDRx);
3881	#ifdef IN_RING0
3882	INTERPRET_CASE_EX_DUAL_PARAM2(OP_LIDT, LIdt, LIGdt);
3883	INTERPRET_CASE_EX_DUAL_PARAM2(OP_LGDT, LGdt, LIGdt);
3884	#endif
3885	INTERPRET_CASE(OP_LLDT,LLdt);
3886	INTERPRET_CASE(OP_LMSW,Lmsw);
3887	#ifdef EM_EMULATE_SMSW
3888	INTERPRET_CASE(OP_SMSW,Smsw);
3889	#endif
3890	INTERPRET_CASE(OP_CLTS,Clts);
3891	INTERPRET_CASE(OP_MONITOR, Monitor);
3892	INTERPRET_CASE(OP_MWAIT, MWait);
3893	INTERPRET_CASE(OP_RDMSR, Rdmsr);
3894	INTERPRET_CASE(OP_WRMSR, Wrmsr);
3895	INTERPRET_CASE_EX_PARAM3(OP_ADD,Add, AddSub, EMEmulateAdd);
3896	INTERPRET_CASE_EX_PARAM3(OP_SUB,Sub, AddSub, EMEmulateSub);
3897	INTERPRET_CASE(OP_ADC,Adc);
3898	INTERPRET_CASE_EX_LOCK_PARAM2(OP_BTR,Btr, BitTest, EMEmulateBtr, EMEmulateLockBtr);
3899	INTERPRET_CASE_EX_PARAM2(OP_BTS,Bts, BitTest, EMEmulateBts);
3900	INTERPRET_CASE_EX_PARAM2(OP_BTC,Btc, BitTest, EMEmulateBtc);
3901	INTERPRET_CASE(OP_RDPMC,Rdpmc);
3902	INTERPRET_CASE(OP_RDTSC,Rdtsc);
3903	INTERPRET_CASE(OP_CMPXCHG, CmpXchg);
3904	#ifdef IN_RC
3905	INTERPRET_CASE(OP_STI,Sti);
3906	INTERPRET_CASE(OP_XADD, XAdd);
3907	INTERPRET_CASE(OP_IRET,Iret);
3908	#endif
3909	INTERPRET_CASE(OP_CMPXCHG8B, CmpXchg8b);
3910	INTERPRET_CASE(OP_HLT,Hlt);
3911	INTERPRET_CASE(OP_WBINVD,WbInvd);
3912	#ifdef VBOX_WITH_STATISTICS
3913	# ifndef IN_RC
3914	INTERPRET_STAT_CASE(OP_XADD, XAdd);
3915	# endif
3916	INTERPRET_STAT_CASE(OP_MOVNTPS,MovNTPS);
3917	#endif
3918
3919	default:
3920	Log3(("emInterpretInstructionCPU: opcode=%d\n", pDis->pCurInstr->uOpcode));
3921	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedMisc));
3922	return VERR_EM_INTERPRETER;
3923
3924	#undef INTERPRET_CASE_EX_PARAM2
3925	#undef INTERPRET_STAT_CASE
3926	#undef INTERPRET_CASE_EX
3927	#undef INTERPRET_CASE
3928	} /* switch (opcode) */
3929	/* not reached */
3930	}
3931
3932	/**
3933	* Interprets the current instruction using the supplied DISCPUSTATE structure.
3934	*
3935	* EIP is NOT updated!
3936	*
3937	* @returns VBox strict status code.
3938	* @retval VINF_* Scheduling instructions. When these are returned, it
3939	* starts to get a bit tricky to know whether code was
3940	* executed or not... We'll address this when it becomes a problem.
3941	* @retval VERR_EM_INTERPRETER Something we can't cope with.
3942	* @retval VERR_* Fatal errors.
3943	*
3944	* @param pVCpu The cross context virtual CPU structure.
3945	* @param pDis The disassembler cpu state for the instruction to be
3946	* interpreted.
3947	* @param pRegFrame The register frame. EIP is NOT changed!
3948	* @param pvFault The fault address (CR2).
3949	* @param pcbSize Size of the write (if applicable).
3950	* @param enmCodeType Code type (user/supervisor)
3951	*
3952	* @remark Invalid opcode exceptions have a higher priority than GP (see Intel
3953	* Architecture System Developers Manual, Vol 3, 5.5) so we don't need
3954	* to worry about e.g. invalid modrm combinations (!)
3955	*
3956	* @todo At this time we do NOT check if the instruction overwrites vital information.
3957	* Make sure this can't happen!! (will add some assertions/checks later)
3958	*/
3959	DECLINLINE(VBOXSTRICTRC) emInterpretInstructionCPUOuter(PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame,
3960	RTGCPTR pvFault, EMCODETYPE enmCodeType, uint32_t *pcbSize)
3961	{
3962	STAM_PROFILE_START(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Emulate), a);
3963	VBOXSTRICTRC rc = emInterpretInstructionCPU(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, pRegFrame, pvFault, enmCodeType, pcbSize);
3964	STAM_PROFILE_STOP(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Emulate), a);
3965	if (RT_SUCCESS(rc))
3966	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InterpretSucceeded));
3967	else
3968	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InterpretFailed));
3969	return rc;
3970	}
3971
3972
3973	#endif /* !VBOX_WITH_IEM */

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/VMM/VMMAll/EMAll.cpp@ 65504

Download in other formats: