EMAll.cpp@ 13447

Last change on this file since 13447 was 13447, checked in by vboxsync, 16 years ago
Logging change
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 97.7 KB

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

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

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

Download in other formats: