EMAllA.asm@ 29450

Last change on this file since 29450 was 28800, checked in by vboxsync, 15 years ago
Automated rebranding to Oracle copyright/license strings via filemuncher
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 45.9 KB

Line
1	; $Id: EMAllA.asm 28800 2010-04-27 08:22:32Z vboxsync $
2	;; @file
3	; EM Assembly Routines.
4	;
5
6	;
7	; Copyright (C) 2006-2007 Oracle Corporation
8	;
9	; This file is part of VirtualBox Open Source Edition (OSE), as
10	; available from http://www.virtualbox.org. This file is free software;
11	; you can redistribute it and/or modify it under the terms of the GNU
12	; General Public License (GPL) as published by the Free Software
13	; Foundation, in version 2 as it comes in the "COPYING" file of the
14	; VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	;
17
18	;*******************************************************************************
19	;* Header Files *
20	;*******************************************************************************
21	%include "VBox/asmdefs.mac"
22	%include "VBox/err.mac"
23	%include "VBox/x86.mac"
24
25	;; @def MY_PTR_REG
26	; The register we use for value pointers (And,Or,Dec,Inc).
27	%ifdef RT_ARCH_AMD64
28	%define MY_PTR_REG rcx
29	%else
30	%define MY_PTR_REG ecx
31	%endif
32
33	;; @def MY_RET_REG
34	; The register we return the result in.
35	%ifdef RT_ARCH_AMD64
36	%define MY_RET_REG rax
37	%else
38	%define MY_RET_REG eax
39	%endif
40
41	;; @def RT_ARCH_AMD64
42	; Indicator for whether we can deal with 8 byte operatands. (Darwin fun again.)
43	%ifdef RT_ARCH_AMD64
44	%define CAN_DO_8_BYTE_OP 1
45	%endif
46	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
47	%define CAN_DO_8_BYTE_OP 1
48	%define MY_PTR_REG64 rcx
49	%endif
50
51
52	;*******************************************************************************
53	;* External Symbols *
54	;*******************************************************************************
55	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
56	extern NAME(SUPR0Abs64bitKernelCS)
57	extern NAME(SUPR0AbsKernelCS)
58	%endif
59
60
61	BEGINCODE
62
63
64	;;
65	; Emulate CMP instruction, CDECL calling conv.
66	; VMMDECL(uint32_t) EMEmulateCmp(uint32_t u32Param1, uint64_t u64Param2, size_t cb);
67	;
68	; @returns EFLAGS after the operation, only arithmetic flags are valid.
69	; @param [esp + 04h] rdi rcx Param 1 - First parameter (Dst).
70	; @param [esp + 08h] rsi edx Param 2 - Second parameter (Src).
71	; @param [esp + 10h] Param 3 - Size of parameters, only 1/2/4/8 (64 bits host only) is valid.
72	;
73	align 16
74	BEGINPROC EMEmulateCmp
75	%ifdef RT_ARCH_AMD64
76	%ifdef RT_OS_WINDOWS
77	mov rax, r8 ; eax = size of parameters
78	%else ; !RT_OS_WINDOWS
79	mov rax, rdx ; rax = size of parameters
80	mov rcx, rdi ; rcx = first parameter
81	mov rdx, rsi ; rdx = second parameter
82	%endif ; !RT_OS_WINDOWS
83	%else ; !RT_ARCH_AMD64
84	mov eax, [esp + 10h] ; eax = size of parameters
85	mov ecx, [esp + 04h] ; ecx = first parameter
86	mov edx, [esp + 08h] ; edx = second parameter
87	%endif
88
89	; switch on size
90	%ifdef RT_ARCH_AMD64
91	cmp al, 8
92	je short .do_qword ; 8 bytes variant
93	%endif
94	cmp al, 4
95	je short .do_dword ; 4 bytes variant
96	cmp al, 2
97	je short .do_word ; 2 byte variant
98	cmp al, 1
99	je short .do_byte ; 1 bytes variant
100	int3
101
102	; workers
103	%ifdef RT_ARCH_AMD64
104	.do_qword:
105	cmp rcx, rdx ; do 8 bytes CMP
106	jmp short .done
107	%endif
108
109	.do_dword:
110	cmp ecx, edx ; do 4 bytes CMP
111	jmp short .done
112
113	.do_word:
114	cmp cx, dx ; do 2 bytes CMP
115	jmp short .done
116
117	.do_byte:
118	cmp cl, dl ; do 1 byte CMP
119
120	; collect flags and return.
121	.done:
122	pushf
123	pop MY_RET_REG
124	retn
125	ENDPROC EMEmulateCmp
126
127
128	;;
129	; Emulate AND instruction, CDECL calling conv.
130	; VMMDECL(uint32_t) EMEmulateAnd(void *pvParam1, uint64_t u64Param2, size_t cb);
131	;
132	; @returns EFLAGS after the operation, only arithmetic flags are valid.
133	; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
134	; @param [esp + 08h] Param 2 - Second parameter.
135	; @param [esp + 10h] Param 3 - Size of parameters, only 1/2/4/8 (64 bits host only) is valid.
136	; @uses eax, ecx, edx
137	;
138	align 16
139	BEGINPROC EMEmulateAnd
140	%ifdef RT_ARCH_AMD64
141	%ifdef RT_OS_WINDOWS
142	mov rax, r8 ; eax = size of parameters
143	%else ; !RT_OS_WINDOWS
144	mov rax, rdx ; rax = size of parameters
145	mov rcx, rdi ; rcx = first parameter
146	mov rdx, rsi ; rdx = second parameter
147	%endif ; !RT_OS_WINDOWS
148	%else ; !RT_ARCH_AMD64
149	mov eax, [esp + 10h] ; eax = size of parameters
150	mov ecx, [esp + 04h] ; ecx = first parameter
151	mov edx, [esp + 08h] ; edx = second parameter
152	%endif
153
154	; switch on size
155	%ifdef CAN_DO_8_BYTE_OP
156	cmp al, 8
157	je short .do_qword ; 8 bytes variant
158	%endif
159	cmp al, 4
160	je short .do_dword ; 4 bytes variant
161	cmp al, 2
162	je short .do_word ; 2 byte variant
163	cmp al, 1
164	je short .do_byte ; 1 bytes variant
165	int3
166
167	; workers
168	%ifdef RT_ARCH_AMD64
169	.do_qword:
170	and [MY_PTR_REG], rdx ; do 8 bytes AND
171	jmp short .done
172	%endif
173
174	.do_dword:
175	and [MY_PTR_REG], edx ; do 4 bytes AND
176	jmp short .done
177
178	.do_word:
179	and [MY_PTR_REG], dx ; do 2 bytes AND
180	jmp short .done
181
182	.do_byte:
183	and [MY_PTR_REG], dl ; do 1 byte AND
184
185	; collect flags and return.
186	.done:
187	pushf
188	pop MY_RET_REG
189	retn
190
191	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
192	.do_qword:
193	db 0xea ; jmp far .sixtyfourbit_mode
194	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
195	BITS 64
196	.sixtyfourbit_mode:
197	and esp, 0ffffffffh
198	and MY_PTR_REG, 0ffffffffh
199	mov rdx, qword [rsp + 08h] ; rdx = second parameter
200	and [MY_PTR_REG64], rdx ; do 8 bytes AND
201	jmp far [.fpret wrt rip]
202	.fpret: ; 16:32 Pointer to .done.
203	dd .done, NAME(SUPR0AbsKernelCS)
204	BITS 32
205	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
206	ENDPROC EMEmulateAnd
207
208
209	;;
210	; Emulate LOCK AND instruction.
211	; VMMDECL(int) EMEmulateLockAnd(void pvParam1, uint64_t u64Param2, size_t cbSize, RTGCUINTREG32 pf);
212	;
213	; @returns VINF_SUCCESS on success, VERR_ACCESS_DENIED on \#PF (GC only).
214	; @param [esp + 04h] gcc:rdi msc:rcx Param 1 - First parameter - pointer to data item (the real stuff).
215	; @param [esp + 08h] gcc:rsi msc:rdx Param 2 - Second parameter- the immediate / register value.
216	; @param [esp + 10h] gcc:rdx msc:r8 Param 3 - Size of the operation - 1, 2, 4 or 8 bytes.
217	; @param [esp + 14h] gcc:rcx msc:r9 Param 4 - Where to store the eflags on success.
218	; only arithmetic flags are valid.
219	align 16
220	BEGINPROC EMEmulateLockAnd
221	%ifdef RT_ARCH_AMD64
222	%ifdef RT_OS_WINDOWS
223	mov rax, r8 ; eax = size of parameters
224	%else ; !RT_OS_WINDOWS
225	mov r9, rcx ; r9 = eflags result ptr
226	mov rax, rdx ; rax = size of parameters
227	mov rcx, rdi ; rcx = first parameter
228	mov rdx, rsi ; rdx = second parameter
229	%endif ; !RT_OS_WINDOWS
230	%else ; !RT_ARCH_AMD64
231	mov eax, [esp + 10h] ; eax = size of parameters
232	mov ecx, [esp + 04h] ; ecx = first parameter (MY_PTR_REG)
233	mov edx, [esp + 08h] ; edx = second parameter
234	%endif
235
236	; switch on size
237	%ifdef CAN_DO_8_BYTE_OP
238	cmp al, 8
239	je short .do_qword ; 8 bytes variant
240	%endif
241	cmp al, 4
242	je short .do_dword ; 4 bytes variant
243	cmp al, 2
244	je short .do_word ; 2 byte variant
245	cmp al, 1
246	je short .do_byte ; 1 bytes variant
247	int3
248
249	; workers
250	%ifdef RT_ARCH_AMD64
251	.do_qword:
252	lock and [MY_PTR_REG], rdx ; do 8 bytes OR
253	jmp short .done
254	%endif
255
256	.do_dword:
257	lock and [MY_PTR_REG], edx ; do 4 bytes OR
258	jmp short .done
259
260	.do_word:
261	lock and [MY_PTR_REG], dx ; do 2 bytes OR
262	jmp short .done
263
264	.do_byte:
265	lock and [MY_PTR_REG], dl ; do 1 byte OR
266
267	; collect flags and return.
268	.done:
269	pushf
270	%ifdef RT_ARCH_AMD64
271	pop rax
272	mov [r9], eax
273	%else ; !RT_ARCH_AMD64
274	mov eax, [esp + 14h + 4]
275	pop dword [eax]
276	%endif
277	mov eax, VINF_SUCCESS
278	retn
279
280	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
281	.do_qword:
282	db 0xea ; jmp far .sixtyfourbit_mode
283	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
284	BITS 64
285	.sixtyfourbit_mode:
286	and esp, 0ffffffffh
287	and MY_PTR_REG, 0ffffffffh
288	mov rdx, qword [rsp + 08h] ; rdx = second parameter
289	lock and [MY_PTR_REG64], rdx ; do 8 bytes OR
290	jmp far [.fpret wrt rip]
291	.fpret: ; 16:32 Pointer to .done.
292	dd .done, NAME(SUPR0AbsKernelCS)
293	BITS 32
294	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
295
296
297	%ifdef IN_RC
298	; #PF resume point.
299	GLOBALNAME EMEmulateLockAnd_Error
300	mov eax, VERR_ACCESS_DENIED
301	ret
302	%endif
303
304	ENDPROC EMEmulateLockAnd
305
306	;;
307	; Emulate OR instruction, CDECL calling conv.
308	; VMMDECL(uint32_t) EMEmulateOr(void *pvParam1, uint64_t u64Param2, size_t cb);
309	;
310	; @returns EFLAGS after the operation, only arithmetic flags are valid.
311	; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
312	; @param [esp + 08h] Param 2 - Second parameter.
313	; @param [esp + 10h] Param 3 - Size of parameters, only 1/2/4/8 (64 bits host only) is valid.
314	; @uses eax, ecx, edx
315	;
316	align 16
317	BEGINPROC EMEmulateOr
318	%ifdef RT_ARCH_AMD64
319	%ifdef RT_OS_WINDOWS
320	mov rax, r8 ; eax = size of parameters
321	%else ; !RT_OS_WINDOWS
322	mov rax, rdx ; rax = size of parameters
323	mov rcx, rdi ; rcx = first parameter
324	mov rdx, rsi ; rdx = second parameter
325	%endif ; !RT_OS_WINDOWS
326	%else ; !RT_ARCH_AMD64
327	mov eax, [esp + 10h] ; eax = size of parameters
328	mov ecx, [esp + 04h] ; ecx = first parameter
329	mov edx, [esp + 08h] ; edx = second parameter
330	%endif
331
332	; switch on size
333	%ifdef CAN_DO_8_BYTE_OP
334	cmp al, 8
335	je short .do_qword ; 8 bytes variant
336	%endif
337	cmp al, 4
338	je short .do_dword ; 4 bytes variant
339	cmp al, 2
340	je short .do_word ; 2 byte variant
341	cmp al, 1
342	je short .do_byte ; 1 bytes variant
343	int3
344
345	; workers
346	%ifdef RT_ARCH_AMD64
347	.do_qword:
348	or [MY_PTR_REG], rdx ; do 8 bytes OR
349	jmp short .done
350	%endif
351
352	.do_dword:
353	or [MY_PTR_REG], edx ; do 4 bytes OR
354	jmp short .done
355
356	.do_word:
357	or [MY_PTR_REG], dx ; do 2 bytes OR
358	jmp short .done
359
360	.do_byte:
361	or [MY_PTR_REG], dl ; do 1 byte OR
362
363	; collect flags and return.
364	.done:
365	pushf
366	pop MY_RET_REG
367	retn
368
369	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
370	.do_qword:
371	db 0xea ; jmp far .sixtyfourbit_mode
372	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
373	BITS 64
374	.sixtyfourbit_mode:
375	and esp, 0ffffffffh
376	and MY_PTR_REG, 0ffffffffh
377	mov rdx, qword [rsp + 08h] ; rdx = second parameter
378	or [MY_PTR_REG64], rdx ; do 8 bytes OR
379	jmp far [.fpret wrt rip]
380	.fpret: ; 16:32 Pointer to .done.
381	dd .done, NAME(SUPR0AbsKernelCS)
382	BITS 32
383	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
384	ENDPROC EMEmulateOr
385
386
387	;;
388	; Emulate LOCK OR instruction.
389	; VMMDECL(int) EMEmulateLockOr(void pvParam1, uint64_t u64Param2, size_t cbSize, RTGCUINTREG32 pf);
390	;
391	; @returns VINF_SUCCESS on success, VERR_ACCESS_DENIED on \#PF (GC only).
392	; @param [esp + 04h] gcc:rdi msc:rcx Param 1 - First parameter - pointer to data item (the real stuff).
393	; @param [esp + 08h] gcc:rsi msc:rdx Param 2 - Second parameter- the immediate / register value.
394	; @param [esp + 10h] gcc:rdx msc:r8 Param 3 - Size of the operation - 1, 2, 4 or 8 bytes.
395	; @param [esp + 14h] gcc:rcx msc:r9 Param 4 - Where to store the eflags on success.
396	; only arithmetic flags are valid.
397	align 16
398	BEGINPROC EMEmulateLockOr
399	%ifdef RT_ARCH_AMD64
400	%ifdef RT_OS_WINDOWS
401	mov rax, r8 ; eax = size of parameters
402	%else ; !RT_OS_WINDOWS
403	mov r9, rcx ; r9 = eflags result ptr
404	mov rax, rdx ; rax = size of parameters
405	mov rcx, rdi ; rcx = first parameter
406	mov rdx, rsi ; rdx = second parameter
407	%endif ; !RT_OS_WINDOWS
408	%else ; !RT_ARCH_AMD64
409	mov eax, [esp + 10h] ; eax = size of parameters
410	mov ecx, [esp + 04h] ; ecx = first parameter (MY_PTR_REG)
411	mov edx, [esp + 08h] ; edx = second parameter
412	%endif
413
414	; switch on size
415	%ifdef CAN_DO_8_BYTE_OP
416	cmp al, 8
417	je short .do_qword ; 8 bytes variant
418	%endif
419	cmp al, 4
420	je short .do_dword ; 4 bytes variant
421	cmp al, 2
422	je short .do_word ; 2 byte variant
423	cmp al, 1
424	je short .do_byte ; 1 bytes variant
425	int3
426
427	; workers
428	%ifdef RT_ARCH_AMD64
429	.do_qword:
430	lock or [MY_PTR_REG], rdx ; do 8 bytes OR
431	jmp short .done
432	%endif
433
434	.do_dword:
435	lock or [MY_PTR_REG], edx ; do 4 bytes OR
436	jmp short .done
437
438	.do_word:
439	lock or [MY_PTR_REG], dx ; do 2 bytes OR
440	jmp short .done
441
442	.do_byte:
443	lock or [MY_PTR_REG], dl ; do 1 byte OR
444
445	; collect flags and return.
446	.done:
447	pushf
448	%ifdef RT_ARCH_AMD64
449	pop rax
450	mov [r9], eax
451	%else ; !RT_ARCH_AMD64
452	mov eax, [esp + 14h + 4]
453	pop dword [eax]
454	%endif
455	mov eax, VINF_SUCCESS
456	retn
457
458	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
459	.do_qword:
460	db 0xea ; jmp far .sixtyfourbit_mode
461	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
462	BITS 64
463	.sixtyfourbit_mode:
464	and esp, 0ffffffffh
465	and MY_PTR_REG, 0ffffffffh
466	mov rdx, qword [rsp + 08h] ; rdx = second parameter
467	lock or [MY_PTR_REG64], rdx ; do 8 bytes OR
468	jmp far [.fpret wrt rip]
469	.fpret: ; 16:32 Pointer to .done.
470	dd .done, NAME(SUPR0AbsKernelCS)
471	BITS 32
472	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
473
474
475	%ifdef IN_RC
476	; #PF resume point.
477	GLOBALNAME EMEmulateLockOr_Error
478	mov eax, VERR_ACCESS_DENIED
479	ret
480	%endif
481
482	ENDPROC EMEmulateLockOr
483
484
485	;;
486	; Emulate XOR instruction, CDECL calling conv.
487	; VMMDECL(uint32_t) EMEmulateXor(void *pvParam1, uint64_t u64Param2, size_t cb);
488	;
489	; @returns EFLAGS after the operation, only arithmetic flags are valid.
490	; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
491	; @param [esp + 08h] Param 2 - Second parameter.
492	; @param [esp + 10h] Param 3 - Size of parameters, only 1/2/4/8 (64 bits host only) is valid.
493	; @uses eax, ecx, edx
494	;
495	align 16
496	BEGINPROC EMEmulateXor
497	%ifdef RT_ARCH_AMD64
498	%ifdef RT_OS_WINDOWS
499	mov rax, r8 ; eax = size of parameters
500	%else ; !RT_OS_WINDOWS
501	mov rax, rdx ; rax = size of parameters
502	mov rcx, rdi ; rcx = first parameter
503	mov rdx, rsi ; rdx = second parameter
504	%endif ; !RT_OS_WINDOWS
505	%else ; !RT_ARCH_AMD64
506	mov eax, [esp + 10h] ; eax = size of parameters
507	mov ecx, [esp + 04h] ; ecx = first parameter
508	mov edx, [esp + 08h] ; edx = second parameter
509	%endif
510
511	; switch on size
512	%ifdef CAN_DO_8_BYTE_OP
513	cmp al, 8
514	je short .do_qword ; 8 bytes variant
515	%endif
516	cmp al, 4
517	je short .do_dword ; 4 bytes variant
518	cmp al, 2
519	je short .do_word ; 2 byte variant
520	cmp al, 1
521	je short .do_byte ; 1 bytes variant
522	int3
523
524	; workers
525	%ifdef RT_ARCH_AMD64
526	.do_qword:
527	xor [MY_PTR_REG], rdx ; do 8 bytes XOR
528	jmp short .done
529	%endif
530
531	.do_dword:
532	xor [MY_PTR_REG], edx ; do 4 bytes XOR
533	jmp short .done
534
535	.do_word:
536	xor [MY_PTR_REG], dx ; do 2 bytes XOR
537	jmp short .done
538
539	.do_byte:
540	xor [MY_PTR_REG], dl ; do 1 byte XOR
541
542	; collect flags and return.
543	.done:
544	pushf
545	pop MY_RET_REG
546	retn
547
548	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
549	.do_qword:
550	db 0xea ; jmp far .sixtyfourbit_mode
551	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
552	BITS 64
553	.sixtyfourbit_mode:
554	and esp, 0ffffffffh
555	and MY_PTR_REG, 0ffffffffh
556	mov rdx, qword [rsp + 08h] ; rdx = second parameter
557	xor [MY_PTR_REG64], rdx ; do 8 bytes XOR
558	jmp far [.fpret wrt rip]
559	.fpret: ; 16:32 Pointer to .done.
560	dd .done, NAME(SUPR0AbsKernelCS)
561	BITS 32
562	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
563	ENDPROC EMEmulateXor
564
565	;;
566	; Emulate LOCK XOR instruction.
567	; VMMDECL(int) EMEmulateLockXor(void pvParam1, uint64_t u64Param2, size_t cbSize, RTGCUINTREG32 pf);
568	;
569	; @returns VINF_SUCCESS on success, VERR_ACCESS_DENIED on \#PF (GC only).
570	; @param [esp + 04h] gcc:rdi msc:rcx Param 1 - First parameter - pointer to data item (the real stuff).
571	; @param [esp + 08h] gcc:rsi msc:rdx Param 2 - Second parameter- the immediate / register value.
572	; @param [esp + 10h] gcc:rdx msc:r8 Param 3 - Size of the operation - 1, 2, 4 or 8 bytes.
573	; @param [esp + 14h] gcc:rcx msc:r9 Param 4 - Where to store the eflags on success.
574	; only arithmetic flags are valid.
575	align 16
576	BEGINPROC EMEmulateLockXor
577	%ifdef RT_ARCH_AMD64
578	%ifdef RT_OS_WINDOWS
579	mov rax, r8 ; eax = size of parameters
580	%else ; !RT_OS_WINDOWS
581	mov r9, rcx ; r9 = eflags result ptr
582	mov rax, rdx ; rax = size of parameters
583	mov rcx, rdi ; rcx = first parameter
584	mov rdx, rsi ; rdx = second parameter
585	%endif ; !RT_OS_WINDOWS
586	%else ; !RT_ARCH_AMD64
587	mov eax, [esp + 10h] ; eax = size of parameters
588	mov ecx, [esp + 04h] ; ecx = first parameter (MY_PTR_REG)
589	mov edx, [esp + 08h] ; edx = second parameter
590	%endif
591
592	; switch on size
593	%ifdef CAN_DO_8_BYTE_OP
594	cmp al, 8
595	je short .do_qword ; 8 bytes variant
596	%endif
597	cmp al, 4
598	je short .do_dword ; 4 bytes variant
599	cmp al, 2
600	je short .do_word ; 2 byte variant
601	cmp al, 1
602	je short .do_byte ; 1 bytes variant
603	int3
604
605	; workers
606	%ifdef RT_ARCH_AMD64
607	.do_qword:
608	lock xor [MY_PTR_REG], rdx ; do 8 bytes OR
609	jmp short .done
610	%endif
611
612	.do_dword:
613	lock xor [MY_PTR_REG], edx ; do 4 bytes OR
614	jmp short .done
615
616	.do_word:
617	lock xor [MY_PTR_REG], dx ; do 2 bytes OR
618	jmp short .done
619
620	.do_byte:
621	lock xor [MY_PTR_REG], dl ; do 1 byte OR
622
623	; collect flags and return.
624	.done:
625	pushf
626	%ifdef RT_ARCH_AMD64
627	pop rax
628	mov [r9], eax
629	%else ; !RT_ARCH_AMD64
630	mov eax, [esp + 14h + 4]
631	pop dword [eax]
632	%endif
633	mov eax, VINF_SUCCESS
634	retn
635
636	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
637	.do_qword:
638	db 0xea ; jmp far .sixtyfourbit_mode
639	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
640	BITS 64
641	.sixtyfourbit_mode:
642	and esp, 0ffffffffh
643	and MY_PTR_REG, 0ffffffffh
644	mov rdx, qword [rsp + 08h] ; rdx = second parameter
645	lock xor [MY_PTR_REG64], rdx ; do 8 bytes OR
646	jmp far [.fpret wrt rip]
647	.fpret: ; 16:32 Pointer to .done.
648	dd .done, NAME(SUPR0AbsKernelCS)
649	BITS 32
650	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
651
652
653	%ifdef IN_RC
654	; #PF resume point.
655	GLOBALNAME EMEmulateLockXor_Error
656	mov eax, VERR_ACCESS_DENIED
657	ret
658	%endif
659
660	ENDPROC EMEmulateLockXor
661
662	;;
663	; Emulate INC instruction, CDECL calling conv.
664	; VMMDECL(uint32_t) EMEmulateInc(void *pvParam1, size_t cb);
665	;
666	; @returns EFLAGS after the operation, only arithmetic flags are valid.
667	; @param [esp + 04h] rdi rcx Param 1 - First parameter - pointer to data item.
668	; @param [esp + 08h] rsi rdx Param 2 - Size of parameters, only 1/2/4 is valid.
669	; @uses eax, ecx, edx
670	;
671	align 16
672	BEGINPROC EMEmulateInc
673	%ifdef RT_ARCH_AMD64
674	%ifdef RT_OS_WINDOWS
675	mov rax, rdx ; eax = size of parameters
676	%else ; !RT_OS_WINDOWS
677	mov rax, rsi ; eax = size of parameters
678	mov rcx, rdi ; rcx = first parameter
679	%endif ; !RT_OS_WINDOWS
680	%else ; !RT_ARCH_AMD64
681	mov eax, [esp + 08h] ; eax = size of parameters
682	mov ecx, [esp + 04h] ; ecx = first parameter
683	%endif
684
685	; switch on size
686	%ifdef RT_ARCH_AMD64
687	cmp al, 8
688	je short .do_qword ; 8 bytes variant
689	%endif
690	cmp al, 4
691	je short .do_dword ; 4 bytes variant
692	cmp al, 2
693	je short .do_word ; 2 byte variant
694	cmp al, 1
695	je short .do_byte ; 1 bytes variant
696	int3
697
698	; workers
699	%ifdef RT_ARCH_AMD64
700	.do_qword:
701	inc qword [MY_PTR_REG] ; do 8 bytes INC
702	jmp short .done
703	%endif
704
705	.do_dword:
706	inc dword [MY_PTR_REG] ; do 4 bytes INC
707	jmp short .done
708
709	.do_word:
710	inc word [MY_PTR_REG] ; do 2 bytes INC
711	jmp short .done
712
713	.do_byte:
714	inc byte [MY_PTR_REG] ; do 1 byte INC
715	jmp short .done
716
717	; collect flags and return.
718	.done:
719	pushf
720	pop MY_RET_REG
721	retn
722	ENDPROC EMEmulateInc
723
724
725	;;
726	; Emulate DEC instruction, CDECL calling conv.
727	; VMMDECL(uint32_t) EMEmulateDec(void *pvParam1, size_t cb);
728	;
729	; @returns EFLAGS after the operation, only arithmetic flags are valid.
730	; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
731	; @param [esp + 08h] Param 2 - Size of parameters, only 1/2/4 is valid.
732	; @uses eax, ecx, edx
733	;
734	align 16
735	BEGINPROC EMEmulateDec
736	%ifdef RT_ARCH_AMD64
737	%ifdef RT_OS_WINDOWS
738	mov rax, rdx ; eax = size of parameters
739	%else ; !RT_OS_WINDOWS
740	mov rax, rsi ; eax = size of parameters
741	mov rcx, rdi ; rcx = first parameter
742	%endif ; !RT_OS_WINDOWS
743	%else ; !RT_ARCH_AMD64
744	mov eax, [esp + 08h] ; eax = size of parameters
745	mov ecx, [esp + 04h] ; ecx = first parameter
746	%endif
747
748	; switch on size
749	%ifdef RT_ARCH_AMD64
750	cmp al, 8
751	je short .do_qword ; 8 bytes variant
752	%endif
753	cmp al, 4
754	je short .do_dword ; 4 bytes variant
755	cmp al, 2
756	je short .do_word ; 2 byte variant
757	cmp al, 1
758	je short .do_byte ; 1 bytes variant
759	int3
760
761	; workers
762	%ifdef RT_ARCH_AMD64
763	.do_qword:
764	dec qword [MY_PTR_REG] ; do 8 bytes DEC
765	jmp short .done
766	%endif
767
768	.do_dword:
769	dec dword [MY_PTR_REG] ; do 4 bytes DEC
770	jmp short .done
771
772	.do_word:
773	dec word [MY_PTR_REG] ; do 2 bytes DEC
774	jmp short .done
775
776	.do_byte:
777	dec byte [MY_PTR_REG] ; do 1 byte DEC
778	jmp short .done
779
780	; collect flags and return.
781	.done:
782	pushf
783	pop MY_RET_REG
784	retn
785	ENDPROC EMEmulateDec
786
787
788	;;
789	; Emulate ADD instruction, CDECL calling conv.
790	; VMMDECL(uint32_t) EMEmulateAdd(void *pvParam1, uint64_t u64Param2, size_t cb);
791	;
792	; @returns EFLAGS after the operation, only arithmetic flags are valid.
793	; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
794	; @param [esp + 08h] Param 2 - Second parameter.
795	; @param [esp + 10h] Param 3 - Size of parameters, only 1/2/4/8 (64 bits host only) is valid.
796	; @uses eax, ecx, edx
797	;
798	align 16
799	BEGINPROC EMEmulateAdd
800	%ifdef RT_ARCH_AMD64
801	%ifdef RT_OS_WINDOWS
802	mov rax, r8 ; eax = size of parameters
803	%else ; !RT_OS_WINDOWS
804	mov rax, rdx ; rax = size of parameters
805	mov rcx, rdi ; rcx = first parameter
806	mov rdx, rsi ; rdx = second parameter
807	%endif ; !RT_OS_WINDOWS
808	%else ; !RT_ARCH_AMD64
809	mov eax, [esp + 10h] ; eax = size of parameters
810	mov ecx, [esp + 04h] ; ecx = first parameter
811	mov edx, [esp + 08h] ; edx = second parameter
812	%endif
813
814	; switch on size
815	%ifdef CAN_DO_8_BYTE_OP
816	cmp al, 8
817	je short .do_qword ; 8 bytes variant
818	%endif
819	cmp al, 4
820	je short .do_dword ; 4 bytes variant
821	cmp al, 2
822	je short .do_word ; 2 byte variant
823	cmp al, 1
824	je short .do_byte ; 1 bytes variant
825	int3
826
827	; workers
828	%ifdef RT_ARCH_AMD64
829	.do_qword:
830	add [MY_PTR_REG], rdx ; do 8 bytes ADD
831	jmp short .done
832	%endif
833
834	.do_dword:
835	add [MY_PTR_REG], edx ; do 4 bytes ADD
836	jmp short .done
837
838	.do_word:
839	add [MY_PTR_REG], dx ; do 2 bytes ADD
840	jmp short .done
841
842	.do_byte:
843	add [MY_PTR_REG], dl ; do 1 byte ADD
844
845	; collect flags and return.
846	.done:
847	pushf
848	pop MY_RET_REG
849	retn
850
851	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
852	.do_qword:
853	db 0xea ; jmp far .sixtyfourbit_mode
854	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
855	BITS 64
856	.sixtyfourbit_mode:
857	and esp, 0ffffffffh
858	and MY_PTR_REG, 0ffffffffh
859	mov rdx, qword [rsp + 08h] ; rdx = second parameter
860	add [MY_PTR_REG64], rdx ; do 8 bytes ADD
861	jmp far [.fpret wrt rip]
862	.fpret: ; 16:32 Pointer to .done.
863	dd .done, NAME(SUPR0AbsKernelCS)
864	BITS 32
865	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
866	ENDPROC EMEmulateAdd
867
868
869	;;
870	; Emulate ADC instruction, CDECL calling conv.
871	; VMMDECL(uint32_t) EMEmulateAdcWithCarrySet(void *pvParam1, uint64_t u64Param2, size_t cb);
872	;
873	; @returns EFLAGS after the operation, only arithmetic flags are valid.
874	; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
875	; @param [esp + 08h] Param 2 - Second parameter.
876	; @param [esp + 10h] Param 3 - Size of parameters, only 1/2/4/8 (64 bits host only) is valid.
877	; @uses eax, ecx, edx
878	;
879	align 16
880	BEGINPROC EMEmulateAdcWithCarrySet
881	%ifdef RT_ARCH_AMD64
882	%ifdef RT_OS_WINDOWS
883	mov rax, r8 ; eax = size of parameters
884	%else ; !RT_OS_WINDOWS
885	mov rax, rdx ; rax = size of parameters
886	mov rcx, rdi ; rcx = first parameter
887	mov rdx, rsi ; rdx = second parameter
888	%endif ; !RT_OS_WINDOWS
889	%else ; !RT_ARCH_AMD64
890	mov eax, [esp + 10h] ; eax = size of parameters
891	mov ecx, [esp + 04h] ; ecx = first parameter
892	mov edx, [esp + 08h] ; edx = second parameter
893	%endif
894
895	; switch on size
896	%ifdef CAN_DO_8_BYTE_OP
897	cmp al, 8
898	je short .do_qword ; 8 bytes variant
899	%endif
900	cmp al, 4
901	je short .do_dword ; 4 bytes variant
902	cmp al, 2
903	je short .do_word ; 2 byte variant
904	cmp al, 1
905	je short .do_byte ; 1 bytes variant
906	int3
907
908	; workers
909	%ifdef RT_ARCH_AMD64
910	.do_qword:
911	stc ; set carry flag
912	adc [MY_PTR_REG], rdx ; do 8 bytes ADC
913	jmp short .done
914	%endif
915
916	.do_dword:
917	stc ; set carry flag
918	adc [MY_PTR_REG], edx ; do 4 bytes ADC
919	jmp short .done
920
921	.do_word:
922	stc ; set carry flag
923	adc [MY_PTR_REG], dx ; do 2 bytes ADC
924	jmp short .done
925
926	.do_byte:
927	stc ; set carry flag
928	adc [MY_PTR_REG], dl ; do 1 byte ADC
929
930	; collect flags and return.
931	.done:
932	pushf
933	pop MY_RET_REG
934	retn
935
936	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
937	.do_qword:
938	db 0xea ; jmp far .sixtyfourbit_mode
939	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
940	BITS 64
941	.sixtyfourbit_mode:
942	and esp, 0ffffffffh
943	and MY_PTR_REG, 0ffffffffh
944	mov rdx, qword [rsp + 08h] ; rdx = second parameter
945	stc ; set carry flag
946	adc [MY_PTR_REG64], rdx ; do 8 bytes ADC
947	jmp far [.fpret wrt rip]
948	.fpret: ; 16:32 Pointer to .done.
949	dd .done, NAME(SUPR0AbsKernelCS)
950	BITS 32
951	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
952	ENDPROC EMEmulateAdcWithCarrySet
953
954
955	;;
956	; Emulate SUB instruction, CDECL calling conv.
957	; VMMDECL(uint32_t) EMEmulateSub(void *pvParam1, uint64_t u64Param2, size_t cb);
958	;
959	; @returns EFLAGS after the operation, only arithmetic flags are valid.
960	; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
961	; @param [esp + 08h] Param 2 - Second parameter.
962	; @param [esp + 10h] Param 3 - Size of parameters, only 1/2/4/8 (64 bits host only) is valid.
963	; @uses eax, ecx, edx
964	;
965	align 16
966	BEGINPROC EMEmulateSub
967	%ifdef RT_ARCH_AMD64
968	%ifdef RT_OS_WINDOWS
969	mov rax, r8 ; eax = size of parameters
970	%else ; !RT_OS_WINDOWS
971	mov rax, rdx ; rax = size of parameters
972	mov rcx, rdi ; rcx = first parameter
973	mov rdx, rsi ; rdx = second parameter
974	%endif ; !RT_OS_WINDOWS
975	%else ; !RT_ARCH_AMD64
976	mov eax, [esp + 10h] ; eax = size of parameters
977	mov ecx, [esp + 04h] ; ecx = first parameter
978	mov edx, [esp + 08h] ; edx = second parameter
979	%endif
980
981	; switch on size
982	%ifdef CAN_DO_8_BYTE_OP
983	cmp al, 8
984	je short .do_qword ; 8 bytes variant
985	%endif
986	cmp al, 4
987	je short .do_dword ; 4 bytes variant
988	cmp al, 2
989	je short .do_word ; 2 byte variant
990	cmp al, 1
991	je short .do_byte ; 1 bytes variant
992	int3
993
994	; workers
995	%ifdef RT_ARCH_AMD64
996	.do_qword:
997	sub [MY_PTR_REG], rdx ; do 8 bytes SUB
998	jmp short .done
999	%endif
1000
1001	.do_dword:
1002	sub [MY_PTR_REG], edx ; do 4 bytes SUB
1003	jmp short .done
1004
1005	.do_word:
1006	sub [MY_PTR_REG], dx ; do 2 bytes SUB
1007	jmp short .done
1008
1009	.do_byte:
1010	sub [MY_PTR_REG], dl ; do 1 byte SUB
1011
1012	; collect flags and return.
1013	.done:
1014	pushf
1015	pop MY_RET_REG
1016	retn
1017
1018	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
1019	.do_qword:
1020	db 0xea ; jmp far .sixtyfourbit_mode
1021	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
1022	BITS 64
1023	.sixtyfourbit_mode:
1024	and esp, 0ffffffffh
1025	and MY_PTR_REG, 0ffffffffh
1026	mov rdx, qword [rsp + 08h] ; rdx = second parameter
1027	sub [MY_PTR_REG64], rdx ; do 8 bytes SUB
1028	jmp far [.fpret wrt rip]
1029	.fpret: ; 16:32 Pointer to .done.
1030	dd .done, NAME(SUPR0AbsKernelCS)
1031	BITS 32
1032	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
1033	ENDPROC EMEmulateSub
1034
1035
1036	;;
1037	; Emulate BTR instruction, CDECL calling conv.
1038	; VMMDECL(uint32_t) EMEmulateBtr(void *pvParam1, uint64_t u64Param2);
1039	;
1040	; @returns EFLAGS after the operation, only arithmetic flags are valid.
1041	; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
1042	; @param [esp + 08h] Param 2 - Second parameter.
1043	; @uses eax, ecx, edx
1044	;
1045	align 16
1046	BEGINPROC EMEmulateBtr
1047	%ifdef RT_ARCH_AMD64
1048	%ifndef RT_OS_WINDOWS
1049	mov rcx, rdi ; rcx = first parameter
1050	mov rdx, rsi ; rdx = second parameter
1051	%endif ; !RT_OS_WINDOWS
1052	%else ; !RT_ARCH_AMD64
1053	mov ecx, [esp + 04h] ; ecx = first parameter
1054	mov edx, [esp + 08h] ; edx = second parameter
1055	%endif
1056
1057	and edx, 7
1058	btr [MY_PTR_REG], edx
1059
1060	; collect flags and return.
1061	pushf
1062	pop MY_RET_REG
1063	retn
1064	ENDPROC EMEmulateBtr
1065
1066	;;
1067	; Emulate LOCK BTR instruction.
1068	; VMMDECL(int) EMEmulateLockBtr(void pvParam1, uint64_t u64Param2, RTGCUINTREG32 pf);
1069	;
1070	; @returns VINF_SUCCESS on success, VERR_ACCESS_DENIED on \#PF (GC only).
1071	; @param [esp + 04h] gcc:rdi msc:rcx Param 1 - First parameter - pointer to data item (the real stuff).
1072	; @param [esp + 08h] gcc:rsi msc:rdx Param 2 - Second parameter- the immediate / register value. (really an 8 byte value)
1073	; @param [esp + 10h] gcc:rdx msc:r8 Param 3 - Where to store the eflags on success.
1074	;
1075	align 16
1076	BEGINPROC EMEmulateLockBtr
1077	%ifdef RT_ARCH_AMD64
1078	%ifdef RT_OS_WINDOWS
1079	mov rax, r8 ; rax = third parameter
1080	%else ; !RT_OS_WINDOWS
1081	mov rcx, rdi ; rcx = first parameter
1082	mov rax, rdx ; rax = third parameter
1083	mov rdx, rsi ; rdx = second parameter
1084	%endif ; !RT_OS_WINDOWS
1085	%else ; !RT_ARCH_AMD64
1086	mov ecx, [esp + 04h] ; ecx = first parameter
1087	mov edx, [esp + 08h] ; edx = second parameter
1088	mov eax, [esp + 10h] ; eax = third parameter
1089	%endif
1090
1091	lock btr [MY_PTR_REG], edx
1092
1093	; collect flags and return.
1094	pushf
1095	pop xDX
1096	mov [xAX], edx
1097	mov eax, VINF_SUCCESS
1098	retn
1099
1100	%ifdef IN_RC
1101	; #PF resume point.
1102	GLOBALNAME EMEmulateLockBtr_Error
1103	mov eax, VERR_ACCESS_DENIED
1104	ret
1105	%endif
1106
1107	ENDPROC EMEmulateLockBtr
1108
1109
1110	;;
1111	; Emulate BTC instruction, CDECL calling conv.
1112	; VMMDECL(uint32_t) EMEmulateBtc(void *pvParam1, uint64_t u64Param2);
1113	;
1114	; @returns EFLAGS after the operation, only arithmetic flags are valid.
1115	; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
1116	; @param [esp + 08h] Param 2 - Second parameter.
1117	; @uses eax, ecx, edx
1118	;
1119	align 16
1120	BEGINPROC EMEmulateBtc
1121	%ifdef RT_ARCH_AMD64
1122	%ifndef RT_OS_WINDOWS
1123	mov rcx, rdi ; rcx = first parameter
1124	mov rdx, rsi ; rdx = second parameter
1125	%endif ; !RT_OS_WINDOWS
1126	%else ; !RT_ARCH_AMD64
1127	mov ecx, [esp + 04h] ; ecx = first parameter
1128	mov edx, [esp + 08h] ; edx = second parameter
1129	%endif
1130
1131	and edx, 7
1132	btc [MY_PTR_REG], edx
1133
1134	; collect flags and return.
1135	pushf
1136	pop MY_RET_REG
1137	retn
1138	ENDPROC EMEmulateBtc
1139
1140
1141	;;
1142	; Emulate BTS instruction, CDECL calling conv.
1143	; VMMDECL(uint32_t) EMEmulateBts(void *pvParam1, uint64_t u64Param2);
1144	;
1145	; @returns EFLAGS after the operation, only arithmetic flags are valid.
1146	; @param [esp + 04h] Param 1 - First parameter - pointer to data item.
1147	; @param [esp + 08h] Param 2 - Second parameter.
1148	; @uses eax, ecx, edx
1149	;
1150	align 16
1151	BEGINPROC EMEmulateBts
1152	%ifdef RT_ARCH_AMD64
1153	%ifndef RT_OS_WINDOWS
1154	mov rcx, rdi ; rcx = first parameter
1155	mov rdx, rsi ; rdx = second parameter
1156	%endif ; !RT_OS_WINDOWS
1157	%else ; !RT_ARCH_AMD64
1158	mov ecx, [esp + 04h] ; ecx = first parameter
1159	mov edx, [esp + 08h] ; edx = second parameter
1160	%endif
1161
1162	and edx, 7
1163	bts [MY_PTR_REG], edx
1164
1165	; collect flags and return.
1166	pushf
1167	pop MY_RET_REG
1168	retn
1169	ENDPROC EMEmulateBts
1170
1171
1172	;;
1173	; Emulate LOCK CMPXCHG instruction, CDECL calling conv.
1174	; VMMDECL(uint32_t) EMEmulateLockCmpXchg(void pvParam1, uint64_t pu64Param2, uint64_t u64Param3, size_t cbSize);
1175	;
1176	; @returns EFLAGS after the operation, only arithmetic flags are valid.
1177	; @param [esp + 04h] gcc:rdi msc:rcx Param 1 - First parameter - pointer to first parameter
1178	; @param [esp + 08h] gcc:rsi msc:rdx Param 2 - pointer to second parameter (eax)
1179	; @param [esp + 0ch] gcc:rdx msc:r8 Param 3 - third parameter
1180	; @param [esp + 14h] gcc:rcx msc:r9 Param 4 - Size of parameters, only 1/2/4/8 is valid
1181	; @uses eax, ecx, edx
1182	;
1183	align 16
1184	BEGINPROC EMEmulateLockCmpXchg
1185	push xBX
1186	%ifdef RT_ARCH_AMD64
1187	%ifdef RT_OS_WINDOWS
1188	; rcx contains the first parameter already
1189	mov rbx, rdx ; rdx = 2nd parameter
1190	mov rdx, r8 ; r8 = 3rd parameter
1191	mov rax, r9 ; r9 = size of parameters
1192	%else
1193	mov rax, rcx ; rcx = size of parameters (4th)
1194	mov rcx, rdi ; rdi = 1st parameter
1195	mov rbx, rsi ; rsi = second parameter
1196	;rdx contains the 3rd parameter already
1197	%endif ; !RT_OS_WINDOWS
1198	%else ; !RT_ARCH_AMD64
1199	mov ecx, [esp + 04h + 4] ; ecx = first parameter
1200	mov ebx, [esp + 08h + 4] ; ebx = 2nd parameter (eax)
1201	mov edx, [esp + 0ch + 4] ; edx = third parameter
1202	mov eax, [esp + 14h + 4] ; eax = size of parameters
1203	%endif
1204
1205	%ifdef CAN_DO_8_BYTE_OP
1206	cmp al, 8
1207	je short .do_qword ; 8 bytes variant
1208	%endif
1209	cmp al, 4
1210	je short .do_dword ; 4 bytes variant
1211	cmp al, 2
1212	je short .do_word ; 2 byte variant
1213	cmp al, 1
1214	je short .do_byte ; 1 bytes variant
1215	int3
1216
1217	%ifdef RT_ARCH_AMD64
1218	.do_qword:
1219	; load 2nd parameter's value
1220	mov rax, qword [rbx]
1221
1222	lock cmpxchg qword [rcx], rdx ; do 8 bytes CMPXCHG
1223	mov qword [rbx], rax
1224	jmp short .done
1225	%endif
1226
1227	.do_dword:
1228	; load 2nd parameter's value
1229	mov eax, dword [xBX]
1230
1231	lock cmpxchg dword [xCX], edx ; do 4 bytes CMPXCHG
1232	mov dword [xBX], eax
1233	jmp short .done
1234
1235	.do_word:
1236	; load 2nd parameter's value
1237	mov eax, dword [xBX]
1238
1239	lock cmpxchg word [xCX], dx ; do 2 bytes CMPXCHG
1240	mov word [xBX], ax
1241	jmp short .done
1242
1243	.do_byte:
1244	; load 2nd parameter's value
1245	mov eax, dword [xBX]
1246
1247	lock cmpxchg byte [xCX], dl ; do 1 byte CMPXCHG
1248	mov byte [xBX], al
1249
1250	.done:
1251	; collect flags and return.
1252	pushf
1253	pop MY_RET_REG
1254
1255	pop xBX
1256	retn
1257
1258	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
1259	.do_qword:
1260	db 0xea ; jmp far .sixtyfourbit_mode
1261	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
1262	BITS 64
1263	.sixtyfourbit_mode:
1264	and ebx, 0ffffffffh
1265	and esp, 0ffffffffh
1266	and ecx, 0ffffffffh
1267	mov rax, qword [rbx] ; load 2nd parameter's value
1268	mov rdx, qword [rsp + 0ch + 4] ; rdx = third parameter
1269
1270	lock cmpxchg qword [rcx], rdx ; do 8 byte CMPXCHG
1271	mov qword [rbx], rax
1272	jmp far [.fpret wrt rip]
1273	.fpret: ; 16:32 Pointer to .done.
1274	dd .done, NAME(SUPR0AbsKernelCS)
1275	BITS 32
1276	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
1277	ENDPROC EMEmulateLockCmpXchg
1278
1279
1280	;;
1281	; Emulate CMPXCHG instruction, CDECL calling conv.
1282	; VMMDECL(uint32_t) EMEmulateCmpXchg(void pvParam1, uint64_t pu32Param2, uint64_t u32Param3, size_t cbSize);
1283	;
1284	; @returns EFLAGS after the operation, only arithmetic flags are valid.
1285	; @param [esp + 04h] gcc:rdi msc:rcx Param 1 - First parameter - pointer to first parameter
1286	; @param [esp + 08h] gcc:rsi msc:rdx Param 2 - pointer to second parameter (eax)
1287	; @param [esp + 0ch] gcc:rdx msc:r8 Param 3 - third parameter
1288	; @param [esp + 14h] gcc:rcx msc:r9 Param 4 - Size of parameters, only 1/2/4 is valid.
1289	; @uses eax, ecx, edx
1290	;
1291	align 16
1292	BEGINPROC EMEmulateCmpXchg
1293	push xBX
1294	%ifdef RT_ARCH_AMD64
1295	%ifdef RT_OS_WINDOWS
1296	; rcx contains the first parameter already
1297	mov rbx, rdx ; rdx = 2nd parameter
1298	mov rdx, r8 ; r8 = 3rd parameter
1299	mov rax, r9 ; r9 = size of parameters
1300	%else
1301	mov rax, rcx ; rcx = size of parameters (4th)
1302	mov rcx, rdi ; rdi = 1st parameter
1303	mov rbx, rsi ; rsi = second parameter
1304	;rdx contains the 3rd parameter already
1305	%endif ; !RT_OS_WINDOWS
1306	%else ; !RT_ARCH_AMD64
1307	mov ecx, [esp + 04h + 4] ; ecx = first parameter
1308	mov ebx, [esp + 08h + 4] ; ebx = 2nd parameter (eax)
1309	mov edx, [esp + 0ch + 4] ; edx = third parameter
1310	mov eax, [esp + 14h + 4] ; eax = size of parameters
1311	%endif
1312
1313	%ifdef CAN_DO_8_BYTE_OP
1314	cmp al, 8
1315	je short .do_qword ; 8 bytes variant
1316	%endif
1317	cmp al, 4
1318	je short .do_dword ; 4 bytes variant
1319	cmp al, 2
1320	je short .do_word ; 2 byte variant
1321	cmp al, 1
1322	je short .do_byte ; 1 bytes variant
1323	int3
1324
1325	%ifdef RT_ARCH_AMD64
1326	.do_qword:
1327	; load 2nd parameter's value
1328	mov rax, qword [rbx]
1329
1330	cmpxchg qword [rcx], rdx ; do 8 bytes CMPXCHG
1331	mov qword [rbx], rax
1332	jmp short .done
1333	%endif
1334
1335	.do_dword:
1336	; load 2nd parameter's value
1337	mov eax, dword [xBX]
1338
1339	cmpxchg dword [xCX], edx ; do 4 bytes CMPXCHG
1340	mov dword [xBX], eax
1341	jmp short .done
1342
1343	.do_word:
1344	; load 2nd parameter's value
1345	mov eax, dword [xBX]
1346
1347	cmpxchg word [xCX], dx ; do 2 bytes CMPXCHG
1348	mov word [xBX], ax
1349	jmp short .done
1350
1351	.do_byte:
1352	; load 2nd parameter's value
1353	mov eax, dword [xBX]
1354
1355	cmpxchg byte [xCX], dl ; do 1 byte CMPXCHG
1356	mov byte [xBX], al
1357
1358	.done:
1359	; collect flags and return.
1360	pushf
1361	pop MY_RET_REG
1362
1363	pop xBX
1364	retn
1365
1366	%ifdef VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
1367	.do_qword:
1368	db 0xea ; jmp far .sixtyfourbit_mode
1369	dd .sixtyfourbit_mode, NAME(SUPR0Abs64bitKernelCS)
1370	BITS 64
1371	.sixtyfourbit_mode:
1372	and ebx, 0ffffffffh
1373	and esp, 0ffffffffh
1374	and ecx, 0ffffffffh
1375	mov rax, qword [rbx] ; load 2nd parameter's value
1376	mov rdx, qword [rsp + 0ch + 4] ; rdx = third parameter
1377
1378	cmpxchg qword [rcx], rdx ; do 8 byte CMPXCHG
1379	mov qword [rbx], rax
1380	jmp far [.fpret wrt rip]
1381	.fpret: ; 16:32 Pointer to .done.
1382	dd .done, NAME(SUPR0AbsKernelCS)
1383	BITS 32
1384	%endif ; VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0
1385	ENDPROC EMEmulateCmpXchg
1386
1387
1388	;;
1389	; Emulate LOCK CMPXCHG8B instruction, CDECL calling conv.
1390	; VMMDECL(uint32_t) EMEmulateLockCmpXchg8b(void pu32Param1, uint32_t pEAX, uint32_t *pEDX, uint32_t uEBX, uint32_t uECX);
1391	;
1392	; @returns EFLAGS after the operation, only the ZF flag is valid.
1393	; @param [esp + 04h] gcc:rdi msc:rcx Param 1 - First parameter - pointer to first parameter
1394	; @param [esp + 08h] gcc:rsi msc:rdx Param 2 - Address of the eax register
1395	; @param [esp + 0ch] gcc:rdx msc:r8 Param 3 - Address of the edx register
1396	; @param [esp + 10h] gcc:rcx msc:r9 Param 4 - EBX
1397	; @param [esp + 14h] gcc:r8 msc:[rsp + 8] Param 5 - ECX
1398	; @uses eax, ecx, edx
1399	;
1400	align 16
1401	BEGINPROC EMEmulateLockCmpXchg8b
1402	push xBP
1403	push xBX
1404	%ifdef RT_ARCH_AMD64
1405	%ifdef RT_OS_WINDOWS
1406	mov rbp, rcx
1407	mov r10, rdx
1408	mov eax, dword [rdx]
1409	mov edx, dword [r8]
1410	mov rbx, r9
1411	mov ecx, [rsp + 28h + 16]
1412	%else
1413	mov rbp, rdi
1414	mov r10, rdx
1415	mov eax, dword [rsi]
1416	mov edx, dword [rdx]
1417	mov rbx, rcx
1418	mov rcx, r8
1419	%endif
1420	%else
1421	mov ebp, [esp + 04h + 8] ; ebp = first parameter
1422	mov eax, [esp + 08h + 8] ; &EAX
1423	mov eax, dword [eax]
1424	mov edx, [esp + 0ch + 8] ; &EDX
1425	mov edx, dword [edx]
1426	mov ebx, [esp + 10h + 8] ; EBX
1427	mov ecx, [esp + 14h + 8] ; ECX
1428	%endif
1429
1430	%ifdef RT_OS_OS2
1431	lock cmpxchg8b [xBP] ; do CMPXCHG8B
1432	%else
1433	lock cmpxchg8b qword [xBP] ; do CMPXCHG8B
1434	%endif
1435
1436	%ifdef RT_ARCH_AMD64
1437	%ifdef RT_OS_WINDOWS
1438	mov dword [r10], eax
1439	mov dword [r8], edx
1440	%else
1441	mov dword [rsi], eax
1442	mov dword [r10], edx
1443	%endif
1444	%else
1445	mov ebx, dword [esp + 08h + 8]
1446	mov dword [ebx], eax
1447	mov ebx, dword [esp + 0ch + 8]
1448	mov dword [ebx], edx
1449	%endif
1450	; collect flags and return.
1451	pushf
1452	pop MY_RET_REG
1453
1454	pop xBX
1455	pop xBP
1456	retn
1457	ENDPROC EMEmulateLockCmpXchg8b
1458
1459	;;
1460	; Emulate CMPXCHG8B instruction, CDECL calling conv.
1461	; VMMDECL(uint32_t) EMEmulateCmpXchg8b(void pu32Param1, uint32_t pEAX, uint32_t *pEDX, uint32_t uEBX, uint32_t uECX);
1462	;
1463	; @returns EFLAGS after the operation, only arithmetic flags are valid.
1464	; @param [esp + 04h] gcc:rdi msc:rcx Param 1 - First parameter - pointer to first parameter
1465	; @param [esp + 08h] gcc:rsi msc:rdx Param 2 - Address of the eax register
1466	; @param [esp + 0ch] gcc:rdx msc:r8 Param 3 - Address of the edx register
1467	; @param [esp + 10h] gcc:rcx msc:r9 Param 4 - EBX
1468	; @param [esp + 14h] gcc:r8 msc:[rsp + 8] Param 5 - ECX
1469	; @uses eax, ecx, edx
1470	;
1471	align 16
1472	BEGINPROC EMEmulateCmpXchg8b
1473	push xBP
1474	push xBX
1475	%ifdef RT_ARCH_AMD64
1476	%ifdef RT_OS_WINDOWS
1477	mov rbp, rcx
1478	mov r10, rdx
1479	mov eax, dword [rdx]
1480	mov edx, dword [r8]
1481	mov rbx, r9
1482	mov ecx, [rsp + 28h + 16]
1483	%else
1484	mov rbp, rdi
1485	mov r10, rdx
1486	mov eax, dword [rsi]
1487	mov edx, dword [rdx]
1488	mov rbx, rcx
1489	mov rcx, r8
1490	%endif
1491	%else
1492	mov ebp, [esp + 04h + 8] ; ebp = first parameter
1493	mov eax, [esp + 08h + 8] ; &EAX
1494	mov eax, dword [eax]
1495	mov edx, [esp + 0ch + 8] ; &EDX
1496	mov edx, dword [edx]
1497	mov ebx, [esp + 10h + 8] ; EBX
1498	mov ecx, [esp + 14h + 8] ; ECX
1499	%endif
1500
1501	%ifdef RT_OS_OS2
1502	cmpxchg8b [xBP] ; do CMPXCHG8B
1503	%else
1504	cmpxchg8b qword [xBP] ; do CMPXCHG8B
1505	%endif
1506
1507	%ifdef RT_ARCH_AMD64
1508	%ifdef RT_OS_WINDOWS
1509	mov dword [r10], eax
1510	mov dword [r8], edx
1511	%else
1512	mov dword [rsi], eax
1513	mov dword [r10], edx
1514	%endif
1515	%else
1516	mov ebx, dword [esp + 08h + 8]
1517	mov dword [ebx], eax
1518	mov ebx, dword [esp + 0ch + 8]
1519	mov dword [ebx], edx
1520	%endif
1521
1522	; collect flags and return.
1523	pushf
1524	pop MY_RET_REG
1525
1526	pop xBX
1527	pop xBP
1528	retn
1529	ENDPROC EMEmulateCmpXchg8b
1530

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

source: vbox/trunk/src/VBox/VMM/VMMAll/EMAllA.asm@ 29450

Download in other formats: