EMAll.cpp@ 31631

Last change on this file since 31631 was 31569, checked in by vboxsync, 14 years ago
HWACCM: burn fix / VBOXSTRICTRC cleanup - a bit risky...
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 106.4 KB

Line
1	/* $Id: EMAll.cpp 31569 2010-08-11 13:41:52Z vboxsync $ */
2	/** @file
3	* EM - Execution Monitor(/Manager) - All contexts
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 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	* Header Files *
20	*******************************************************************************/
21	#define LOG_GROUP LOG_GROUP_EM
22	#include <VBox/em.h>
23	#include <VBox/mm.h>
24	#include <VBox/selm.h>
25	#include <VBox/patm.h>
26	#include <VBox/csam.h>
27	#include <VBox/pgm.h>
28	#include <VBox/iom.h>
29	#include <VBox/stam.h>
30	#include "EMInternal.h"
31	#include <VBox/vm.h>
32	#include <VBox/vmm.h>
33	#include <VBox/hwaccm.h>
34	#include <VBox/tm.h>
35	#include <VBox/pdmapi.h>
36	#include <VBox/param.h>
37	#include <VBox/err.h>
38	#include <VBox/dis.h>
39	#include <VBox/disopcode.h>
40	#include <VBox/log.h>
41	#include <include/internal/pgm.h>
42	#include <iprt/assert.h>
43	#include <iprt/asm.h>
44	#include <iprt/string.h>
45
46
47	/*******************************************************************************
48	* Defined Constants And Macros *
49	*******************************************************************************/
50	/** @def EM_ASSERT_FAULT_RETURN
51	* Safety check.
52	*
53	* Could in theory misfire on a cross page boundary access...
54	*
55	* Currently disabled because the CSAM (+ PATM) patch monitoring occasionally
56	* turns up an alias page instead of the original faulting one and annoying the
57	* heck out of anyone running a debug build. See @bugref{2609} and @bugref{1931}.
58	*/
59	#if 0
60	# define EM_ASSERT_FAULT_RETURN(expr, rc) AssertReturn(expr, rc)
61	#else
62	# define EM_ASSERT_FAULT_RETURN(expr, rc) do { } while (0)
63	#endif
64
65	/* Used to pass information during instruction disassembly. */
66	typedef struct
67	{
68	PVM pVM;
69	PVMCPU pVCpu;
70	RTGCPTR GCPtr;
71	uint8_t aOpcode[8];
72	} EMDISSTATE, *PEMDISSTATE;
73
74	/*******************************************************************************
75	* Internal Functions *
76	*******************************************************************************/
77	DECLINLINE(int) emInterpretInstructionCPU(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize, EMCODETYPE enmCodeType = EMCODETYPE_SUPERVISOR);
78
79
80
81	/**
82	* Get the current execution manager status.
83	*
84	* @returns Current status.
85	* @param pVCpu The VMCPU to operate on.
86	*/
87	VMMDECL(EMSTATE) EMGetState(PVMCPU pVCpu)
88	{
89	return pVCpu->em.s.enmState;
90	}
91
92	/**
93	* Sets the current execution manager status. (use only when you know what you're doing!)
94	*
95	* @param pVCpu The VMCPU to operate on.
96	*/
97	VMMDECL(void) EMSetState(PVMCPU pVCpu, EMSTATE enmNewState)
98	{
99	/* Only allowed combination: */
100	Assert(pVCpu->em.s.enmState == EMSTATE_WAIT_SIPI && enmNewState == EMSTATE_HALTED);
101	pVCpu->em.s.enmState = enmNewState;
102	}
103
104
105	/**
106	* Read callback for disassembly function; supports reading bytes that cross a page boundary
107	*
108	* @returns VBox status code.
109	* @param pSrc GC source pointer
110	* @param pDest HC destination pointer
111	* @param cb Number of bytes to read
112	* @param dwUserdata Callback specific user data (pDis)
113	*
114	*/
115	DECLCALLBACK(int) EMReadBytes(RTUINTPTR pSrc, uint8_t pDest, unsigned cb, void pvUserdata)
116	{
117	PDISCPUSTATE pDis = (PDISCPUSTATE)pvUserdata;
118	PEMDISSTATE pState = (PEMDISSTATE)pDis->apvUserData[0];
119	PVM pVM = pState->pVM;
120	PVMCPU pVCpu = pState->pVCpu;
121
122	# ifdef IN_RING0
123	int rc;
124
125	if ( pState->GCPtr
126	&& pSrc + cb <= pState->GCPtr + sizeof(pState->aOpcode))
127	{
128	unsigned offset = pSrc - pState->GCPtr;
129
130	Assert(pSrc >= pState->GCPtr);
131
132	for (unsigned i=0; i<cb; i++)
133	{
134	pDest[i] = pState->aOpcode[offset + i];
135	}
136	return VINF_SUCCESS;
137	}
138
139	rc = PGMPhysSimpleReadGCPtr(pVCpu, pDest, pSrc, cb);
140	AssertMsgRC(rc, ("PGMPhysSimpleReadGCPtr failed for pSrc=%RGv cb=%x rc=%d\n", pSrc, cb, rc));
141	# elif defined(IN_RING3)
142	if (!PATMIsPatchGCAddr(pVM, pSrc))
143	{
144	int rc = PGMPhysSimpleReadGCPtr(pVCpu, pDest, pSrc, cb);
145	AssertRC(rc);
146	}
147	else
148	memcpy(pDest, PATMR3GCPtrToHCPtr(pVM, pSrc), cb);
149
150	# elif defined(IN_RC)
151	if (!PATMIsPatchGCAddr(pVM, pSrc))
152	{
153	int rc = MMGCRamRead(pVM, pDest, (void *)(uintptr_t)pSrc, cb);
154	if (rc == VERR_ACCESS_DENIED)
155	{
156	/* Recently flushed; access the data manually. */
157	rc = PGMPhysSimpleReadGCPtr(pVCpu, pDest, pSrc, cb);
158	AssertRC(rc);
159	}
160	}
161	else /* the hypervisor region is always present. */
162	memcpy(pDest, (RTRCPTR)(uintptr_t)pSrc, cb);
163
164	# endif /* IN_RING3 */
165	return VINF_SUCCESS;
166	}
167
168
169	#ifndef IN_RC
170	DECLINLINE(int) emDisCoreOne(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, RTGCUINTPTR InstrGC, uint32_t *pOpsize)
171	{
172	EMDISSTATE State;
173
174	State.pVM = pVM;
175	State.pVCpu = pVCpu;
176	int rc = PGMPhysSimpleReadGCPtr(pVCpu, &State.aOpcode, InstrGC, sizeof(State.aOpcode));
177	if (RT_SUCCESS(rc))
178	{
179	State.GCPtr = InstrGC;
180	}
181	else
182	{
183	if (PAGE_ADDRESS(InstrGC) == PAGE_ADDRESS(InstrGC + sizeof(State.aOpcode) - 1))
184	{
185	if (rc == VERR_PAGE_TABLE_NOT_PRESENT)
186	HWACCMInvalidatePage(pVCpu, InstrGC);
187
188	Log(("emDisCoreOne: read failed with %d\n", rc));
189	return rc;
190	}
191	State.GCPtr = NIL_RTGCPTR;
192	}
193	return DISCoreOneEx(InstrGC, pDis->mode, EMReadBytes, &State, pDis, pOpsize);
194	}
195
196	#else /* IN_RC */
197
198	DECLINLINE(int) emDisCoreOne(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, RTGCUINTPTR InstrGC, uint32_t *pOpsize)
199	{
200	EMDISSTATE State;
201
202	State.pVM = pVM;
203	State.pVCpu = pVCpu;
204	State.GCPtr = InstrGC;
205
206	return DISCoreOneEx(InstrGC, pDis->mode, EMReadBytes, &State, pDis, pOpsize);
207	}
208
209	#endif /* IN_RC */
210
211
212	/**
213	* Disassembles one instruction.
214	*
215	* @returns VBox status code, see SELMToFlatEx and EMInterpretDisasOneEx for
216	* details.
217	* @retval VERR_INTERNAL_ERROR on DISCoreOneEx failure.
218	*
219	* @param pVM The VM handle.
220	* @param pVCpu The VMCPU handle.
221	* @param pCtxCore The context core (used for both the mode and instruction).
222	* @param pDis Where to return the parsed instruction info.
223	* @param pcbInstr Where to return the instruction size. (optional)
224	*/
225	VMMDECL(int) EMInterpretDisasOne(PVM pVM, PVMCPU pVCpu, PCCPUMCTXCORE pCtxCore, PDISCPUSTATE pDis, unsigned *pcbInstr)
226	{
227	RTGCPTR GCPtrInstr;
228	int rc = SELMToFlatEx(pVM, DIS_SELREG_CS, pCtxCore, pCtxCore->rip, 0, &GCPtrInstr);
229	if (RT_FAILURE(rc))
230	{
231	Log(("EMInterpretDisasOne: Failed to convert %RTsel:%RGv (cpl=%d) - rc=%Rrc !!\n",
232	pCtxCore->cs, (RTGCPTR)pCtxCore->rip, pCtxCore->ss & X86_SEL_RPL, rc));
233	return rc;
234	}
235	return EMInterpretDisasOneEx(pVM, pVCpu, (RTGCUINTPTR)GCPtrInstr, pCtxCore, pDis, pcbInstr);
236	}
237
238
239	/**
240	* Disassembles one instruction.
241	*
242	* This is used by internally by the interpreter and by trap/access handlers.
243	*
244	* @returns VBox status code.
245	* @retval VERR_INTERNAL_ERROR on DISCoreOneEx failure.
246	*
247	* @param pVM The VM handle.
248	* @param pVCpu The VMCPU handle.
249	* @param GCPtrInstr The flat address of the instruction.
250	* @param pCtxCore The context core (used to determine the cpu mode).
251	* @param pDis Where to return the parsed instruction info.
252	* @param pcbInstr Where to return the instruction size. (optional)
253	*/
254	VMMDECL(int) EMInterpretDisasOneEx(PVM pVM, PVMCPU pVCpu, RTGCUINTPTR GCPtrInstr, PCCPUMCTXCORE pCtxCore, PDISCPUSTATE pDis, unsigned *pcbInstr)
255	{
256	int rc;
257	EMDISSTATE State;
258
259	State.pVM = pVM;
260	State.pVCpu = pVCpu;
261
262	#ifdef IN_RC
263	State.GCPtr = GCPtrInstr;
264	#else /* ring 0/3 */
265	rc = PGMPhysSimpleReadGCPtr(pVCpu, &State.aOpcode, GCPtrInstr, sizeof(State.aOpcode));
266	if (RT_SUCCESS(rc))
267	{
268	State.GCPtr = GCPtrInstr;
269	}
270	else
271	{
272	if (PAGE_ADDRESS(GCPtrInstr) == PAGE_ADDRESS(GCPtrInstr + sizeof(State.aOpcode) - 1))
273	{
274	if (rc == VERR_PAGE_TABLE_NOT_PRESENT)
275	HWACCMInvalidatePage(pVCpu, GCPtrInstr);
276
277	Log(("EMInterpretDisasOneEx: read failed with %d\n", rc));
278	return rc;
279	}
280	State.GCPtr = NIL_RTGCPTR;
281	}
282	#endif
283
284	rc = DISCoreOneEx(GCPtrInstr, SELMGetCpuModeFromSelector(pVM, pCtxCore->eflags, pCtxCore->cs, (PCPUMSELREGHID)&pCtxCore->csHid),
285	EMReadBytes, &State,
286	pDis, pcbInstr);
287	if (RT_SUCCESS(rc))
288	return VINF_SUCCESS;
289	AssertMsgFailed(("DISCoreOne failed to GCPtrInstr=%RGv rc=%Rrc\n", GCPtrInstr, rc));
290	return VERR_INTERNAL_ERROR;
291	}
292
293
294	/**
295	* Interprets the current instruction.
296	*
297	* @returns VBox status code.
298	* @retval VINF_* Scheduling instructions.
299	* @retval VERR_EM_INTERPRETER Something we can't cope with.
300	* @retval VERR_* Fatal errors.
301	*
302	* @param pVM The VM handle.
303	* @param pVCpu The VMCPU handle.
304	* @param pRegFrame The register frame.
305	* Updates the EIP if an instruction was executed successfully.
306	* @param pvFault The fault address (CR2).
307	* @param pcbSize Size of the write (if applicable).
308	*
309	* @remark Invalid opcode exceptions have a higher priority than GP (see Intel
310	* Architecture System Developers Manual, Vol 3, 5.5) so we don't need
311	* to worry about e.g. invalid modrm combinations (!)
312	*/
313	VMMDECL(int) EMInterpretInstruction(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
314	{
315	RTGCPTR pbCode;
316
317	LogFlow(("EMInterpretInstruction %RGv fault %RGv\n", (RTGCPTR)pRegFrame->rip, pvFault));
318	int rc = SELMToFlatEx(pVM, DIS_SELREG_CS, pRegFrame, pRegFrame->rip, 0, &pbCode);
319	if (RT_SUCCESS(rc))
320	{
321	uint32_t cbOp;
322	PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
323	pDis->mode = SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
324	rc = emDisCoreOne(pVM, pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
325	if (RT_SUCCESS(rc))
326	{
327	Assert(cbOp == pDis->opsize);
328	rc = EMInterpretInstructionCPU(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize);
329	if (RT_SUCCESS(rc))
330	pRegFrame->rip += cbOp; /* Move on to the next instruction. */
331
332	return rc;
333	}
334	}
335	return VERR_EM_INTERPRETER;
336	}
337
338
339	/**
340	* Interprets the current instruction using the supplied DISCPUSTATE structure.
341	*
342	* EIP is NOT updated!
343	*
344	* @returns VBox status code.
345	* @retval VINF_* Scheduling instructions. When these are returned, it
346	* starts to get a bit tricky to know whether code was
347	* executed or not... We'll address this when it becomes a problem.
348	* @retval VERR_EM_INTERPRETER Something we can't cope with.
349	* @retval VERR_* Fatal errors.
350	*
351	* @param pVM The VM handle.
352	* @param pVCpu The VMCPU handle.
353	* @param pDis The disassembler cpu state for the instruction to be
354	* interpreted.
355	* @param pRegFrame The register frame. EIP is NOT changed!
356	* @param pvFault The fault address (CR2).
357	* @param pcbSize Size of the write (if applicable).
358	* @param enmCodeType Code type (user/supervisor)
359	*
360	* @remark Invalid opcode exceptions have a higher priority than GP (see Intel
361	* Architecture System Developers Manual, Vol 3, 5.5) so we don't need
362	* to worry about e.g. invalid modrm combinations (!)
363	*
364	* @todo At this time we do NOT check if the instruction overwrites vital information.
365	* Make sure this can't happen!! (will add some assertions/checks later)
366	*/
367	VMMDECL(int) EMInterpretInstructionCPUEx(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize, EMCODETYPE enmCodeType)
368	{
369	STAM_PROFILE_START(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Emulate), a);
370	int rc = emInterpretInstructionCPU(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, enmCodeType);
371	STAM_PROFILE_STOP(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Emulate), a);
372	if (RT_SUCCESS(rc))
373	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InterpretSucceeded));
374	else
375	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InterpretFailed));
376	return rc;
377	}
378
379
380	/**
381	* Interpret a port I/O instruction.
382	*
383	* @returns VBox status code suitable for scheduling.
384	* @param pVM The VM handle.
385	* @param pVCpu The VMCPU handle.
386	* @param pCtxCore The context core. This will be updated on successful return.
387	* @param pDis The instruction to interpret.
388	* @param cbOp The size of the instruction.
389	* @remark This may raise exceptions.
390	*/
391	VMMDECL(VBOXSTRICTRC) EMInterpretPortIO(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, PDISCPUSTATE pDis, uint32_t cbOp)
392	{
393	/*
394	* Hand it on to IOM.
395	*/
396	#ifdef IN_RC
397	VBOXSTRICTRC rcStrict = IOMGCIOPortHandler(pVM, pCtxCore, pDis);
398	if (IOM_SUCCESS(rcStrict))
399	pCtxCore->rip += cbOp;
400	return rcStrict;
401	#else
402	AssertReleaseMsgFailed(("not implemented\n"));
403	return VERR_NOT_IMPLEMENTED;
404	#endif
405	}
406
407
408	DECLINLINE(int) emRamRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, void *pvDst, RTGCPTR GCPtrSrc, uint32_t cb)
409	{
410	#ifdef IN_RC
411	int rc = MMGCRamRead(pVM, pvDst, (void *)(uintptr_t)GCPtrSrc, cb);
412	if (RT_LIKELY(rc != VERR_ACCESS_DENIED))
413	return rc;
414	/*
415	* The page pool cache may end up here in some cases because it
416	* flushed one of the shadow mappings used by the trapping
417	* instruction and it either flushed the TLB or the CPU reused it.
418	*/
419	#endif
420	return PGMPhysInterpretedReadNoHandlers(pVCpu, pCtxCore, pvDst, GCPtrSrc, cb, /fMayTrap/ false);
421	}
422
423
424	DECLINLINE(int) emRamWrite(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pCtxCore, RTGCPTR GCPtrDst, const void *pvSrc, uint32_t cb)
425	{
426	/* Don't use MMGCRamWrite here as it does not respect zero pages, shared
427	pages or write monitored pages. */
428	return PGMPhysInterpretedWriteNoHandlers(pVCpu, pCtxCore, GCPtrDst, pvSrc, cb, /fMayTrap/ false);
429	}
430
431
432	/** Convert sel:addr to a flat GC address. */
433	DECLINLINE(RTGCPTR) emConvertToFlatAddr(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pDis, POP_PARAMETER pParam, RTGCPTR pvAddr)
434	{
435	DIS_SELREG enmPrefixSeg = DISDetectSegReg(pDis, pParam);
436	return SELMToFlat(pVM, enmPrefixSeg, pRegFrame, pvAddr);
437	}
438
439
440	#if defined(VBOX_STRICT) \|\| defined(LOG_ENABLED)
441	/**
442	* Get the mnemonic for the disassembled instruction.
443	*
444	* GC/R0 doesn't include the strings in the DIS tables because
445	* of limited space.
446	*/
447	static const char *emGetMnemonic(PDISCPUSTATE pDis)
448	{
449	switch (pDis->pCurInstr->opcode)
450	{
451	case OP_XCHG: return "Xchg";
452	case OP_DEC: return "Dec";
453	case OP_INC: return "Inc";
454	case OP_POP: return "Pop";
455	case OP_OR: return "Or";
456	case OP_AND: return "And";
457	case OP_MOV: return "Mov";
458	case OP_INVLPG: return "InvlPg";
459	case OP_CPUID: return "CpuId";
460	case OP_MOV_CR: return "MovCRx";
461	case OP_MOV_DR: return "MovDRx";
462	case OP_LLDT: return "LLdt";
463	case OP_LGDT: return "LGdt";
464	case OP_LIDT: return "LIdt";
465	case OP_CLTS: return "Clts";
466	case OP_MONITOR: return "Monitor";
467	case OP_MWAIT: return "MWait";
468	case OP_RDMSR: return "Rdmsr";
469	case OP_WRMSR: return "Wrmsr";
470	case OP_ADD: return "Add";
471	case OP_ADC: return "Adc";
472	case OP_SUB: return "Sub";
473	case OP_SBB: return "Sbb";
474	case OP_RDTSC: return "Rdtsc";
475	case OP_STI: return "Sti";
476	case OP_CLI: return "Cli";
477	case OP_XADD: return "XAdd";
478	case OP_HLT: return "Hlt";
479	case OP_IRET: return "Iret";
480	case OP_MOVNTPS: return "MovNTPS";
481	case OP_STOSWD: return "StosWD";
482	case OP_WBINVD: return "WbInvd";
483	case OP_XOR: return "Xor";
484	case OP_BTR: return "Btr";
485	case OP_BTS: return "Bts";
486	case OP_BTC: return "Btc";
487	case OP_LMSW: return "Lmsw";
488	case OP_SMSW: return "Smsw";
489	case OP_CMPXCHG: return pDis->prefix & PREFIX_LOCK ? "Lock CmpXchg" : "CmpXchg";
490	case OP_CMPXCHG8B: return pDis->prefix & PREFIX_LOCK ? "Lock CmpXchg8b" : "CmpXchg8b";
491
492	default:
493	Log(("Unknown opcode %d\n", pDis->pCurInstr->opcode));
494	return "???";
495	}
496	}
497	#endif /* VBOX_STRICT \|\| LOG_ENABLED */
498
499
500	/**
501	* XCHG instruction emulation.
502	*/
503	static int emInterpretXchg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
504	{
505	OP_PARAMVAL param1, param2;
506
507	/* Source to make DISQueryParamVal read the register value - ugly hack */
508	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
509	if(RT_FAILURE(rc))
510	return VERR_EM_INTERPRETER;
511
512	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
513	if(RT_FAILURE(rc))
514	return VERR_EM_INTERPRETER;
515
516	#ifdef IN_RC
517	if (TRPMHasTrap(pVCpu))
518	{
519	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
520	{
521	#endif
522	RTGCPTR pParam1 = 0, pParam2 = 0;
523	uint64_t valpar1, valpar2;
524
525	AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
526	switch(param1.type)
527	{
528	case PARMTYPE_IMMEDIATE: /* register type is translated to this one too */
529	valpar1 = param1.val.val64;
530	break;
531
532	case PARMTYPE_ADDRESS:
533	pParam1 = (RTGCPTR)param1.val.val64;
534	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
535	EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
536	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
537	if (RT_FAILURE(rc))
538	{
539	AssertMsgFailed(("MMGCRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
540	return VERR_EM_INTERPRETER;
541	}
542	break;
543
544	default:
545	AssertFailed();
546	return VERR_EM_INTERPRETER;
547	}
548
549	switch(param2.type)
550	{
551	case PARMTYPE_ADDRESS:
552	pParam2 = (RTGCPTR)param2.val.val64;
553	pParam2 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param2, pParam2);
554	EM_ASSERT_FAULT_RETURN(pParam2 == pvFault, VERR_EM_INTERPRETER);
555	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar2, pParam2, param2.size);
556	if (RT_FAILURE(rc))
557	{
558	AssertMsgFailed(("MMGCRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
559	}
560	break;
561
562	case PARMTYPE_IMMEDIATE:
563	valpar2 = param2.val.val64;
564	break;
565
566	default:
567	AssertFailed();
568	return VERR_EM_INTERPRETER;
569	}
570
571	/* Write value of parameter 2 to parameter 1 (reg or memory address) */
572	if (pParam1 == 0)
573	{
574	Assert(param1.type == PARMTYPE_IMMEDIATE); /* register actually */
575	switch(param1.size)
576	{
577	case 1: //special case for AH etc
578	rc = DISWriteReg8(pRegFrame, pDis->param1.base.reg_gen, (uint8_t )valpar2); break;
579	case 2: rc = DISWriteReg16(pRegFrame, pDis->param1.base.reg_gen, (uint16_t)valpar2); break;
580	case 4: rc = DISWriteReg32(pRegFrame, pDis->param1.base.reg_gen, (uint32_t)valpar2); break;
581	case 8: rc = DISWriteReg64(pRegFrame, pDis->param1.base.reg_gen, valpar2); break;
582	default: AssertFailedReturn(VERR_EM_INTERPRETER);
583	}
584	if (RT_FAILURE(rc))
585	return VERR_EM_INTERPRETER;
586	}
587	else
588	{
589	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar2, param1.size);
590	if (RT_FAILURE(rc))
591	{
592	AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
593	return VERR_EM_INTERPRETER;
594	}
595	}
596
597	/* Write value of parameter 1 to parameter 2 (reg or memory address) */
598	if (pParam2 == 0)
599	{
600	Assert(param2.type == PARMTYPE_IMMEDIATE); /* register actually */
601	switch(param2.size)
602	{
603	case 1: //special case for AH etc
604	rc = DISWriteReg8(pRegFrame, pDis->param2.base.reg_gen, (uint8_t )valpar1); break;
605	case 2: rc = DISWriteReg16(pRegFrame, pDis->param2.base.reg_gen, (uint16_t)valpar1); break;
606	case 4: rc = DISWriteReg32(pRegFrame, pDis->param2.base.reg_gen, (uint32_t)valpar1); break;
607	case 8: rc = DISWriteReg64(pRegFrame, pDis->param2.base.reg_gen, valpar1); break;
608	default: AssertFailedReturn(VERR_EM_INTERPRETER);
609	}
610	if (RT_FAILURE(rc))
611	return VERR_EM_INTERPRETER;
612	}
613	else
614	{
615	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam2, &valpar1, param2.size);
616	if (RT_FAILURE(rc))
617	{
618	AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
619	return VERR_EM_INTERPRETER;
620	}
621	}
622
623	*pcbSize = param2.size;
624	return VINF_SUCCESS;
625	#ifdef IN_RC
626	}
627	}
628	#endif
629	return VERR_EM_INTERPRETER;
630	}
631
632
633	/**
634	* INC and DEC emulation.
635	*/
636	static int emInterpretIncDec(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
637	PFNEMULATEPARAM2 pfnEmulate)
638	{
639	OP_PARAMVAL param1;
640
641	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
642	if(RT_FAILURE(rc))
643	return VERR_EM_INTERPRETER;
644
645	#ifdef IN_RC
646	if (TRPMHasTrap(pVCpu))
647	{
648	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
649	{
650	#endif
651	RTGCPTR pParam1 = 0;
652	uint64_t valpar1;
653
654	if (param1.type == PARMTYPE_ADDRESS)
655	{
656	pParam1 = (RTGCPTR)param1.val.val64;
657	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
658	#ifdef IN_RC
659	/* Safety check (in theory it could cross a page boundary and fault there though) */
660	AssertReturn(pParam1 == pvFault, VERR_EM_INTERPRETER);
661	#endif
662	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
663	if (RT_FAILURE(rc))
664	{
665	AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
666	return VERR_EM_INTERPRETER;
667	}
668	}
669	else
670	{
671	AssertFailed();
672	return VERR_EM_INTERPRETER;
673	}
674
675	uint32_t eflags;
676
677	eflags = pfnEmulate(&valpar1, param1.size);
678
679	/* Write result back */
680	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
681	if (RT_FAILURE(rc))
682	{
683	AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
684	return VERR_EM_INTERPRETER;
685	}
686
687	/* Update guest's eflags and finish. */
688	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
689	\| (eflags & (X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
690
691	/* All done! */
692	*pcbSize = param1.size;
693	return VINF_SUCCESS;
694	#ifdef IN_RC
695	}
696	}
697	#endif
698	return VERR_EM_INTERPRETER;
699	}
700
701
702	/**
703	* POP Emulation.
704	*/
705	static int emInterpretPop(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
706	{
707	Assert(pDis->mode != CPUMODE_64BIT); /** @todo check */
708	OP_PARAMVAL param1;
709	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
710	if(RT_FAILURE(rc))
711	return VERR_EM_INTERPRETER;
712
713	#ifdef IN_RC
714	if (TRPMHasTrap(pVCpu))
715	{
716	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
717	{
718	#endif
719	RTGCPTR pParam1 = 0;
720	uint32_t valpar1;
721	RTGCPTR pStackVal;
722
723	/* Read stack value first */
724	if (SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->ss, &pRegFrame->ssHid) == CPUMODE_16BIT)
725	return VERR_EM_INTERPRETER; /* No legacy 16 bits stuff here, please. */
726
727	/* Convert address; don't bother checking limits etc, as we only read here */
728	pStackVal = SELMToFlat(pVM, DIS_SELREG_SS, pRegFrame, (RTGCPTR)pRegFrame->esp);
729	if (pStackVal == 0)
730	return VERR_EM_INTERPRETER;
731
732	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pStackVal, param1.size);
733	if (RT_FAILURE(rc))
734	{
735	AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
736	return VERR_EM_INTERPRETER;
737	}
738
739	if (param1.type == PARMTYPE_ADDRESS)
740	{
741	pParam1 = (RTGCPTR)param1.val.val64;
742
743	/* pop [esp+xx] uses esp after the actual pop! */
744	AssertCompile(USE_REG_ESP == USE_REG_SP);
745	if ( (pDis->param1.flags & USE_BASE)
746	&& (pDis->param1.flags & (USE_REG_GEN16\|USE_REG_GEN32))
747	&& pDis->param1.base.reg_gen == USE_REG_ESP
748	)
749	pParam1 = (RTGCPTR)((RTGCUINTPTR)pParam1 + param1.size);
750
751	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
752	EM_ASSERT_FAULT_RETURN(pParam1 == pvFault \|\| (RTGCPTR)pRegFrame->esp == pvFault, VERR_EM_INTERPRETER);
753	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
754	if (RT_FAILURE(rc))
755	{
756	AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
757	return VERR_EM_INTERPRETER;
758	}
759
760	/* Update ESP as the last step */
761	pRegFrame->esp += param1.size;
762	}
763	else
764	{
765	#ifndef DEBUG_bird // annoying assertion.
766	AssertFailed();
767	#endif
768	return VERR_EM_INTERPRETER;
769	}
770
771	/* All done! */
772	*pcbSize = param1.size;
773	return VINF_SUCCESS;
774	#ifdef IN_RC
775	}
776	}
777	#endif
778	return VERR_EM_INTERPRETER;
779	}
780
781
782	/**
783	* XOR/OR/AND Emulation.
784	*/
785	static int emInterpretOrXorAnd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
786	PFNEMULATEPARAM3 pfnEmulate)
787	{
788	OP_PARAMVAL param1, param2;
789
790	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
791	if(RT_FAILURE(rc))
792	return VERR_EM_INTERPRETER;
793
794	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
795	if(RT_FAILURE(rc))
796	return VERR_EM_INTERPRETER;
797
798	#ifdef IN_RC
799	if (TRPMHasTrap(pVCpu))
800	{
801	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
802	{
803	#endif
804	RTGCPTR pParam1;
805	uint64_t valpar1, valpar2;
806
807	if (pDis->param1.size != pDis->param2.size)
808	{
809	if (pDis->param1.size < pDis->param2.size)
810	{
811	AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size)); /* should never happen! */
812	return VERR_EM_INTERPRETER;
813	}
814	/* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
815	pDis->param2.size = pDis->param1.size;
816	param2.size = param1.size;
817	}
818
819	/* The destination is always a virtual address */
820	if (param1.type == PARMTYPE_ADDRESS)
821	{
822	pParam1 = (RTGCPTR)param1.val.val64;
823	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
824	EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
825	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
826	if (RT_FAILURE(rc))
827	{
828	AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
829	return VERR_EM_INTERPRETER;
830	}
831	}
832	else
833	{
834	AssertFailed();
835	return VERR_EM_INTERPRETER;
836	}
837
838	/* Register or immediate data */
839	switch(param2.type)
840	{
841	case PARMTYPE_IMMEDIATE: /* both immediate data and register (ugly) */
842	valpar2 = param2.val.val64;
843	break;
844
845	default:
846	AssertFailed();
847	return VERR_EM_INTERPRETER;
848	}
849
850	LogFlow(("emInterpretOrXorAnd %s %RGv %RX64 - %RX64 size %d (%d)\n", emGetMnemonic(pDis), pParam1, valpar1, valpar2, param2.size, param1.size));
851
852	/* Data read, emulate instruction. */
853	uint32_t eflags = pfnEmulate(&valpar1, valpar2, param2.size);
854
855	LogFlow(("emInterpretOrXorAnd %s result %RX64\n", emGetMnemonic(pDis), valpar1));
856
857	/* Update guest's eflags and finish. */
858	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
859	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
860
861	/* And write it back */
862	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
863	if (RT_SUCCESS(rc))
864	{
865	/* All done! */
866	*pcbSize = param2.size;
867	return VINF_SUCCESS;
868	}
869	#ifdef IN_RC
870	}
871	}
872	#endif
873	return VERR_EM_INTERPRETER;
874	}
875
876
877	/**
878	* LOCK XOR/OR/AND Emulation.
879	*/
880	static int emInterpretLockOrXorAnd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
881	uint32_t *pcbSize, PFNEMULATELOCKPARAM3 pfnEmulate)
882	{
883	void *pvParam1;
884	OP_PARAMVAL param1, param2;
885
886	#if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0)
887	Assert(pDis->param1.size <= 4);
888	#endif
889
890	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
891	if(RT_FAILURE(rc))
892	return VERR_EM_INTERPRETER;
893
894	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
895	if(RT_FAILURE(rc))
896	return VERR_EM_INTERPRETER;
897
898	if (pDis->param1.size != pDis->param2.size)
899	{
900	AssertMsgReturn(pDis->param1.size >= pDis->param2.size, /* should never happen! */
901	("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size),
902	VERR_EM_INTERPRETER);
903
904	/* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
905	pDis->param2.size = pDis->param1.size;
906	param2.size = param1.size;
907	}
908
909	#ifdef IN_RC
910	/* Safety check (in theory it could cross a page boundary and fault there though) */
911	Assert( TRPMHasTrap(pVCpu)
912	&& (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW));
913	EM_ASSERT_FAULT_RETURN(GCPtrPar1 == pvFault, VERR_EM_INTERPRETER);
914	#endif
915
916	/* Register and immediate data == PARMTYPE_IMMEDIATE */
917	AssertReturn(param2.type == PARMTYPE_IMMEDIATE, VERR_EM_INTERPRETER);
918	RTGCUINTREG ValPar2 = param2.val.val64;
919
920	/* The destination is always a virtual address */
921	AssertReturn(param1.type == PARMTYPE_ADDRESS, VERR_EM_INTERPRETER);
922
923	RTGCPTR GCPtrPar1 = param1.val.val64;
924	GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
925	PGMPAGEMAPLOCK Lock;
926	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
927	AssertRCReturn(rc, VERR_EM_INTERPRETER);
928
929	/* Try emulate it with a one-shot #PF handler in place. (RC) */
930	Log2(("%s %RGv imm%d=%RX64\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
931
932	RTGCUINTREG32 eflags = 0;
933	rc = pfnEmulate(pvParam1, ValPar2, pDis->param2.size, &eflags);
934	PGMPhysReleasePageMappingLock(pVM, &Lock);
935	if (RT_FAILURE(rc))
936	{
937	Log(("%s %RGv imm%d=%RX64-> emulation failed due to page fault!\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
938	return VERR_EM_INTERPRETER;
939	}
940
941	/* Update guest's eflags and finish. */
942	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
943	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
944
945	*pcbSize = param2.size;
946	return VINF_SUCCESS;
947	}
948
949
950	/**
951	* ADD, ADC & SUB Emulation.
952	*/
953	static int emInterpretAddSub(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
954	PFNEMULATEPARAM3 pfnEmulate)
955	{
956	OP_PARAMVAL param1, param2;
957	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
958	if(RT_FAILURE(rc))
959	return VERR_EM_INTERPRETER;
960
961	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
962	if(RT_FAILURE(rc))
963	return VERR_EM_INTERPRETER;
964
965	#ifdef IN_RC
966	if (TRPMHasTrap(pVCpu))
967	{
968	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
969	{
970	#endif
971	RTGCPTR pParam1;
972	uint64_t valpar1, valpar2;
973
974	if (pDis->param1.size != pDis->param2.size)
975	{
976	if (pDis->param1.size < pDis->param2.size)
977	{
978	AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size)); /* should never happen! */
979	return VERR_EM_INTERPRETER;
980	}
981	/* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
982	pDis->param2.size = pDis->param1.size;
983	param2.size = param1.size;
984	}
985
986	/* The destination is always a virtual address */
987	if (param1.type == PARMTYPE_ADDRESS)
988	{
989	pParam1 = (RTGCPTR)param1.val.val64;
990	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
991	EM_ASSERT_FAULT_RETURN(pParam1 == pvFault, VERR_EM_INTERPRETER);
992	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, param1.size);
993	if (RT_FAILURE(rc))
994	{
995	AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
996	return VERR_EM_INTERPRETER;
997	}
998	}
999	else
1000	{
1001	#ifndef DEBUG_bird
1002	AssertFailed();
1003	#endif
1004	return VERR_EM_INTERPRETER;
1005	}
1006
1007	/* Register or immediate data */
1008	switch(param2.type)
1009	{
1010	case PARMTYPE_IMMEDIATE: /* both immediate data and register (ugly) */
1011	valpar2 = param2.val.val64;
1012	break;
1013
1014	default:
1015	AssertFailed();
1016	return VERR_EM_INTERPRETER;
1017	}
1018
1019	/* Data read, emulate instruction. */
1020	uint32_t eflags = pfnEmulate(&valpar1, valpar2, param2.size);
1021
1022	/* Update guest's eflags and finish. */
1023	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
1024	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
1025
1026	/* And write it back */
1027	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, param1.size);
1028	if (RT_SUCCESS(rc))
1029	{
1030	/* All done! */
1031	*pcbSize = param2.size;
1032	return VINF_SUCCESS;
1033	}
1034	#ifdef IN_RC
1035	}
1036	}
1037	#endif
1038	return VERR_EM_INTERPRETER;
1039	}
1040
1041
1042	/**
1043	* ADC Emulation.
1044	*/
1045	static int emInterpretAdc(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1046	{
1047	if (pRegFrame->eflags.Bits.u1CF)
1048	return emInterpretAddSub(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, EMEmulateAdcWithCarrySet);
1049	else
1050	return emInterpretAddSub(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, EMEmulateAdd);
1051	}
1052
1053
1054	/**
1055	* BTR/C/S Emulation.
1056	*/
1057	static int emInterpretBitTest(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize,
1058	PFNEMULATEPARAM2UINT32 pfnEmulate)
1059	{
1060	OP_PARAMVAL param1, param2;
1061	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
1062	if(RT_FAILURE(rc))
1063	return VERR_EM_INTERPRETER;
1064
1065	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
1066	if(RT_FAILURE(rc))
1067	return VERR_EM_INTERPRETER;
1068
1069	#ifdef IN_RC
1070	if (TRPMHasTrap(pVCpu))
1071	{
1072	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1073	{
1074	#endif
1075	RTGCPTR pParam1;
1076	uint64_t valpar1 = 0, valpar2;
1077	uint32_t eflags;
1078
1079	/* The destination is always a virtual address */
1080	if (param1.type != PARMTYPE_ADDRESS)
1081	return VERR_EM_INTERPRETER;
1082
1083	pParam1 = (RTGCPTR)param1.val.val64;
1084	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
1085
1086	/* Register or immediate data */
1087	switch(param2.type)
1088	{
1089	case PARMTYPE_IMMEDIATE: /* both immediate data and register (ugly) */
1090	valpar2 = param2.val.val64;
1091	break;
1092
1093	default:
1094	AssertFailed();
1095	return VERR_EM_INTERPRETER;
1096	}
1097
1098	Log2(("emInterpret%s: pvFault=%RGv pParam1=%RGv val2=%x\n", emGetMnemonic(pDis), pvFault, pParam1, valpar2));
1099	pParam1 = (RTGCPTR)((RTGCUINTPTR)pParam1 + valpar2/8);
1100	EM_ASSERT_FAULT_RETURN((RTGCPTR)((RTGCUINTPTR)pParam1 & ~3) == pvFault, VERR_EM_INTERPRETER);
1101	rc = emRamRead(pVM, pVCpu, pRegFrame, &valpar1, pParam1, 1);
1102	if (RT_FAILURE(rc))
1103	{
1104	AssertMsgFailed(("emRamRead %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
1105	return VERR_EM_INTERPRETER;
1106	}
1107
1108	Log2(("emInterpretBtx: val=%x\n", valpar1));
1109	/* Data read, emulate bit test instruction. */
1110	eflags = pfnEmulate(&valpar1, valpar2 & 0x7);
1111
1112	Log2(("emInterpretBtx: val=%x CF=%d\n", valpar1, !!(eflags & X86_EFL_CF)));
1113
1114	/* Update guest's eflags and finish. */
1115	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
1116	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
1117
1118	/* And write it back */
1119	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &valpar1, 1);
1120	if (RT_SUCCESS(rc))
1121	{
1122	/* All done! */
1123	*pcbSize = 1;
1124	return VINF_SUCCESS;
1125	}
1126	#ifdef IN_RC
1127	}
1128	}
1129	#endif
1130	return VERR_EM_INTERPRETER;
1131	}
1132
1133
1134	/**
1135	* LOCK BTR/C/S Emulation.
1136	*/
1137	static int emInterpretLockBitTest(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
1138	uint32_t *pcbSize, PFNEMULATELOCKPARAM2 pfnEmulate)
1139	{
1140	void *pvParam1;
1141
1142	OP_PARAMVAL param1, param2;
1143	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
1144	if(RT_FAILURE(rc))
1145	return VERR_EM_INTERPRETER;
1146
1147	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
1148	if(RT_FAILURE(rc))
1149	return VERR_EM_INTERPRETER;
1150
1151	/* The destination is always a virtual address */
1152	if (param1.type != PARMTYPE_ADDRESS)
1153	return VERR_EM_INTERPRETER;
1154
1155	/* Register and immediate data == PARMTYPE_IMMEDIATE */
1156	AssertReturn(param2.type == PARMTYPE_IMMEDIATE, VERR_EM_INTERPRETER);
1157	uint64_t ValPar2 = param2.val.val64;
1158
1159	/* Adjust the parameters so what we're dealing with is a bit within the byte pointed to. */
1160	RTGCPTR GCPtrPar1 = param1.val.val64;
1161	GCPtrPar1 = (GCPtrPar1 + ValPar2 / 8);
1162	ValPar2 &= 7;
1163
1164	GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
1165	#ifdef IN_RC
1166	Assert(TRPMHasTrap(pVCpu));
1167	EM_ASSERT_FAULT_RETURN((RTGCPTR)((RTGCUINTPTR)GCPtrPar1 & ~(RTGCUINTPTR)3) == pvFault, VERR_EM_INTERPRETER);
1168	#endif
1169
1170	PGMPAGEMAPLOCK Lock;
1171	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
1172	AssertRCReturn(rc, VERR_EM_INTERPRETER);
1173
1174	Log2(("emInterpretLockBitTest %s: pvFault=%RGv GCPtrPar1=%RGv imm=%RX64\n", emGetMnemonic(pDis), pvFault, GCPtrPar1, ValPar2));
1175
1176	/* Try emulate it with a one-shot #PF handler in place. (RC) */
1177	RTGCUINTREG32 eflags = 0;
1178	rc = pfnEmulate(pvParam1, ValPar2, &eflags);
1179	PGMPhysReleasePageMappingLock(pVM, &Lock);
1180	if (RT_FAILURE(rc))
1181	{
1182	Log(("emInterpretLockBitTest %s: %RGv imm%d=%RX64 -> emulation failed due to page fault!\n",
1183	emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
1184	return VERR_EM_INTERPRETER;
1185	}
1186
1187	Log2(("emInterpretLockBitTest %s: GCPtrPar1=%RGv imm=%RX64 CF=%d\n", emGetMnemonic(pDis), GCPtrPar1, ValPar2, !!(eflags & X86_EFL_CF)));
1188
1189	/* Update guest's eflags and finish. */
1190	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
1191	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
1192
1193	*pcbSize = 1;
1194	return VINF_SUCCESS;
1195	}
1196
1197
1198	/**
1199	* MOV emulation.
1200	*/
1201	static int emInterpretMov(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1202	{
1203	OP_PARAMVAL param1, param2;
1204	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
1205	if(RT_FAILURE(rc))
1206	return VERR_EM_INTERPRETER;
1207
1208	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
1209	if(RT_FAILURE(rc))
1210	return VERR_EM_INTERPRETER;
1211
1212	#ifdef IN_RC
1213	if (TRPMHasTrap(pVCpu))
1214	{
1215	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1216	{
1217	#else
1218	/** @todo Make this the default and don't rely on TRPM information. */
1219	if (param1.type == PARMTYPE_ADDRESS)
1220	{
1221	#endif
1222	RTGCPTR pDest;
1223	uint64_t val64;
1224
1225	switch(param1.type)
1226	{
1227	case PARMTYPE_IMMEDIATE:
1228	if(!(param1.flags & (PARAM_VAL32\|PARAM_VAL64)))
1229	return VERR_EM_INTERPRETER;
1230	/* fallthru */
1231
1232	case PARMTYPE_ADDRESS:
1233	pDest = (RTGCPTR)param1.val.val64;
1234	pDest = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pDest);
1235	break;
1236
1237	default:
1238	AssertFailed();
1239	return VERR_EM_INTERPRETER;
1240	}
1241
1242	switch(param2.type)
1243	{
1244	case PARMTYPE_IMMEDIATE: /* register type is translated to this one too */
1245	val64 = param2.val.val64;
1246	break;
1247
1248	default:
1249	Log(("emInterpretMov: unexpected type=%d rip=%RGv\n", param2.type, (RTGCPTR)pRegFrame->rip));
1250	return VERR_EM_INTERPRETER;
1251	}
1252	#ifdef LOG_ENABLED
1253	if (pDis->mode == CPUMODE_64BIT)
1254	LogFlow(("EMInterpretInstruction at %RGv: OP_MOV %RGv <- %RX64 (%d) &val64=%RHv\n", (RTGCPTR)pRegFrame->rip, pDest, val64, param2.size, &val64));
1255	else
1256	LogFlow(("EMInterpretInstruction at %08RX64: OP_MOV %RGv <- %08X (%d) &val64=%RHv\n", pRegFrame->rip, pDest, (uint32_t)val64, param2.size, &val64));
1257	#endif
1258
1259	Assert(param2.size <= 8 && param2.size > 0);
1260	EM_ASSERT_FAULT_RETURN(pDest == pvFault, VERR_EM_INTERPRETER);
1261	rc = emRamWrite(pVM, pVCpu, pRegFrame, pDest, &val64, param2.size);
1262	if (RT_FAILURE(rc))
1263	return VERR_EM_INTERPRETER;
1264
1265	*pcbSize = param2.size;
1266	}
1267	else
1268	{ /* read fault */
1269	RTGCPTR pSrc;
1270	uint64_t val64;
1271
1272	/* Source */
1273	switch(param2.type)
1274	{
1275	case PARMTYPE_IMMEDIATE:
1276	if(!(param2.flags & (PARAM_VAL32\|PARAM_VAL64)))
1277	return VERR_EM_INTERPRETER;
1278	/* fallthru */
1279
1280	case PARMTYPE_ADDRESS:
1281	pSrc = (RTGCPTR)param2.val.val64;
1282	pSrc = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param2, pSrc);
1283	break;
1284
1285	default:
1286	return VERR_EM_INTERPRETER;
1287	}
1288
1289	Assert(param1.size <= 8 && param1.size > 0);
1290	EM_ASSERT_FAULT_RETURN(pSrc == pvFault, VERR_EM_INTERPRETER);
1291	rc = emRamRead(pVM, pVCpu, pRegFrame, &val64, pSrc, param1.size);
1292	if (RT_FAILURE(rc))
1293	return VERR_EM_INTERPRETER;
1294
1295	/* Destination */
1296	switch(param1.type)
1297	{
1298	case PARMTYPE_REGISTER:
1299	switch(param1.size)
1300	{
1301	case 1: rc = DISWriteReg8(pRegFrame, pDis->param1.base.reg_gen, (uint8_t) val64); break;
1302	case 2: rc = DISWriteReg16(pRegFrame, pDis->param1.base.reg_gen, (uint16_t)val64); break;
1303	case 4: rc = DISWriteReg32(pRegFrame, pDis->param1.base.reg_gen, (uint32_t)val64); break;
1304	case 8: rc = DISWriteReg64(pRegFrame, pDis->param1.base.reg_gen, val64); break;
1305	default:
1306	return VERR_EM_INTERPRETER;
1307	}
1308	if (RT_FAILURE(rc))
1309	return rc;
1310	break;
1311
1312	default:
1313	return VERR_EM_INTERPRETER;
1314	}
1315	#ifdef LOG_ENABLED
1316	if (pDis->mode == CPUMODE_64BIT)
1317	LogFlow(("EMInterpretInstruction: OP_MOV %RGv -> %RX64 (%d)\n", pSrc, val64, param1.size));
1318	else
1319	LogFlow(("EMInterpretInstruction: OP_MOV %RGv -> %08X (%d)\n", pSrc, (uint32_t)val64, param1.size));
1320	#endif
1321	}
1322	return VINF_SUCCESS;
1323	#ifdef IN_RC
1324	}
1325	#endif
1326	return VERR_EM_INTERPRETER;
1327	}
1328
1329
1330	#ifndef IN_RC
1331	/**
1332	* [REP] STOSWD emulation
1333	*/
1334	static int emInterpretStosWD(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1335	{
1336	int rc;
1337	RTGCPTR GCDest, GCOffset;
1338	uint32_t cbSize;
1339	uint64_t cTransfers;
1340	int offIncrement;
1341
1342	/* Don't support any but these three prefix bytes. */
1343	if ((pDis->prefix & ~(PREFIX_ADDRSIZE\|PREFIX_OPSIZE\|PREFIX_REP\|PREFIX_REX)))
1344	return VERR_EM_INTERPRETER;
1345
1346	switch (pDis->addrmode)
1347	{
1348	case CPUMODE_16BIT:
1349	GCOffset = pRegFrame->di;
1350	cTransfers = pRegFrame->cx;
1351	break;
1352	case CPUMODE_32BIT:
1353	GCOffset = pRegFrame->edi;
1354	cTransfers = pRegFrame->ecx;
1355	break;
1356	case CPUMODE_64BIT:
1357	GCOffset = pRegFrame->rdi;
1358	cTransfers = pRegFrame->rcx;
1359	break;
1360	default:
1361	AssertFailed();
1362	return VERR_EM_INTERPRETER;
1363	}
1364
1365	GCDest = SELMToFlat(pVM, DIS_SELREG_ES, pRegFrame, GCOffset);
1366	switch (pDis->opmode)
1367	{
1368	case CPUMODE_16BIT:
1369	cbSize = 2;
1370	break;
1371	case CPUMODE_32BIT:
1372	cbSize = 4;
1373	break;
1374	case CPUMODE_64BIT:
1375	cbSize = 8;
1376	break;
1377	default:
1378	AssertFailed();
1379	return VERR_EM_INTERPRETER;
1380	}
1381
1382	offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
1383
1384	if (!(pDis->prefix & PREFIX_REP))
1385	{
1386	LogFlow(("emInterpretStosWD dest=%04X:%RGv (%RGv) cbSize=%d\n", pRegFrame->es, GCOffset, GCDest, cbSize));
1387
1388	rc = emRamWrite(pVM, pVCpu, pRegFrame, GCDest, &pRegFrame->rax, cbSize);
1389	if (RT_FAILURE(rc))
1390	return VERR_EM_INTERPRETER;
1391	Assert(rc == VINF_SUCCESS);
1392
1393	/* Update (e/r)di. */
1394	switch (pDis->addrmode)
1395	{
1396	case CPUMODE_16BIT:
1397	pRegFrame->di += offIncrement;
1398	break;
1399	case CPUMODE_32BIT:
1400	pRegFrame->edi += offIncrement;
1401	break;
1402	case CPUMODE_64BIT:
1403	pRegFrame->rdi += offIncrement;
1404	break;
1405	default:
1406	AssertFailed();
1407	return VERR_EM_INTERPRETER;
1408	}
1409
1410	}
1411	else
1412	{
1413	if (!cTransfers)
1414	return VINF_SUCCESS;
1415
1416	/*
1417	* Do not try emulate cross page stuff here because we don't know what might
1418	* be waiting for us on the subsequent pages. The caller has only asked us to
1419	* ignore access handlers fro the current page.
1420	* This also fends off big stores which would quickly kill PGMR0DynMap.
1421	*/
1422	if ( cbSize > PAGE_SIZE
1423	\|\| cTransfers > PAGE_SIZE
1424	\|\| (GCDest >> PAGE_SHIFT) != ((GCDest + offIncrement * cTransfers) >> PAGE_SHIFT))
1425	{
1426	Log(("STOSWD is crosses pages, chicken out to the recompiler; GCDest=%RGv cbSize=%#x offIncrement=%d cTransfers=%#x\n",
1427	GCDest, cbSize, offIncrement, cTransfers));
1428	return VERR_EM_INTERPRETER;
1429	}
1430
1431	LogFlow(("emInterpretStosWD dest=%04X:%RGv (%RGv) cbSize=%d cTransfers=%x DF=%d\n", pRegFrame->es, GCOffset, GCDest, cbSize, cTransfers, pRegFrame->eflags.Bits.u1DF));
1432	/* Access verification first; we currently can't recover properly from traps inside this instruction */
1433	rc = PGMVerifyAccess(pVCpu, GCDest - ((offIncrement > 0) ? 0 : ((cTransfers-1) * cbSize)),
1434	cTransfers * cbSize,
1435	X86_PTE_RW \| (CPUMGetGuestCPL(pVCpu, pRegFrame) == 3 ? X86_PTE_US : 0));
1436	if (rc != VINF_SUCCESS)
1437	{
1438	Log(("STOSWD will generate a trap -> recompiler, rc=%d\n", rc));
1439	return VERR_EM_INTERPRETER;
1440	}
1441
1442	/* REP case */
1443	while (cTransfers)
1444	{
1445	rc = emRamWrite(pVM, pVCpu, pRegFrame, GCDest, &pRegFrame->rax, cbSize);
1446	if (RT_FAILURE(rc))
1447	{
1448	rc = VERR_EM_INTERPRETER;
1449	break;
1450	}
1451
1452	Assert(rc == VINF_SUCCESS);
1453	GCOffset += offIncrement;
1454	GCDest += offIncrement;
1455	cTransfers--;
1456	}
1457
1458	/* Update the registers. */
1459	switch (pDis->addrmode)
1460	{
1461	case CPUMODE_16BIT:
1462	pRegFrame->di = GCOffset;
1463	pRegFrame->cx = cTransfers;
1464	break;
1465	case CPUMODE_32BIT:
1466	pRegFrame->edi = GCOffset;
1467	pRegFrame->ecx = cTransfers;
1468	break;
1469	case CPUMODE_64BIT:
1470	pRegFrame->rdi = GCOffset;
1471	pRegFrame->rcx = cTransfers;
1472	break;
1473	default:
1474	AssertFailed();
1475	return VERR_EM_INTERPRETER;
1476	}
1477	}
1478
1479	*pcbSize = cbSize;
1480	return rc;
1481	}
1482	#endif /* !IN_RC */
1483
1484
1485	/**
1486	* [LOCK] CMPXCHG emulation.
1487	*/
1488	static int emInterpretCmpXchg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1489	{
1490	OP_PARAMVAL param1, param2;
1491
1492	#if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0)
1493	Assert(pDis->param1.size <= 4);
1494	#endif
1495
1496	/* Source to make DISQueryParamVal read the register value - ugly hack */
1497	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
1498	if(RT_FAILURE(rc))
1499	return VERR_EM_INTERPRETER;
1500
1501	rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
1502	if(RT_FAILURE(rc))
1503	return VERR_EM_INTERPRETER;
1504
1505	uint64_t valpar;
1506	switch(param2.type)
1507	{
1508	case PARMTYPE_IMMEDIATE: /* register actually */
1509	valpar = param2.val.val64;
1510	break;
1511
1512	default:
1513	return VERR_EM_INTERPRETER;
1514	}
1515
1516	PGMPAGEMAPLOCK Lock;
1517	RTGCPTR GCPtrPar1;
1518	void *pvParam1;
1519	uint64_t eflags;
1520
1521	AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
1522	switch(param1.type)
1523	{
1524	case PARMTYPE_ADDRESS:
1525	GCPtrPar1 = param1.val.val64;
1526	GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
1527
1528	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
1529	AssertRCReturn(rc, VERR_EM_INTERPRETER);
1530	break;
1531
1532	default:
1533	return VERR_EM_INTERPRETER;
1534	}
1535
1536	LogFlow(("%s %RGv rax=%RX64 %RX64\n", emGetMnemonic(pDis), GCPtrPar1, pRegFrame->rax, valpar));
1537
1538	if (pDis->prefix & PREFIX_LOCK)
1539	eflags = EMEmulateLockCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.size);
1540	else
1541	eflags = EMEmulateCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.size);
1542
1543	LogFlow(("%s %RGv rax=%RX64 %RX64 ZF=%d\n", emGetMnemonic(pDis), GCPtrPar1, pRegFrame->rax, valpar, !!(eflags & X86_EFL_ZF)));
1544
1545	/* Update guest's eflags and finish. */
1546	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
1547	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
1548
1549	*pcbSize = param2.size;
1550	PGMPhysReleasePageMappingLock(pVM, &Lock);
1551	return VINF_SUCCESS;
1552	}
1553
1554
1555	/**
1556	* [LOCK] CMPXCHG8B emulation.
1557	*/
1558	static int emInterpretCmpXchg8b(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1559	{
1560	Assert(pDis->mode != CPUMODE_64BIT); /** @todo check */
1561	OP_PARAMVAL param1;
1562
1563	/* Source to make DISQueryParamVal read the register value - ugly hack */
1564	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
1565	if(RT_FAILURE(rc))
1566	return VERR_EM_INTERPRETER;
1567
1568	RTGCPTR GCPtrPar1;
1569	void *pvParam1;
1570	uint64_t eflags;
1571	PGMPAGEMAPLOCK Lock;
1572
1573	AssertReturn(pDis->param1.size == 8, VERR_EM_INTERPRETER);
1574	switch(param1.type)
1575	{
1576	case PARMTYPE_ADDRESS:
1577	GCPtrPar1 = param1.val.val64;
1578	GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
1579
1580	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
1581	AssertRCReturn(rc, VERR_EM_INTERPRETER);
1582	break;
1583
1584	default:
1585	return VERR_EM_INTERPRETER;
1586	}
1587
1588	LogFlow(("%s %RGv=%08x eax=%08x\n", emGetMnemonic(pDis), pvParam1, pRegFrame->eax));
1589
1590	if (pDis->prefix & PREFIX_LOCK)
1591	eflags = EMEmulateLockCmpXchg8b(pvParam1, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx);
1592	else
1593	eflags = EMEmulateCmpXchg8b(pvParam1, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx);
1594
1595	LogFlow(("%s %RGv=%08x eax=%08x ZF=%d\n", emGetMnemonic(pDis), pvParam1, pRegFrame->eax, !!(eflags & X86_EFL_ZF)));
1596
1597	/* Update guest's eflags and finish; note that only ZF is affected. */
1598	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_ZF))
1599	\| (eflags & (X86_EFL_ZF));
1600
1601	*pcbSize = 8;
1602	PGMPhysReleasePageMappingLock(pVM, &Lock);
1603	return VINF_SUCCESS;
1604	}
1605
1606
1607	#ifdef IN_RC /** @todo test+enable for HWACCM as well. */
1608	/**
1609	* [LOCK] XADD emulation.
1610	*/
1611	static int emInterpretXAdd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1612	{
1613	Assert(pDis->mode != CPUMODE_64BIT); /** @todo check */
1614	OP_PARAMVAL param1;
1615	void *pvParamReg2;
1616	size_t cbParamReg2;
1617
1618	/* Source to make DISQueryParamVal read the register value - ugly hack */
1619	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
1620	if(RT_FAILURE(rc))
1621	return VERR_EM_INTERPRETER;
1622
1623	rc = DISQueryParamRegPtr(pRegFrame, pDis, &pDis->param2, &pvParamReg2, &cbParamReg2);
1624	Assert(cbParamReg2 <= 4);
1625	if(RT_FAILURE(rc))
1626	return VERR_EM_INTERPRETER;
1627
1628	#ifdef IN_RC
1629	if (TRPMHasTrap(pVCpu))
1630	{
1631	if (TRPMGetErrorCode(pVCpu) & X86_TRAP_PF_RW)
1632	{
1633	#endif
1634	RTGCPTR GCPtrPar1;
1635	void *pvParam1;
1636	uint32_t eflags;
1637	PGMPAGEMAPLOCK Lock;
1638
1639	AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
1640	switch(param1.type)
1641	{
1642	case PARMTYPE_ADDRESS:
1643	GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, (RTRCUINTPTR)param1.val.val64);
1644	#ifdef IN_RC
1645	EM_ASSERT_FAULT_RETURN(GCPtrPar1 == pvFault, VERR_EM_INTERPRETER);
1646	#endif
1647
1648	rc = PGMPhysGCPtr2CCPtr(pVCpu, GCPtrPar1, &pvParam1, &Lock);
1649	AssertRCReturn(rc, VERR_EM_INTERPRETER);
1650	break;
1651
1652	default:
1653	return VERR_EM_INTERPRETER;
1654	}
1655
1656	LogFlow(("XAdd %RGv=%p reg=%08llx\n", GCPtrPar1, pvParam1, (uint64_t )pvParamReg2));
1657
1658	if (pDis->prefix & PREFIX_LOCK)
1659	eflags = EMEmulateLockXAdd(pvParam1, pvParamReg2, cbParamReg2);
1660	else
1661	eflags = EMEmulateXAdd(pvParam1, pvParamReg2, cbParamReg2);
1662
1663	LogFlow(("XAdd %RGv=%p reg=%08llx ZF=%d\n", GCPtrPar1, pvParam1, (uint64_t )pvParamReg2, !!(eflags & X86_EFL_ZF) ));
1664
1665	/* Update guest's eflags and finish. */
1666	pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF))
1667	\| (eflags & (X86_EFL_CF \| X86_EFL_PF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_SF \| X86_EFL_OF));
1668
1669	*pcbSize = cbParamReg2;
1670	PGMPhysReleasePageMappingLock(pVM, &Lock);
1671	return VINF_SUCCESS;
1672	#ifdef IN_RC
1673	}
1674	}
1675
1676	return VERR_EM_INTERPRETER;
1677	#endif
1678	}
1679	#endif /* IN_RC */
1680
1681
1682	#ifdef IN_RC
1683	/**
1684	* Interpret IRET (currently only to V86 code)
1685	*
1686	* @returns VBox status code.
1687	* @param pVM The VM handle.
1688	* @param pVCpu The VMCPU handle.
1689	* @param pRegFrame The register frame.
1690	*
1691	*/
1692	VMMDECL(int) EMInterpretIret(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1693	{
1694	RTGCUINTPTR pIretStack = (RTGCUINTPTR)pRegFrame->esp;
1695	RTGCUINTPTR eip, cs, esp, ss, eflags, ds, es, fs, gs, uMask;
1696	int rc;
1697
1698	Assert(!CPUMIsGuestIn64BitCode(pVCpu, pRegFrame));
1699
1700	rc = emRamRead(pVM, pVCpu, pRegFrame, &eip, (RTGCPTR)pIretStack , 4);
1701	rc \|= emRamRead(pVM, pVCpu, pRegFrame, &cs, (RTGCPTR)(pIretStack + 4), 4);
1702	rc \|= emRamRead(pVM, pVCpu, pRegFrame, &eflags, (RTGCPTR)(pIretStack + 8), 4);
1703	AssertRCReturn(rc, VERR_EM_INTERPRETER);
1704	AssertReturn(eflags & X86_EFL_VM, VERR_EM_INTERPRETER);
1705
1706	rc \|= emRamRead(pVM, pVCpu, pRegFrame, &esp, (RTGCPTR)(pIretStack + 12), 4);
1707	rc \|= emRamRead(pVM, pVCpu, pRegFrame, &ss, (RTGCPTR)(pIretStack + 16), 4);
1708	rc \|= emRamRead(pVM, pVCpu, pRegFrame, &es, (RTGCPTR)(pIretStack + 20), 4);
1709	rc \|= emRamRead(pVM, pVCpu, pRegFrame, &ds, (RTGCPTR)(pIretStack + 24), 4);
1710	rc \|= emRamRead(pVM, pVCpu, pRegFrame, &fs, (RTGCPTR)(pIretStack + 28), 4);
1711	rc \|= emRamRead(pVM, pVCpu, pRegFrame, &gs, (RTGCPTR)(pIretStack + 32), 4);
1712	AssertRCReturn(rc, VERR_EM_INTERPRETER);
1713
1714	pRegFrame->eip = eip & 0xffff;
1715	pRegFrame->cs = cs;
1716
1717	/* Mask away all reserved bits */
1718	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;
1719	eflags &= uMask;
1720
1721	#ifndef IN_RING0
1722	CPUMRawSetEFlags(pVCpu, pRegFrame, eflags);
1723	#endif
1724	Assert((pRegFrame->eflags.u32 & (X86_EFL_IF\|X86_EFL_IOPL)) == X86_EFL_IF);
1725
1726	pRegFrame->esp = esp;
1727	pRegFrame->ss = ss;
1728	pRegFrame->ds = ds;
1729	pRegFrame->es = es;
1730	pRegFrame->fs = fs;
1731	pRegFrame->gs = gs;
1732
1733	return VINF_SUCCESS;
1734	}
1735	#endif /* IN_RC */
1736
1737
1738	/**
1739	* IRET Emulation.
1740	*/
1741	static int emInterpretIret(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1742	{
1743	/* only allow direct calls to EMInterpretIret for now */
1744	return VERR_EM_INTERPRETER;
1745	}
1746
1747	/**
1748	* WBINVD Emulation.
1749	*/
1750	static int emInterpretWbInvd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1751	{
1752	/* Nothing to do. */
1753	return VINF_SUCCESS;
1754	}
1755
1756
1757	/**
1758	* Interpret INVLPG
1759	*
1760	* @returns VBox status code.
1761	* @param pVM The VM handle.
1762	* @param pVCpu The VMCPU handle.
1763	* @param pRegFrame The register frame.
1764	* @param pAddrGC Operand address
1765	*
1766	*/
1767	VMMDECL(int) EMInterpretInvlpg(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, RTGCPTR pAddrGC)
1768	{
1769	int rc;
1770
1771	/** @todo is addr always a flat linear address or ds based
1772	* (in absence of segment override prefixes)????
1773	*/
1774	#ifdef IN_RC
1775	LogFlow(("RC: EMULATE: invlpg %RGv\n", pAddrGC));
1776	#endif
1777	rc = PGMInvalidatePage(pVCpu, pAddrGC);
1778	if ( rc == VINF_SUCCESS
1779	\|\| rc == VINF_PGM_SYNC_CR3 /* we can rely on the FF */)
1780	return VINF_SUCCESS;
1781	AssertMsgReturn(rc == VINF_EM_RAW_EMULATE_INSTR,
1782	("%Rrc addr=%RGv\n", rc, pAddrGC),
1783	VERR_EM_INTERPRETER);
1784	return rc;
1785	}
1786
1787
1788	/**
1789	* INVLPG Emulation.
1790	*/
1791	static int emInterpretInvlPg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1792	{
1793	OP_PARAMVAL param1;
1794	RTGCPTR addr;
1795
1796	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
1797	if(RT_FAILURE(rc))
1798	return VERR_EM_INTERPRETER;
1799
1800	switch(param1.type)
1801	{
1802	case PARMTYPE_IMMEDIATE:
1803	case PARMTYPE_ADDRESS:
1804	if(!(param1.flags & (PARAM_VAL32\|PARAM_VAL64)))
1805	return VERR_EM_INTERPRETER;
1806	addr = (RTGCPTR)param1.val.val64;
1807	break;
1808
1809	default:
1810	return VERR_EM_INTERPRETER;
1811	}
1812
1813	/** @todo is addr always a flat linear address or ds based
1814	* (in absence of segment override prefixes)????
1815	*/
1816	#ifdef IN_RC
1817	LogFlow(("RC: EMULATE: invlpg %RGv\n", addr));
1818	#endif
1819	rc = PGMInvalidatePage(pVCpu, addr);
1820	if ( rc == VINF_SUCCESS
1821	\|\| rc == VINF_PGM_SYNC_CR3 /* we can rely on the FF */)
1822	return VINF_SUCCESS;
1823	AssertMsgReturn(rc == VINF_EM_RAW_EMULATE_INSTR,
1824	("%Rrc addr=%RGv\n", rc, addr),
1825	VERR_EM_INTERPRETER);
1826	return rc;
1827	}
1828
1829	/** @todo change all these EMInterpretXXX methods to VBOXSTRICTRC. */
1830
1831	/**
1832	* Interpret CPUID given the parameters in the CPU context
1833	*
1834	* @returns VBox status code.
1835	* @param pVM The VM handle.
1836	* @param pVCpu The VMCPU handle.
1837	* @param pRegFrame The register frame.
1838	*
1839	*/
1840	VMMDECL(int) EMInterpretCpuId(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
1841	{
1842	uint32_t iLeaf = pRegFrame->eax;
1843
1844	/* cpuid clears the high dwords of the affected 64 bits registers. */
1845	pRegFrame->rax = 0;
1846	pRegFrame->rbx = 0;
1847	pRegFrame->rcx &= UINT64_C(0x00000000ffffffff);
1848	pRegFrame->rdx = 0;
1849
1850	/* Note: operates the same in 64 and non-64 bits mode. */
1851	CPUMGetGuestCpuId(pVCpu, iLeaf, &pRegFrame->eax, &pRegFrame->ebx, &pRegFrame->ecx, &pRegFrame->edx);
1852	Log(("Emulate: CPUID %x -> %08x %08x %08x %08x\n", iLeaf, pRegFrame->eax, pRegFrame->ebx, pRegFrame->ecx, pRegFrame->edx));
1853	return VINF_SUCCESS;
1854	}
1855
1856
1857	/**
1858	* CPUID Emulation.
1859	*/
1860	static int emInterpretCpuId(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1861	{
1862	int rc = EMInterpretCpuId(pVM, pVCpu, pRegFrame);
1863	return rc;
1864	}
1865
1866
1867	/**
1868	* Interpret CRx read
1869	*
1870	* @returns VBox status code.
1871	* @param pVM The VM handle.
1872	* @param pVCpu The VMCPU handle.
1873	* @param pRegFrame The register frame.
1874	* @param DestRegGen General purpose register index (USE_REG_E**))
1875	* @param SrcRegCRx CRx register index (USE_REG_CR*)
1876	*
1877	*/
1878	VMMDECL(int) EMInterpretCRxRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegGen, uint32_t SrcRegCrx)
1879	{
1880	uint64_t val64;
1881	int rc = CPUMGetGuestCRx(pVCpu, SrcRegCrx, &val64);
1882	AssertMsgRCReturn(rc, ("CPUMGetGuestCRx %d failed\n", SrcRegCrx), VERR_EM_INTERPRETER);
1883
1884	if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
1885	rc = DISWriteReg64(pRegFrame, DestRegGen, val64);
1886	else
1887	rc = DISWriteReg32(pRegFrame, DestRegGen, val64);
1888
1889	if (RT_SUCCESS(rc))
1890	{
1891	LogFlow(("MOV_CR: gen32=%d CR=%d val=%RX64\n", DestRegGen, SrcRegCrx, val64));
1892	return VINF_SUCCESS;
1893	}
1894	return VERR_EM_INTERPRETER;
1895	}
1896
1897
1898
1899	/**
1900	* Interpret CLTS
1901	*
1902	* @returns VBox status code.
1903	* @param pVM The VM handle.
1904	* @param pVCpu The VMCPU handle.
1905	*
1906	*/
1907	VMMDECL(int) EMInterpretCLTS(PVM pVM, PVMCPU pVCpu)
1908	{
1909	uint64_t cr0 = CPUMGetGuestCR0(pVCpu);
1910	if (!(cr0 & X86_CR0_TS))
1911	return VINF_SUCCESS;
1912	return CPUMSetGuestCR0(pVCpu, cr0 & ~X86_CR0_TS);
1913	}
1914
1915	/**
1916	* CLTS Emulation.
1917	*/
1918	static int emInterpretClts(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
1919	{
1920	return EMInterpretCLTS(pVM, pVCpu);
1921	}
1922
1923
1924	/**
1925	* Update CRx
1926	*
1927	* @returns VBox status code.
1928	* @param pVM The VM handle.
1929	* @param pVCpu The VMCPU handle.
1930	* @param pRegFrame The register frame.
1931	* @param DestRegCRx CRx register index (USE_REG_CR*)
1932	* @param val New CRx value
1933	*
1934	*/
1935	static int emUpdateCRx(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegCrx, uint64_t val)
1936	{
1937	uint64_t oldval;
1938	uint64_t msrEFER;
1939	int rc, rc2;
1940
1941	/** @todo Clean up this mess. */
1942	LogFlow(("EMInterpretCRxWrite at %RGv CR%d <- %RX64\n", (RTGCPTR)pRegFrame->rip, DestRegCrx, val));
1943	switch (DestRegCrx)
1944	{
1945	case USE_REG_CR0:
1946	oldval = CPUMGetGuestCR0(pVCpu);
1947	#ifdef IN_RC
1948	/* CR0.WP and CR0.AM changes require a reschedule run in ring 3. */
1949	if ( (val & (X86_CR0_WP \| X86_CR0_AM))
1950	!= (oldval & (X86_CR0_WP \| X86_CR0_AM)))
1951	return VERR_EM_INTERPRETER;
1952	#endif
1953	rc = VINF_SUCCESS;
1954	CPUMSetGuestCR0(pVCpu, val);
1955	val = CPUMGetGuestCR0(pVCpu);
1956	if ( (oldval & (X86_CR0_PG \| X86_CR0_WP \| X86_CR0_PE))
1957	!= (val & (X86_CR0_PG \| X86_CR0_WP \| X86_CR0_PE)))
1958	{
1959	/* global flush */
1960	rc = PGMFlushTLB(pVCpu, CPUMGetGuestCR3(pVCpu), true /* global */);
1961	AssertRCReturn(rc, rc);
1962	}
1963
1964	/* Deal with long mode enabling/disabling. */
1965	msrEFER = CPUMGetGuestEFER(pVCpu);
1966	if (msrEFER & MSR_K6_EFER_LME)
1967	{
1968	if ( !(oldval & X86_CR0_PG)
1969	&& (val & X86_CR0_PG))
1970	{
1971	/* Illegal to have an active 64 bits CS selector (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
1972	if (pRegFrame->csHid.Attr.n.u1Long)
1973	{
1974	AssertMsgFailed(("Illegal enabling of paging with CS.u1Long = 1!!\n"));
1975	return VERR_EM_INTERPRETER; /* @todo generate #GP(0) */
1976	}
1977
1978	/* Illegal to switch to long mode before activating PAE first (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
1979	if (!(CPUMGetGuestCR4(pVCpu) & X86_CR4_PAE))
1980	{
1981	AssertMsgFailed(("Illegal enabling of paging with PAE disabled!!\n"));
1982	return VERR_EM_INTERPRETER; /* @todo generate #GP(0) */
1983	}
1984	msrEFER \|= MSR_K6_EFER_LMA;
1985	}
1986	else
1987	if ( (oldval & X86_CR0_PG)
1988	&& !(val & X86_CR0_PG))
1989	{
1990	msrEFER &= ~MSR_K6_EFER_LMA;
1991	/* @todo Do we need to cut off rip here? High dword of rip is undefined, so it shouldn't really matter. */
1992	}
1993	CPUMSetGuestEFER(pVCpu, msrEFER);
1994	}
1995	rc2 = PGMChangeMode(pVCpu, CPUMGetGuestCR0(pVCpu), CPUMGetGuestCR4(pVCpu), CPUMGetGuestEFER(pVCpu));
1996	return rc2 == VINF_SUCCESS ? rc : rc2;
1997
1998	case USE_REG_CR2:
1999	rc = CPUMSetGuestCR2(pVCpu, val); AssertRC(rc);
2000	return VINF_SUCCESS;
2001
2002	case USE_REG_CR3:
2003	/* Reloading the current CR3 means the guest just wants to flush the TLBs */
2004	rc = CPUMSetGuestCR3(pVCpu, val); AssertRC(rc);
2005	if (CPUMGetGuestCR0(pVCpu) & X86_CR0_PG)
2006	{
2007	/* flush */
2008	rc = PGMFlushTLB(pVCpu, val, !(CPUMGetGuestCR4(pVCpu) & X86_CR4_PGE));
2009	AssertRC(rc);
2010	}
2011	return rc;
2012
2013	case USE_REG_CR4:
2014	oldval = CPUMGetGuestCR4(pVCpu);
2015	rc = CPUMSetGuestCR4(pVCpu, val); AssertRC(rc);
2016	val = CPUMGetGuestCR4(pVCpu);
2017
2018	/* Illegal to disable PAE when long mode is active. (AMD Arch. Programmer's Manual Volume 2: Table 14-5) */
2019	msrEFER = CPUMGetGuestEFER(pVCpu);
2020	if ( (msrEFER & MSR_K6_EFER_LMA)
2021	&& (oldval & X86_CR4_PAE)
2022	&& !(val & X86_CR4_PAE))
2023	{
2024	return VERR_EM_INTERPRETER; /** @todo generate #GP(0) */
2025	}
2026
2027	rc = VINF_SUCCESS;
2028	if ( (oldval & (X86_CR4_PGE\|X86_CR4_PAE\|X86_CR4_PSE))
2029	!= (val & (X86_CR4_PGE\|X86_CR4_PAE\|X86_CR4_PSE)))
2030	{
2031	/* global flush */
2032	rc = PGMFlushTLB(pVCpu, CPUMGetGuestCR3(pVCpu), true /* global */);
2033	AssertRCReturn(rc, rc);
2034	}
2035
2036	/* Feeling extremely lazy. */
2037	# ifdef IN_RC
2038	if ( (oldval & (X86_CR4_OSFSXR\|X86_CR4_OSXMMEEXCPT\|X86_CR4_PCE\|X86_CR4_MCE\|X86_CR4_PAE\|X86_CR4_DE\|X86_CR4_TSD\|X86_CR4_PVI\|X86_CR4_VME))
2039	!= (val & (X86_CR4_OSFSXR\|X86_CR4_OSXMMEEXCPT\|X86_CR4_PCE\|X86_CR4_MCE\|X86_CR4_PAE\|X86_CR4_DE\|X86_CR4_TSD\|X86_CR4_PVI\|X86_CR4_VME)))
2040	{
2041	Log(("emInterpretMovCRx: CR4: %#RX64->%#RX64 => R3\n", oldval, val));
2042	VMCPU_FF_SET(pVCpu, VMCPU_FF_TO_R3);
2043	}
2044	# endif
2045	if ((val ^ oldval) & X86_CR4_VME)
2046	VMCPU_FF_SET(pVCpu, VMCPU_FF_SELM_SYNC_TSS);
2047
2048	rc2 = PGMChangeMode(pVCpu, CPUMGetGuestCR0(pVCpu), CPUMGetGuestCR4(pVCpu), CPUMGetGuestEFER(pVCpu));
2049	return rc2 == VINF_SUCCESS ? rc : rc2;
2050
2051	case USE_REG_CR8:
2052	return PDMApicSetTPR(pVCpu, val << 4); /* cr8 bits 3-0 correspond to bits 7-4 of the task priority mmio register. */
2053
2054	default:
2055	AssertFailed();
2056	case USE_REG_CR1: /* illegal op */
2057	break;
2058	}
2059	return VERR_EM_INTERPRETER;
2060	}
2061
2062	/**
2063	* Interpret CRx write
2064	*
2065	* @returns VBox status code.
2066	* @param pVM The VM handle.
2067	* @param pVCpu The VMCPU handle.
2068	* @param pRegFrame The register frame.
2069	* @param DestRegCRx CRx register index (USE_REG_CR*)
2070	* @param SrcRegGen General purpose register index (USE_REG_E**))
2071	*
2072	*/
2073	VMMDECL(int) EMInterpretCRxWrite(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegCrx, uint32_t SrcRegGen)
2074	{
2075	uint64_t val;
2076	int rc;
2077
2078	if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
2079	{
2080	rc = DISFetchReg64(pRegFrame, SrcRegGen, &val);
2081	}
2082	else
2083	{
2084	uint32_t val32;
2085	rc = DISFetchReg32(pRegFrame, SrcRegGen, &val32);
2086	val = val32;
2087	}
2088
2089	if (RT_SUCCESS(rc))
2090	return emUpdateCRx(pVM, pVCpu, pRegFrame, DestRegCrx, val);
2091
2092	return VERR_EM_INTERPRETER;
2093	}
2094
2095	/**
2096	* Interpret LMSW
2097	*
2098	* @returns VBox status code.
2099	* @param pVM The VM handle.
2100	* @param pVCpu The VMCPU handle.
2101	* @param pRegFrame The register frame.
2102	* @param u16Data LMSW source data.
2103	*
2104	*/
2105	VMMDECL(int) EMInterpretLMSW(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint16_t u16Data)
2106	{
2107	uint64_t OldCr0 = CPUMGetGuestCR0(pVCpu);
2108
2109	/* Only PE, MP, EM and TS can be changed; note that PE can't be cleared by this instruction. */
2110	uint64_t NewCr0 = ( OldCr0 & ~( X86_CR0_MP \| X86_CR0_EM \| X86_CR0_TS))
2111	\| (u16Data & (X86_CR0_PE \| X86_CR0_MP \| X86_CR0_EM \| X86_CR0_TS));
2112
2113	return emUpdateCRx(pVM, pVCpu, pRegFrame, USE_REG_CR0, NewCr0);
2114	}
2115
2116	/**
2117	* LMSW Emulation.
2118	*/
2119	static int emInterpretLmsw(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2120	{
2121	OP_PARAMVAL param1;
2122	uint32_t val;
2123
2124	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
2125	if(RT_FAILURE(rc))
2126	return VERR_EM_INTERPRETER;
2127
2128	switch(param1.type)
2129	{
2130	case PARMTYPE_IMMEDIATE:
2131	case PARMTYPE_ADDRESS:
2132	if(!(param1.flags & PARAM_VAL16))
2133	return VERR_EM_INTERPRETER;
2134	val = param1.val.val32;
2135	break;
2136
2137	default:
2138	return VERR_EM_INTERPRETER;
2139	}
2140
2141	LogFlow(("emInterpretLmsw %x\n", val));
2142	return EMInterpretLMSW(pVM, pVCpu, pRegFrame, val);
2143	}
2144
2145	#ifdef EM_EMULATE_SMSW
2146	/**
2147	* SMSW Emulation.
2148	*/
2149	static int emInterpretSmsw(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2150	{
2151	OP_PARAMVAL param1;
2152	uint64_t cr0 = CPUMGetGuestCR0(pVCpu);
2153
2154	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
2155	if(RT_FAILURE(rc))
2156	return VERR_EM_INTERPRETER;
2157
2158	switch(param1.type)
2159	{
2160	case PARMTYPE_IMMEDIATE:
2161	if(param1.size != sizeof(uint16_t))
2162	return VERR_EM_INTERPRETER;
2163	LogFlow(("emInterpretSmsw %d <- cr0 (%x)\n", pDis->param1.base.reg_gen, cr0));
2164	rc = DISWriteReg16(pRegFrame, pDis->param1.base.reg_gen, cr0);
2165	break;
2166
2167	case PARMTYPE_ADDRESS:
2168	{
2169	RTGCPTR pParam1;
2170
2171	/* Actually forced to 16 bits regardless of the operand size. */
2172	if(param1.size != sizeof(uint16_t))
2173	return VERR_EM_INTERPRETER;
2174
2175	pParam1 = (RTGCPTR)param1.val.val64;
2176	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
2177	LogFlow(("emInterpretSmsw %RGv <- cr0 (%x)\n", pParam1, cr0));
2178
2179	rc = emRamWrite(pVM, pVCpu, pRegFrame, pParam1, &cr0, sizeof(uint16_t));
2180	if (RT_FAILURE(rc))
2181	{
2182	AssertMsgFailed(("emRamWrite %RGv size=%d failed with %Rrc\n", pParam1, param1.size, rc));
2183	return VERR_EM_INTERPRETER;
2184	}
2185	break;
2186	}
2187
2188	default:
2189	return VERR_EM_INTERPRETER;
2190	}
2191
2192	LogFlow(("emInterpretSmsw %x\n", cr0));
2193	return rc;
2194	}
2195	#endif
2196
2197	/**
2198	* MOV CRx
2199	*/
2200	static int emInterpretMovCRx(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2201	{
2202	if ((pDis->param1.flags == USE_REG_GEN32 \|\| pDis->param1.flags == USE_REG_GEN64) && pDis->param2.flags == USE_REG_CR)
2203	return EMInterpretCRxRead(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_gen, pDis->param2.base.reg_ctrl);
2204
2205	if (pDis->param1.flags == USE_REG_CR && (pDis->param2.flags == USE_REG_GEN32 \|\| pDis->param2.flags == USE_REG_GEN64))
2206	return EMInterpretCRxWrite(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_ctrl, pDis->param2.base.reg_gen);
2207
2208	AssertMsgFailedReturn(("Unexpected control register move\n"), VERR_EM_INTERPRETER);
2209	return VERR_EM_INTERPRETER;
2210	}
2211
2212
2213	/**
2214	* Interpret DRx write
2215	*
2216	* @returns VBox status code.
2217	* @param pVM The VM handle.
2218	* @param pVCpu The VMCPU handle.
2219	* @param pRegFrame The register frame.
2220	* @param DestRegDRx DRx register index (USE_REG_DR*)
2221	* @param SrcRegGen General purpose register index (USE_REG_E**))
2222	*
2223	*/
2224	VMMDECL(int) EMInterpretDRxWrite(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegDrx, uint32_t SrcRegGen)
2225	{
2226	uint64_t val;
2227	int rc;
2228
2229	if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
2230	{
2231	rc = DISFetchReg64(pRegFrame, SrcRegGen, &val);
2232	}
2233	else
2234	{
2235	uint32_t val32;
2236	rc = DISFetchReg32(pRegFrame, SrcRegGen, &val32);
2237	val = val32;
2238	}
2239
2240	if (RT_SUCCESS(rc))
2241	{
2242	/** @todo we don't fail if illegal bits are set/cleared for e.g. dr7 */
2243	rc = CPUMSetGuestDRx(pVCpu, DestRegDrx, val);
2244	if (RT_SUCCESS(rc))
2245	return rc;
2246	AssertMsgFailed(("CPUMSetGuestDRx %d failed\n", DestRegDrx));
2247	}
2248	return VERR_EM_INTERPRETER;
2249	}
2250
2251
2252	/**
2253	* Interpret DRx read
2254	*
2255	* @returns VBox status code.
2256	* @param pVM The VM handle.
2257	* @param pVCpu The VMCPU handle.
2258	* @param pRegFrame The register frame.
2259	* @param DestRegGen General purpose register index (USE_REG_E**))
2260	* @param SrcRegDRx DRx register index (USE_REG_DR*)
2261	*
2262	*/
2263	VMMDECL(int) EMInterpretDRxRead(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t DestRegGen, uint32_t SrcRegDrx)
2264	{
2265	uint64_t val64;
2266
2267	int rc = CPUMGetGuestDRx(pVCpu, SrcRegDrx, &val64);
2268	AssertMsgRCReturn(rc, ("CPUMGetGuestDRx %d failed\n", SrcRegDrx), VERR_EM_INTERPRETER);
2269	if (CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
2270	{
2271	rc = DISWriteReg64(pRegFrame, DestRegGen, val64);
2272	}
2273	else
2274	rc = DISWriteReg32(pRegFrame, DestRegGen, (uint32_t)val64);
2275
2276	if (RT_SUCCESS(rc))
2277	return VINF_SUCCESS;
2278
2279	return VERR_EM_INTERPRETER;
2280	}
2281
2282
2283	/**
2284	* MOV DRx
2285	*/
2286	static int emInterpretMovDRx(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2287	{
2288	int rc = VERR_EM_INTERPRETER;
2289
2290	if((pDis->param1.flags == USE_REG_GEN32 \|\| pDis->param1.flags == USE_REG_GEN64) && pDis->param2.flags == USE_REG_DBG)
2291	{
2292	rc = EMInterpretDRxRead(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_gen, pDis->param2.base.reg_dbg);
2293	}
2294	else
2295	if(pDis->param1.flags == USE_REG_DBG && (pDis->param2.flags == USE_REG_GEN32 \|\| pDis->param2.flags == USE_REG_GEN64))
2296	{
2297	rc = EMInterpretDRxWrite(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_dbg, pDis->param2.base.reg_gen);
2298	}
2299	else
2300	AssertMsgFailed(("Unexpected debug register move\n"));
2301
2302	return rc;
2303	}
2304
2305
2306	/**
2307	* LLDT Emulation.
2308	*/
2309	static int emInterpretLLdt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2310	{
2311	OP_PARAMVAL param1;
2312	RTSEL sel;
2313
2314	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
2315	if(RT_FAILURE(rc))
2316	return VERR_EM_INTERPRETER;
2317
2318	switch(param1.type)
2319	{
2320	case PARMTYPE_ADDRESS:
2321	return VERR_EM_INTERPRETER; //feeling lazy right now
2322
2323	case PARMTYPE_IMMEDIATE:
2324	if(!(param1.flags & PARAM_VAL16))
2325	return VERR_EM_INTERPRETER;
2326	sel = (RTSEL)param1.val.val16;
2327	break;
2328
2329	default:
2330	return VERR_EM_INTERPRETER;
2331	}
2332
2333	#ifdef IN_RING0
2334	/* Only for the VT-x real-mode emulation case. */
2335	AssertReturn(CPUMIsGuestInRealMode(pVCpu), VERR_EM_INTERPRETER);
2336	CPUMSetGuestLDTR(pVCpu, sel);
2337	return VINF_SUCCESS;
2338	#else
2339	if (sel == 0)
2340	{
2341	if (CPUMGetHyperLDTR(pVCpu) == 0)
2342	{
2343	// this simple case is most frequent in Windows 2000 (31k - boot & shutdown)
2344	return VINF_SUCCESS;
2345	}
2346	}
2347	//still feeling lazy
2348	return VERR_EM_INTERPRETER;
2349	#endif
2350	}
2351
2352	#ifdef IN_RING0
2353	/**
2354	* LIDT/LGDT Emulation.
2355	*/
2356	static int emInterpretLIGdt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2357	{
2358	OP_PARAMVAL param1;
2359	RTGCPTR pParam1;
2360	X86XDTR32 dtr32;
2361
2362	Log(("Emulate %s at %RGv\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip));
2363
2364	/* Only for the VT-x real-mode emulation case. */
2365	AssertReturn(CPUMIsGuestInRealMode(pVCpu), VERR_EM_INTERPRETER);
2366
2367	int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
2368	if(RT_FAILURE(rc))
2369	return VERR_EM_INTERPRETER;
2370
2371	switch(param1.type)
2372	{
2373	case PARMTYPE_ADDRESS:
2374	pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, param1.val.val16);
2375	break;
2376
2377	default:
2378	return VERR_EM_INTERPRETER;
2379	}
2380
2381	rc = emRamRead(pVM, pVCpu, pRegFrame, &dtr32, pParam1, sizeof(dtr32));
2382	AssertRCReturn(rc, VERR_EM_INTERPRETER);
2383
2384	if (!(pDis->prefix & PREFIX_OPSIZE))
2385	dtr32.uAddr &= 0xffffff; /* 16 bits operand size */
2386
2387	if (pDis->pCurInstr->opcode == OP_LIDT)
2388	CPUMSetGuestIDTR(pVCpu, dtr32.uAddr, dtr32.cb);
2389	else
2390	CPUMSetGuestGDTR(pVCpu, dtr32.uAddr, dtr32.cb);
2391
2392	return VINF_SUCCESS;
2393	}
2394	#endif
2395
2396
2397	#ifdef IN_RC
2398	/**
2399	* STI Emulation.
2400	*
2401	* @remark the instruction following sti is guaranteed to be executed before any interrupts are dispatched
2402	*/
2403	static int emInterpretSti(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2404	{
2405	PPATMGCSTATE pGCState = PATMQueryGCState(pVM);
2406
2407	if(!pGCState)
2408	{
2409	Assert(pGCState);
2410	return VERR_EM_INTERPRETER;
2411	}
2412	pGCState->uVMFlags \|= X86_EFL_IF;
2413
2414	Assert(pRegFrame->eflags.u32 & X86_EFL_IF);
2415	Assert(pvFault == SELMToFlat(pVM, DIS_SELREG_CS, pRegFrame, (RTGCPTR)pRegFrame->rip));
2416
2417	pVCpu->em.s.GCPtrInhibitInterrupts = pRegFrame->eip + pDis->opsize;
2418	VMCPU_FF_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
2419
2420	return VINF_SUCCESS;
2421	}
2422	#endif /* IN_RC */
2423
2424
2425	/**
2426	* HLT Emulation.
2427	*/
2428	static int emInterpretHlt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2429	{
2430	return VINF_EM_HALT;
2431	}
2432
2433
2434	/**
2435	* Interpret RDTSC
2436	*
2437	* @returns VBox status code.
2438	* @param pVM The VM handle.
2439	* @param pVCpu The VMCPU handle.
2440	* @param pRegFrame The register frame.
2441	*
2442	*/
2443	VMMDECL(int) EMInterpretRdtsc(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2444	{
2445	unsigned uCR4 = CPUMGetGuestCR4(pVCpu);
2446
2447	if (uCR4 & X86_CR4_TSD)
2448	return VERR_EM_INTERPRETER; /* genuine #GP */
2449
2450	uint64_t uTicks = TMCpuTickGet(pVCpu);
2451
2452	/* Same behaviour in 32 & 64 bits mode */
2453	pRegFrame->rax = (uint32_t)uTicks;
2454	pRegFrame->rdx = (uTicks >> 32ULL);
2455
2456	return VINF_SUCCESS;
2457	}
2458
2459	/**
2460	* Interpret RDTSCP
2461	*
2462	* @returns VBox status code.
2463	* @param pVM The VM handle.
2464	* @param pVCpu The VMCPU handle.
2465	* @param pCtx The CPU context.
2466	*
2467	*/
2468	VMMDECL(int) EMInterpretRdtscp(PVM pVM, PVMCPU pVCpu, PCPUMCTX pCtx)
2469	{
2470	unsigned uCR4 = CPUMGetGuestCR4(pVCpu);
2471
2472	if (!CPUMGetGuestCpuIdFeature(pVM, CPUMCPUIDFEATURE_RDTSCP))
2473	{
2474	AssertFailed();
2475	return VERR_EM_INTERPRETER; /* genuine #UD */
2476	}
2477
2478	if (uCR4 & X86_CR4_TSD)
2479	return VERR_EM_INTERPRETER; /* genuine #GP */
2480
2481	uint64_t uTicks = TMCpuTickGet(pVCpu);
2482
2483	/* Same behaviour in 32 & 64 bits mode */
2484	pCtx->rax = (uint32_t)uTicks;
2485	pCtx->rdx = (uTicks >> 32ULL);
2486	/* Low dword of the TSC_AUX msr only. */
2487	CPUMQueryGuestMsr(pVCpu, MSR_K8_TSC_AUX, &pCtx->rcx);
2488	pCtx->rcx &= UINT32_C(0xffffffff);
2489
2490	return VINF_SUCCESS;
2491	}
2492
2493	/**
2494	* RDTSC Emulation.
2495	*/
2496	static int emInterpretRdtsc(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2497	{
2498	return EMInterpretRdtsc(pVM, pVCpu, pRegFrame);
2499	}
2500
2501	/**
2502	* Interpret RDPMC
2503	*
2504	* @returns VBox status code.
2505	* @param pVM The VM handle.
2506	* @param pVCpu The VMCPU handle.
2507	* @param pRegFrame The register frame.
2508	*
2509	*/
2510	VMMDECL(int) EMInterpretRdpmc(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2511	{
2512	unsigned uCR4 = CPUMGetGuestCR4(pVCpu);
2513
2514	/* If X86_CR4_PCE is not set, then CPL must be zero. */
2515	if ( !(uCR4 & X86_CR4_PCE)
2516	&& CPUMGetGuestCPL(pVCpu, pRegFrame) != 0)
2517	{
2518	Assert(CPUMGetGuestCR0(pVCpu) & X86_CR0_PE);
2519	return VERR_EM_INTERPRETER; /* genuine #GP */
2520	}
2521
2522	/* Just return zero here; rather tricky to properly emulate this, especially as the specs are a mess. */
2523	pRegFrame->rax = 0;
2524	pRegFrame->rdx = 0;
2525	/** @todo We should trigger a #GP here if the cpu doesn't support the index in ecx. */
2526	return VINF_SUCCESS;
2527	}
2528
2529	/**
2530	* RDPMC Emulation
2531	*/
2532	static int emInterpretRdpmc(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2533	{
2534	return EMInterpretRdpmc(pVM, pVCpu, pRegFrame);
2535	}
2536
2537	/**
2538	* MONITOR Emulation.
2539	*/
2540	VMMDECL(int) EMInterpretMonitor(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2541	{
2542	uint32_t u32Dummy, u32ExtFeatures, cpl;
2543
2544	if (pRegFrame->ecx != 0)
2545	{
2546	Log(("emInterpretMonitor: unexpected ecx=%x -> recompiler!!\n", pRegFrame->ecx));
2547	return VERR_EM_INTERPRETER; /* illegal value. */
2548	}
2549
2550	/* Get the current privilege level. */
2551	cpl = CPUMGetGuestCPL(pVCpu, pRegFrame);
2552	if (cpl != 0)
2553	return VERR_EM_INTERPRETER; /* supervisor only */
2554
2555	CPUMGetGuestCpuId(pVCpu, 1, &u32Dummy, &u32Dummy, &u32ExtFeatures, &u32Dummy);
2556	if (!(u32ExtFeatures & X86_CPUID_FEATURE_ECX_MONITOR))
2557	return VERR_EM_INTERPRETER; /* not supported */
2558
2559	pVCpu->em.s.mwait.uMonitorEAX = pRegFrame->rax;
2560	pVCpu->em.s.mwait.uMonitorECX = pRegFrame->rcx;
2561	pVCpu->em.s.mwait.uMonitorEDX = pRegFrame->rdx;
2562	pVCpu->em.s.mwait.fWait \|= EMMWAIT_FLAG_MONITOR_ACTIVE;
2563	return VINF_SUCCESS;
2564	}
2565
2566	static int emInterpretMonitor(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2567	{
2568	return EMInterpretMonitor(pVM, pVCpu, pRegFrame);
2569	}
2570
2571
2572	/**
2573	* MWAIT Emulation.
2574	*/
2575	VMMDECL(int) EMInterpretMWait(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2576	{
2577	uint32_t u32Dummy, u32ExtFeatures, cpl, u32MWaitFeatures;
2578
2579	/* Get the current privilege level. */
2580	cpl = CPUMGetGuestCPL(pVCpu, pRegFrame);
2581	if (cpl != 0)
2582	return VERR_EM_INTERPRETER; /* supervisor only */
2583
2584	CPUMGetGuestCpuId(pVCpu, 1, &u32Dummy, &u32Dummy, &u32ExtFeatures, &u32Dummy);
2585	if (!(u32ExtFeatures & X86_CPUID_FEATURE_ECX_MONITOR))
2586	return VERR_EM_INTERPRETER; /* not supported */
2587
2588	/*
2589	* CPUID.05H.ECX[0] defines support for power management extensions (eax)
2590	* CPUID.05H.ECX[1] defines support for interrupts as break events for mwait even when IF=0
2591	*/
2592	CPUMGetGuestCpuId(pVCpu, 5, &u32Dummy, &u32Dummy, &u32MWaitFeatures, &u32Dummy);
2593	if (pRegFrame->ecx > 1)
2594	{
2595	Log(("EMInterpretMWait: unexpected ecx value %x -> recompiler\n", pRegFrame->ecx));
2596	return VERR_EM_INTERPRETER; /* illegal value. */
2597	}
2598
2599	if (pRegFrame->ecx)
2600	{
2601	if (!(u32MWaitFeatures & X86_CPUID_MWAIT_ECX_BREAKIRQIF0))
2602	{
2603	Log(("EMInterpretMWait: unsupported X86_CPUID_MWAIT_ECX_BREAKIRQIF0 -> recompiler\n"));
2604	return VERR_EM_INTERPRETER; /* illegal value. */
2605	}
2606
2607	pVCpu->em.s.mwait.fWait = EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0;
2608	}
2609	else
2610	pVCpu->em.s.mwait.fWait = EMMWAIT_FLAG_ACTIVE;
2611
2612	pVCpu->em.s.mwait.uMWaitEAX = pRegFrame->rax;
2613	pVCpu->em.s.mwait.uMWaitECX = pRegFrame->rcx;
2614
2615	/** @todo not completely correct */
2616	return VINF_EM_HALT;
2617	}
2618
2619	static int emInterpretMWait(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2620	{
2621	return EMInterpretMWait(pVM, pVCpu, pRegFrame);
2622	}
2623
2624
2625	#ifdef LOG_ENABLED
2626	static const char *emMSRtoString(uint32_t uMsr)
2627	{
2628	switch (uMsr)
2629	{
2630	case MSR_IA32_APICBASE:
2631	return "MSR_IA32_APICBASE";
2632	case MSR_IA32_CR_PAT:
2633	return "MSR_IA32_CR_PAT";
2634	case MSR_IA32_SYSENTER_CS:
2635	return "MSR_IA32_SYSENTER_CS";
2636	case MSR_IA32_SYSENTER_EIP:
2637	return "MSR_IA32_SYSENTER_EIP";
2638	case MSR_IA32_SYSENTER_ESP:
2639	return "MSR_IA32_SYSENTER_ESP";
2640	case MSR_K6_EFER:
2641	return "MSR_K6_EFER";
2642	case MSR_K8_SF_MASK:
2643	return "MSR_K8_SF_MASK";
2644	case MSR_K6_STAR:
2645	return "MSR_K6_STAR";
2646	case MSR_K8_LSTAR:
2647	return "MSR_K8_LSTAR";
2648	case MSR_K8_CSTAR:
2649	return "MSR_K8_CSTAR";
2650	case MSR_K8_FS_BASE:
2651	return "MSR_K8_FS_BASE";
2652	case MSR_K8_GS_BASE:
2653	return "MSR_K8_GS_BASE";
2654	case MSR_K8_KERNEL_GS_BASE:
2655	return "MSR_K8_KERNEL_GS_BASE";
2656	case MSR_K8_TSC_AUX:
2657	return "MSR_K8_TSC_AUX";
2658	case MSR_IA32_BIOS_SIGN_ID:
2659	return "Unsupported MSR_IA32_BIOS_SIGN_ID";
2660	case MSR_IA32_PLATFORM_ID:
2661	return "Unsupported MSR_IA32_PLATFORM_ID";
2662	case MSR_IA32_BIOS_UPDT_TRIG:
2663	return "Unsupported MSR_IA32_BIOS_UPDT_TRIG";
2664	case MSR_IA32_TSC:
2665	return "MSR_IA32_TSC";
2666	case MSR_IA32_MISC_ENABLE:
2667	return "Unsupported MSR_IA32_MISC_ENABLE";
2668	case MSR_IA32_MTRR_CAP:
2669	return "Unsupported MSR_IA32_MTRR_CAP";
2670	case MSR_IA32_MCP_CAP:
2671	return "Unsupported MSR_IA32_MCP_CAP";
2672	case MSR_IA32_MCP_STATUS:
2673	return "Unsupported MSR_IA32_MCP_STATUS";
2674	case MSR_IA32_MCP_CTRL:
2675	return "Unsupported MSR_IA32_MCP_CTRL";
2676	case MSR_IA32_MTRR_DEF_TYPE:
2677	return "Unsupported MSR_IA32_MTRR_DEF_TYPE";
2678	case MSR_K7_EVNTSEL0:
2679	return "Unsupported MSR_K7_EVNTSEL0";
2680	case MSR_K7_EVNTSEL1:
2681	return "Unsupported MSR_K7_EVNTSEL1";
2682	case MSR_K7_EVNTSEL2:
2683	return "Unsupported MSR_K7_EVNTSEL2";
2684	case MSR_K7_EVNTSEL3:
2685	return "Unsupported MSR_K7_EVNTSEL3";
2686	case MSR_IA32_MC0_CTL:
2687	return "Unsupported MSR_IA32_MC0_CTL";
2688	case MSR_IA32_MC0_STATUS:
2689	return "Unsupported MSR_IA32_MC0_STATUS";
2690	case MSR_IA32_PERFEVTSEL0:
2691	return "Unsupported MSR_IA32_PERFEVTSEL0";
2692	case MSR_IA32_PERFEVTSEL1:
2693	return "Unsupported MSR_IA32_PERFEVTSEL1";
2694	case MSR_IA32_PERF_STATUS:
2695	return "MSR_IA32_PERF_STATUS";
2696	case MSR_IA32_PLATFORM_INFO:
2697	return "MSR_IA32_PLATFORM_INFO";
2698	case MSR_IA32_PERF_CTL:
2699	return "Unsupported MSR_IA32_PERF_CTL";
2700	case MSR_K7_PERFCTR0:
2701	return "Unsupported MSR_K7_PERFCTR0";
2702	case MSR_K7_PERFCTR1:
2703	return "Unsupported MSR_K7_PERFCTR1";
2704	case MSR_K7_PERFCTR2:
2705	return "Unsupported MSR_K7_PERFCTR2";
2706	case MSR_K7_PERFCTR3:
2707	return "Unsupported MSR_K7_PERFCTR3";
2708	case MSR_IA32_PMC0:
2709	return "Unsupported MSR_IA32_PMC0";
2710	case MSR_IA32_PMC1:
2711	return "Unsupported MSR_IA32_PMC1";
2712	case MSR_IA32_PMC2:
2713	return "Unsupported MSR_IA32_PMC2";
2714	case MSR_IA32_PMC3:
2715	return "Unsupported MSR_IA32_PMC3";
2716	}
2717	return "Unknown MSR";
2718	}
2719	#endif /* LOG_ENABLED */
2720
2721
2722	/**
2723	* Interpret RDMSR
2724	*
2725	* @returns VBox status code.
2726	* @param pVM The VM handle.
2727	* @param pVCpu The VMCPU handle.
2728	* @param pRegFrame The register frame.
2729	*/
2730	VMMDECL(int) EMInterpretRdmsr(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2731	{
2732	/** @todo According to the Intel manuals, there's a REX version of RDMSR that is slightly different.
2733	* That version clears the high dwords of both RDX & RAX */
2734
2735	/* Get the current privilege level. */
2736	if (CPUMGetGuestCPL(pVCpu, pRegFrame) != 0)
2737	return VERR_EM_INTERPRETER; /* supervisor only */
2738
2739	uint64_t uValue;
2740	int rc = CPUMQueryGuestMsr(pVCpu, pRegFrame->ecx, &uValue);
2741	if (RT_UNLIKELY(rc != VINF_SUCCESS))
2742	{
2743	Assert(rc == VERR_CPUM_RAISE_GP_0);
2744	return VERR_EM_INTERPRETER;
2745	}
2746	pRegFrame->rax = (uint32_t) uValue;
2747	pRegFrame->rdx = (uint32_t)(uValue >> 32);
2748	LogFlow(("EMInterpretRdmsr %s (%x) -> %RX64\n", emMSRtoString(pRegFrame->ecx), pRegFrame->ecx, uValue));
2749	return rc;
2750	}
2751
2752
2753	/**
2754	* RDMSR Emulation.
2755	*/
2756	static int emInterpretRdmsr(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2757	{
2758	/* Note: The Intel manual claims there's a REX version of RDMSR that's slightly
2759	different, so we play safe by completely disassembling the instruction. */
2760	Assert(!(pDis->prefix & PREFIX_REX));
2761	return EMInterpretRdmsr(pVM, pVCpu, pRegFrame);
2762	}
2763
2764
2765	/**
2766	* Interpret WRMSR
2767	*
2768	* @returns VBox status code.
2769	* @param pVM The VM handle.
2770	* @param pVCpu The VMCPU handle.
2771	* @param pRegFrame The register frame.
2772	*/
2773	VMMDECL(int) EMInterpretWrmsr(PVM pVM, PVMCPU pVCpu, PCPUMCTXCORE pRegFrame)
2774	{
2775	/* Check the current privilege level, this instruction is supervisor only. */
2776	if (CPUMGetGuestCPL(pVCpu, pRegFrame) != 0)
2777	return VERR_EM_INTERPRETER; /** @todo raise \#GP(0) */
2778
2779	int rc = CPUMSetGuestMsr(pVCpu, pRegFrame->ecx, RT_MAKE_U64(pRegFrame->eax, pRegFrame->edx));
2780	if (rc != VINF_SUCCESS)
2781	{
2782	Assert(rc == VERR_CPUM_RAISE_GP_0);
2783	return VERR_EM_INTERPRETER;
2784	}
2785	LogFlow(("EMInterpretWrmsr %s (%x) val=%RX64\n", emMSRtoString(pRegFrame->ecx), pRegFrame->ecx,
2786	RT_MAKE_U64(pRegFrame->eax, pRegFrame->edx)));
2787	return rc;
2788	}
2789
2790
2791	/**
2792	* WRMSR Emulation.
2793	*/
2794	static int emInterpretWrmsr(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
2795	{
2796	return EMInterpretWrmsr(pVM, pVCpu, pRegFrame);
2797	}
2798
2799
2800	/**
2801	* Internal worker.
2802	* @copydoc EMInterpretInstructionCPU
2803	*/
2804	DECLINLINE(int) emInterpretInstructionCPU(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
2805	uint32_t *pcbSize, EMCODETYPE enmCodeType)
2806	{
2807	Assert(enmCodeType == EMCODETYPE_SUPERVISOR \|\| enmCodeType == EMCODETYPE_ALL);
2808	Assert(pcbSize);
2809	*pcbSize = 0;
2810
2811	if (enmCodeType == EMCODETYPE_SUPERVISOR)
2812	{
2813	/*
2814	* Only supervisor guest code!!
2815	* And no complicated prefixes.
2816	*/
2817	/* Get the current privilege level. */
2818	uint32_t cpl = CPUMGetGuestCPL(pVCpu, pRegFrame);
2819	if ( cpl != 0
2820	&& pDis->pCurInstr->opcode != OP_RDTSC) /* rdtsc requires emulation in ring 3 as well */
2821	{
2822	Log(("WARNING: refusing instruction emulation for user-mode code!!\n"));
2823	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedUserMode));
2824	return VERR_EM_INTERPRETER;
2825	}
2826	}
2827	else
2828	Log2(("emInterpretInstructionCPU allowed to interpret user-level code!!\n"));
2829
2830	#ifdef IN_RC
2831	if ( (pDis->prefix & (PREFIX_REPNE \| PREFIX_REP))
2832	\|\| ( (pDis->prefix & PREFIX_LOCK)
2833	&& pDis->pCurInstr->opcode != OP_CMPXCHG
2834	&& pDis->pCurInstr->opcode != OP_CMPXCHG8B
2835	&& pDis->pCurInstr->opcode != OP_XADD
2836	&& pDis->pCurInstr->opcode != OP_OR
2837	&& pDis->pCurInstr->opcode != OP_AND
2838	&& pDis->pCurInstr->opcode != OP_XOR
2839	&& pDis->pCurInstr->opcode != OP_BTR
2840	)
2841	)
2842	#else
2843	if ( (pDis->prefix & PREFIX_REPNE)
2844	\|\| ( (pDis->prefix & PREFIX_REP)
2845	&& pDis->pCurInstr->opcode != OP_STOSWD
2846	)
2847	\|\| ( (pDis->prefix & PREFIX_LOCK)
2848	&& pDis->pCurInstr->opcode != OP_OR
2849	&& pDis->pCurInstr->opcode != OP_AND
2850	&& pDis->pCurInstr->opcode != OP_XOR
2851	&& pDis->pCurInstr->opcode != OP_BTR
2852	&& pDis->pCurInstr->opcode != OP_CMPXCHG
2853	&& pDis->pCurInstr->opcode != OP_CMPXCHG8B
2854	)
2855	)
2856	#endif
2857	{
2858	//Log(("EMInterpretInstruction: wrong prefix!!\n"));
2859	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedPrefix));
2860	return VERR_EM_INTERPRETER;
2861	}
2862
2863	#if HC_ARCH_BITS == 32
2864	/*
2865	* Unable to emulate most >4 bytes accesses in 32 bits mode.
2866	* Whitelisted instructions are safe.
2867	*/
2868	if ( pDis->param1.size > 4
2869	&& CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
2870	{
2871	uint32_t uOpCode = pDis->pCurInstr->opcode;
2872	if ( uOpCode != OP_STOSWD
2873	&& uOpCode != OP_MOV
2874	&& uOpCode != OP_CMPXCHG8B
2875	&& uOpCode != OP_XCHG
2876	&& uOpCode != OP_BTS
2877	&& uOpCode != OP_BTR
2878	&& uOpCode != OP_BTC
2879	# ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
2880	&& uOpCode != OP_CMPXCHG /* solaris */
2881	&& uOpCode != OP_AND /* windows */
2882	&& uOpCode != OP_OR /* windows */
2883	&& uOpCode != OP_XOR /* because we can */
2884	&& uOpCode != OP_ADD /* windows (dripple) */
2885	&& uOpCode != OP_ADC /* because we can */
2886	&& uOpCode != OP_SUB /* because we can */
2887	/** @todo OP_BTS or is that a different kind of failure? */
2888	# endif
2889	)
2890	{
2891	# ifdef VBOX_WITH_STATISTICS
2892	switch (pDis->pCurInstr->opcode)
2893	{
2894	# define INTERPRET_FAILED_CASE(opcode, Instr) \
2895	case opcode: STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); break;
2896	INTERPRET_FAILED_CASE(OP_XCHG,Xchg);
2897	INTERPRET_FAILED_CASE(OP_DEC,Dec);
2898	INTERPRET_FAILED_CASE(OP_INC,Inc);
2899	INTERPRET_FAILED_CASE(OP_POP,Pop);
2900	INTERPRET_FAILED_CASE(OP_OR, Or);
2901	INTERPRET_FAILED_CASE(OP_XOR,Xor);
2902	INTERPRET_FAILED_CASE(OP_AND,And);
2903	INTERPRET_FAILED_CASE(OP_MOV,Mov);
2904	INTERPRET_FAILED_CASE(OP_STOSWD,StosWD);
2905	INTERPRET_FAILED_CASE(OP_INVLPG,InvlPg);
2906	INTERPRET_FAILED_CASE(OP_CPUID,CpuId);
2907	INTERPRET_FAILED_CASE(OP_MOV_CR,MovCRx);
2908	INTERPRET_FAILED_CASE(OP_MOV_DR,MovDRx);
2909	INTERPRET_FAILED_CASE(OP_LLDT,LLdt);
2910	INTERPRET_FAILED_CASE(OP_LIDT,LIdt);
2911	INTERPRET_FAILED_CASE(OP_LGDT,LGdt);
2912	INTERPRET_FAILED_CASE(OP_LMSW,Lmsw);
2913	INTERPRET_FAILED_CASE(OP_CLTS,Clts);
2914	INTERPRET_FAILED_CASE(OP_MONITOR,Monitor);
2915	INTERPRET_FAILED_CASE(OP_MWAIT,MWait);
2916	INTERPRET_FAILED_CASE(OP_RDMSR,Rdmsr);
2917	INTERPRET_FAILED_CASE(OP_WRMSR,Wrmsr);
2918	INTERPRET_FAILED_CASE(OP_ADD,Add);
2919	INTERPRET_FAILED_CASE(OP_SUB,Sub);
2920	INTERPRET_FAILED_CASE(OP_ADC,Adc);
2921	INTERPRET_FAILED_CASE(OP_BTR,Btr);
2922	INTERPRET_FAILED_CASE(OP_BTS,Bts);
2923	INTERPRET_FAILED_CASE(OP_BTC,Btc);
2924	INTERPRET_FAILED_CASE(OP_RDTSC,Rdtsc);
2925	INTERPRET_FAILED_CASE(OP_CMPXCHG, CmpXchg);
2926	INTERPRET_FAILED_CASE(OP_STI, Sti);
2927	INTERPRET_FAILED_CASE(OP_XADD,XAdd);
2928	INTERPRET_FAILED_CASE(OP_CMPXCHG8B,CmpXchg8b);
2929	INTERPRET_FAILED_CASE(OP_HLT, Hlt);
2930	INTERPRET_FAILED_CASE(OP_IRET,Iret);
2931	INTERPRET_FAILED_CASE(OP_WBINVD,WbInvd);
2932	INTERPRET_FAILED_CASE(OP_MOVNTPS,MovNTPS);
2933	# undef INTERPRET_FAILED_CASE
2934	default:
2935	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedMisc));
2936	break;
2937	}
2938	# endif /* VBOX_WITH_STATISTICS */
2939	return VERR_EM_INTERPRETER;
2940	}
2941	}
2942	#endif
2943
2944	int rc;
2945	#if (defined(VBOX_STRICT) \|\| defined(LOG_ENABLED))
2946	LogFlow(("emInterpretInstructionCPU %s\n", emGetMnemonic(pDis)));
2947	#endif
2948	switch (pDis->pCurInstr->opcode)
2949	{
2950	/*
2951	* Macros for generating the right case statements.
2952	*/
2953	# define INTERPRET_CASE_EX_LOCK_PARAM3(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock) \
2954	case opcode:\
2955	if (pDis->prefix & PREFIX_LOCK) \
2956	rc = emInterpretLock##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulateLock); \
2957	else \
2958	rc = emInterpret##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulate); \
2959	if (RT_SUCCESS(rc)) \
2960	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
2961	else \
2962	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
2963	return rc
2964	#define INTERPRET_CASE_EX_PARAM3(opcode, Instr, InstrFn, pfnEmulate) \
2965	case opcode:\
2966	rc = emInterpret##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulate); \
2967	if (RT_SUCCESS(rc)) \
2968	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
2969	else \
2970	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
2971	return rc
2972
2973	#define INTERPRET_CASE_EX_PARAM2(opcode, Instr, InstrFn, pfnEmulate) \
2974	INTERPRET_CASE_EX_PARAM3(opcode, Instr, InstrFn, pfnEmulate)
2975	#define INTERPRET_CASE_EX_LOCK_PARAM2(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock) \
2976	INTERPRET_CASE_EX_LOCK_PARAM3(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock)
2977
2978	#define INTERPRET_CASE(opcode, Instr) \
2979	case opcode:\
2980	rc = emInterpret##Instr(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize); \
2981	if (RT_SUCCESS(rc)) \
2982	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
2983	else \
2984	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
2985	return rc
2986
2987	#define INTERPRET_CASE_EX_DUAL_PARAM2(opcode, Instr, InstrFn) \
2988	case opcode:\
2989	rc = emInterpret##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize); \
2990	if (RT_SUCCESS(rc)) \
2991	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Instr)); \
2992	else \
2993	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); \
2994	return rc
2995
2996	#define INTERPRET_STAT_CASE(opcode, Instr) \
2997	case opcode: STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,Failed##Instr)); return VERR_EM_INTERPRETER;
2998
2999	/*
3000	* The actual case statements.
3001	*/
3002	INTERPRET_CASE(OP_XCHG,Xchg);
3003	INTERPRET_CASE_EX_PARAM2(OP_DEC,Dec, IncDec, EMEmulateDec);
3004	INTERPRET_CASE_EX_PARAM2(OP_INC,Inc, IncDec, EMEmulateInc);
3005	INTERPRET_CASE(OP_POP,Pop);
3006	INTERPRET_CASE_EX_LOCK_PARAM3(OP_OR, Or, OrXorAnd, EMEmulateOr, EMEmulateLockOr);
3007	INTERPRET_CASE_EX_LOCK_PARAM3(OP_XOR,Xor, OrXorAnd, EMEmulateXor, EMEmulateLockXor);
3008	INTERPRET_CASE_EX_LOCK_PARAM3(OP_AND,And, OrXorAnd, EMEmulateAnd, EMEmulateLockAnd);
3009	INTERPRET_CASE(OP_MOV,Mov);
3010	#ifndef IN_RC
3011	INTERPRET_CASE(OP_STOSWD,StosWD);
3012	#endif
3013	INTERPRET_CASE(OP_INVLPG,InvlPg);
3014	INTERPRET_CASE(OP_CPUID,CpuId);
3015	INTERPRET_CASE(OP_MOV_CR,MovCRx);
3016	INTERPRET_CASE(OP_MOV_DR,MovDRx);
3017	#ifdef IN_RING0
3018	INTERPRET_CASE_EX_DUAL_PARAM2(OP_LIDT, LIdt, LIGdt);
3019	INTERPRET_CASE_EX_DUAL_PARAM2(OP_LGDT, LGdt, LIGdt);
3020	#endif
3021	INTERPRET_CASE(OP_LLDT,LLdt);
3022	INTERPRET_CASE(OP_LMSW,Lmsw);
3023	#ifdef EM_EMULATE_SMSW
3024	INTERPRET_CASE(OP_SMSW,Smsw);
3025	#endif
3026	INTERPRET_CASE(OP_CLTS,Clts);
3027	INTERPRET_CASE(OP_MONITOR, Monitor);
3028	INTERPRET_CASE(OP_MWAIT, MWait);
3029	INTERPRET_CASE(OP_RDMSR, Rdmsr);
3030	INTERPRET_CASE(OP_WRMSR, Wrmsr);
3031	INTERPRET_CASE_EX_PARAM3(OP_ADD,Add, AddSub, EMEmulateAdd);
3032	INTERPRET_CASE_EX_PARAM3(OP_SUB,Sub, AddSub, EMEmulateSub);
3033	INTERPRET_CASE(OP_ADC,Adc);
3034	INTERPRET_CASE_EX_LOCK_PARAM2(OP_BTR,Btr, BitTest, EMEmulateBtr, EMEmulateLockBtr);
3035	INTERPRET_CASE_EX_PARAM2(OP_BTS,Bts, BitTest, EMEmulateBts);
3036	INTERPRET_CASE_EX_PARAM2(OP_BTC,Btc, BitTest, EMEmulateBtc);
3037	INTERPRET_CASE(OP_RDPMC,Rdpmc);
3038	INTERPRET_CASE(OP_RDTSC,Rdtsc);
3039	INTERPRET_CASE(OP_CMPXCHG, CmpXchg);
3040	#ifdef IN_RC
3041	INTERPRET_CASE(OP_STI,Sti);
3042	INTERPRET_CASE(OP_XADD, XAdd);
3043	#endif
3044	INTERPRET_CASE(OP_CMPXCHG8B, CmpXchg8b);
3045	INTERPRET_CASE(OP_HLT,Hlt);
3046	INTERPRET_CASE(OP_IRET,Iret);
3047	INTERPRET_CASE(OP_WBINVD,WbInvd);
3048	#ifdef VBOX_WITH_STATISTICS
3049	# ifndef IN_RC
3050	INTERPRET_STAT_CASE(OP_XADD, XAdd);
3051	# endif
3052	INTERPRET_STAT_CASE(OP_MOVNTPS,MovNTPS);
3053	#endif
3054
3055	default:
3056	Log3(("emInterpretInstructionCPU: opcode=%d\n", pDis->pCurInstr->opcode));
3057	STAM_COUNTER_INC(&pVCpu->em.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,FailedMisc));
3058	return VERR_EM_INTERPRETER;
3059
3060	#undef INTERPRET_CASE_EX_PARAM2
3061	#undef INTERPRET_STAT_CASE
3062	#undef INTERPRET_CASE_EX
3063	#undef INTERPRET_CASE
3064	} /* switch (opcode) */
3065	AssertFailed();
3066	return VERR_INTERNAL_ERROR;
3067	}
3068
3069
3070	/**
3071	* Sets the PC for which interrupts should be inhibited.
3072	*
3073	* @param pVCpu The VMCPU handle.
3074	* @param PC The PC.
3075	*/
3076	VMMDECL(void) EMSetInhibitInterruptsPC(PVMCPU pVCpu, RTGCUINTPTR PC)
3077	{
3078	pVCpu->em.s.GCPtrInhibitInterrupts = PC;
3079	VMCPU_FF_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
3080	}
3081
3082
3083	/**
3084	* Gets the PC for which interrupts should be inhibited.
3085	*
3086	* There are a few instructions which inhibits or delays interrupts
3087	* for the instruction following them. These instructions are:
3088	* - STI
3089	* - MOV SS, r/m16
3090	* - POP SS
3091	*
3092	* @returns The PC for which interrupts should be inhibited.
3093	* @param pVCpu The VMCPU handle.
3094	*
3095	*/
3096	VMMDECL(RTGCUINTPTR) EMGetInhibitInterruptsPC(PVMCPU pVCpu)
3097	{
3098	return pVCpu->em.s.GCPtrInhibitInterrupts;
3099	}
3100
3101	/**
3102	* Locks REM execution to a single VCpu
3103	*
3104	* @param pVM VM handle.
3105	*/
3106	VMMDECL(void) EMRemLock(PVM pVM)
3107	{
3108	if (!PDMCritSectIsInitialized(&pVM->em.s.CritSectREM))
3109	return; /* early init */
3110
3111	Assert(!PGMIsLockOwner(pVM) && !IOMIsLockOwner(pVM));
3112	int rc = PDMCritSectEnter(&pVM->em.s.CritSectREM, VERR_SEM_BUSY);
3113	AssertMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
3114	}
3115
3116	/**
3117	* Unlocks REM execution
3118	*
3119	* @param pVM VM handle.
3120	*/
3121	VMMDECL(void) EMRemUnlock(PVM pVM)
3122	{
3123	if (!PDMCritSectIsInitialized(&pVM->em.s.CritSectREM))
3124	return; /* early init */
3125
3126	PDMCritSectLeave(&pVM->em.s.CritSectREM);
3127	}
3128
3129	/**
3130	* Check if this VCPU currently owns the REM lock.
3131	*
3132	* @returns bool owner/not owner
3133	* @param pVM The VM to operate on.
3134	*/
3135	VMMDECL(bool) EMRemIsLockOwner(PVM pVM)
3136	{
3137	return PDMCritSectIsOwner(&pVM->em.s.CritSectREM);
3138	}
3139
3140	/**
3141	* Try to acquire the REM lock.
3142	*
3143	* @returns VBox status code
3144	* @param pVM The VM to operate on.
3145	*/
3146	VMMDECL(int) EMTryEnterRemLock(PVM pVM)
3147	{
3148	return PDMCritSectTryEnter(&pVM->em.s.CritSectREM);
3149	}
3150
3151	/**
3152	* Determine if we should continue after encountering a hlt or mwait instruction
3153	*
3154	* @returns boolean
3155	* @param pVCpu The VMCPU to operate on.
3156	* @param pCtx Current CPU context
3157	*/
3158	VMMDECL(bool) EMShouldContinueAfterHalt(PVMCPU pVCpu, PCPUMCTX pCtx)
3159	{
3160	if ( pCtx->eflags.Bits.u1IF
3161	\|\| ((pVCpu->em.s.mwait.fWait & (EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0)) == (EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0)))
3162	{
3163	pVCpu->em.s.mwait.fWait &= ~(EMMWAIT_FLAG_ACTIVE \| EMMWAIT_FLAG_BREAKIRQIF0);
3164	return !!VMCPU_FF_ISPENDING(pVCpu, (VMCPU_FF_INTERRUPT_APIC\|VMCPU_FF_INTERRUPT_PIC));
3165	}
3166
3167	return false;
3168	}
3169

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

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

Download in other formats: