VBoxREMWrapper.cpp@ 51941

Last change on this file since 51941 was 46493, checked in by vboxsync, 12 years ago
STAMR3Deregister* optimizations. Relevant for both startup and shutdown times.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 127.2 KB

Line
1	/* $Id: VBoxREMWrapper.cpp 46493 2013-06-11 13:34:40Z vboxsync $ */
2	/** @file
3	*
4	* VBoxREM Win64 DLL Wrapper.
5	*/
6	/*
7	* Copyright (C) 2006-2013 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	/** @page pg_vboxrem_amd64 VBoxREM Hacks on AMD64
20	*
21	* There are problems with building BoxREM both on WIN64 and 64-bit linux.
22	*
23	* On linux binutils refuses to link shared objects without -fPIC compiled code
24	* (bitches about some fixup types). But when trying to build with -fPIC dyngen
25	* doesn't like the code anymore. Sweet. The current solution is to build the
26	* VBoxREM code as a relocatable module and use our ELF loader to load it.
27	*
28	* On WIN64 we're not aware of any GCC port which can emit code using the MSC
29	* calling convention. So, we're in for some real fun here. The choice is between
30	* porting GCC to AMD64 WIN64 and coming up with some kind of wrapper around
31	* either the win32 build or the 64-bit linux build.
32	*
33	* -# Porting GCC will be a lot of work. For one thing the calling convention differs
34	* and messing with such stuff can easily create ugly bugs. We would also have to
35	* do some binutils changes, but I think those are rather small compared to GCC.
36	* (That said, the MSC calling convention is far simpler than the linux one, it
37	* reminds me of _Optlink which we have working already.)
38	* -# Wrapping win32 code will work, but addresses outside the first 4GB are
39	* inaccessible and we will have to create 32-64 thunks for all imported functions.
40	* (To switch between 32-bit and 64-bit is load the right CS using far jmps (32->64)
41	* or far returns (both).)
42	* -# Wrapping 64-bit linux code might be the easier solution. The requirements here
43	* are:
44	* - Remove all CRT references we possibly, either by using intrinsics or using
45	* IPRT. Part of IPRT will be linked into VBoxREM2.rel, this will be yet another
46	* IPRT mode which I've dubbed 'no-crt'. The no-crt mode provide basic non-system
47	* dependent stuff.
48	* - Compile and link it into a relocatable object (include the gcc intrinsics
49	* in libgcc). Call this VBoxREM2.rel.
50	* - Write a wrapper dll, VBoxREM.dll, for which during REMR3Init() will load
51	* VBoxREM2.rel (using IPRT) and generate calling convention wrappers
52	* for all IPRT functions and VBoxVMM functions that it uses. All exports
53	* will be wrapped vice versa.
54	* - For building on windows hosts, we will use a mingw32 hosted cross compiler.
55	* and add a 'no-crt' mode to IPRT where it provides the necessary CRT headers
56	* and function implementations.
57	*
58	* The 3rd solution will be tried out first since it requires the least effort and
59	* will let us make use of the full 64-bit register set.
60	*
61	*
62	*
63	* @section sec_vboxrem_amd64_compare Comparing the GCC and MSC calling conventions
64	*
65	* GCC expects the following (cut & past from page 20 in the ABI draft 0.96):
66	*
67	* @verbatim
68	%rax temporary register; with variable arguments passes information about the
69	number of SSE registers used; 1st return register.
70	[Not preserved]
71	%rbx callee-saved register; optionally used as base pointer.
72	[Preserved]
73	%rcx used to pass 4th integer argument to functions.
74	[Not preserved]
75	%rdx used to pass 3rd argument to functions; 2nd return register
76	[Not preserved]
77	%rsp stack pointer
78	[Preserved]
79	%rbp callee-saved register; optionally used as frame pointer
80	[Preserved]
81	%rsi used to pass 2nd argument to functions
82	[Not preserved]
83	%rdi used to pass 1st argument to functions
84	[Not preserved]
85	%r8 used to pass 5th argument to functions
86	[Not preserved]
87	%r9 used to pass 6th argument to functions
88	[Not preserved]
89	%r10 temporary register, used for passing a function's static chain
90	pointer [Not preserved]
91	%r11 temporary register
92	[Not preserved]
93	%r12-r15 callee-saved registers
94	[Preserved]
95	%xmm0-%xmm1 used to pass and return floating point arguments
96	[Not preserved]
97	%xmm2-%xmm7 used to pass floating point arguments
98	[Not preserved]
99	%xmm8-%xmm15 temporary registers
100	[Not preserved]
101	%mmx0-%mmx7 temporary registers
102	[Not preserved]
103	%st0 temporary register; used to return long double arguments
104	[Not preserved]
105	%st1 temporary registers; used to return long double arguments
106	[Not preserved]
107	%st2-%st7 temporary registers
108	[Not preserved]
109	%fs Reserved for system use (as thread specific data register)
110	[Not preserved]
111	@endverbatim
112	*
113	* Direction flag is preserved as cleared.
114	* The stack must be aligned on a 16-byte boundary before the 'call/jmp' instruction.
115	*
116	*
117	*
118	* MSC expects the following:
119	* @verbatim
120	rax return value, not preserved.
121	rbx preserved.
122	rcx 1st argument, integer, not preserved.
123	rdx 2nd argument, integer, not preserved.
124	rbp preserved.
125	rsp preserved.
126	rsi preserved.
127	rdi preserved.
128	r8 3rd argument, integer, not preserved.
129	r9 4th argument, integer, not preserved.
130	r10 scratch register, not preserved.
131	r11 scratch register, not preserved.
132	r12-r15 preserved.
133	xmm0 1st argument, fp, return value, not preserved.
134	xmm1 2st argument, fp, not preserved.
135	xmm2 3st argument, fp, not preserved.
136	xmm3 4st argument, fp, not preserved.
137	xmm4-xmm5 scratch, not preserved.
138	xmm6-xmm15 preserved.
139	@endverbatim
140	*
141	* Dunno what the direction flag is...
142	* The stack must be aligned on a 16-byte boundary before the 'call/jmp' instruction.
143	*
144	*
145	* Thus, When GCC code is calling MSC code we don't really have to preserve
146	* anything. But but MSC code is calling GCC code, we'll have to save esi and edi.
147	*
148	*/
149
150
151	/*******************************************************************************
152	* Defined Constants And Macros *
153	*******************************************************************************/
154	/** @def USE_REM_STUBS
155	* Define USE_REM_STUBS to stub the entire REM stuff. This is useful during
156	* early porting (before we start running stuff).
157	*/
158	#if defined(DOXYGEN_RUNNING)
159	# define USE_REM_STUBS
160	#endif
161
162	/** @def USE_REM_CALLING_CONVENTION_GLUE
163	* Define USE_REM_CALLING_CONVENTION_GLUE for platforms where it's necessary to
164	* use calling convention wrappers.
165	*/
166	#if (defined(RT_ARCH_AMD64) && defined(RT_OS_WINDOWS)) \|\| defined(DOXYGEN_RUNNING)
167	# define USE_REM_CALLING_CONVENTION_GLUE
168	#endif
169
170	/** @def USE_REM_IMPORT_JUMP_GLUE
171	* Define USE_REM_IMPORT_JUMP_GLUE for platforms where we need to
172	* emit some jump glue to deal with big addresses.
173	*/
174	#if (defined(RT_ARCH_AMD64) && !defined(USE_REM_CALLING_CONVENTION_GLUE) && !defined(RT_OS_DARWIN)) \|\| defined(DOXYGEN_RUNNING)
175	# define USE_REM_IMPORT_JUMP_GLUE
176	#endif
177
178	/** @def VBOX_USE_BITNESS_SELECTOR
179	* Define VBOX_USE_BITNESS_SELECTOR to build this module as a bitness selector
180	* between VBoxREM32 and VBoxREM64.
181	*/
182	#if defined(DOXYGEN_RUNNING)
183	# define VBOX_USE_BITNESS_SELECTOR
184	#endif
185
186	/** @def VBOX_WITHOUT_REM_LDR_CYCLE
187	* Define VBOX_WITHOUT_REM_LDR_CYCLE dynamically resolve any dependencies on
188	* VBoxVMM and thus avoid the cyclic dependency between VBoxREM and VBoxVMM.
189	*/
190	#if defined(DOXYGEN_RUNNING)
191	# define VBOX_WITHOUT_REM_LDR_CYCLE
192	#endif
193
194
195	/*******************************************************************************
196	* Header Files *
197	*******************************************************************************/
198	#define LOG_GROUP LOG_GROUP_REM
199	#include <VBox/vmm/rem.h>
200	#include <VBox/vmm/vmm.h>
201	#include <VBox/vmm/dbgf.h>
202	#include <VBox/dbg.h>
203	#include <VBox/vmm/csam.h>
204	#include <VBox/vmm/mm.h>
205	#include <VBox/vmm/em.h>
206	#include <VBox/vmm/ssm.h>
207	#include <VBox/vmm/hm.h>
208	#include <VBox/vmm/patm.h>
209	#include <VBox/vmm/pdm.h>
210	#include <VBox/vmm/pdmcritsect.h>
211	#include <VBox/vmm/pgm.h>
212	#include <VBox/vmm/iom.h>
213	#include <VBox/vmm/vm.h>
214	#include <VBox/err.h>
215	#include <VBox/log.h>
216	#include <VBox/dis.h>
217
218	#include <iprt/alloc.h>
219	#include <iprt/assert.h>
220	#include <iprt/ldr.h>
221	#include <iprt/lockvalidator.h>
222	#include <iprt/param.h>
223	#include <iprt/path.h>
224	#include <iprt/string.h>
225	#include <iprt/stream.h>
226
227
228	/*******************************************************************************
229	* Structures and Typedefs *
230	*******************************************************************************/
231	/**
232	* Parameter descriptor.
233	*/
234	typedef struct REMPARMDESC
235	{
236	/** Parameter flags (REMPARMDESC_FLAGS_). /
237	uint8_t fFlags;
238	/** The parameter size if REMPARMDESC_FLAGS_SIZE is set. */
239	uint8_t cb;
240	/** Pointer to additional data.
241	* For REMPARMDESC_FLAGS_PFN this is a PREMFNDESC. */
242	void *pvExtra;
243
244	} REMPARMDESC, *PREMPARMDESC;
245	/** Pointer to a constant parameter descriptor. */
246	typedef const REMPARMDESC *PCREMPARMDESC;
247
248	/** @name Parameter descriptor flags.
249	* @{ */
250	/** The parameter type is a kind of integer which could fit in a register. This includes pointers. */
251	#define REMPARMDESC_FLAGS_INT 0
252	/** The parameter is a GC pointer. */
253	#define REMPARMDESC_FLAGS_GCPTR 1
254	/** The parameter is a GC physical address. */
255	#define REMPARMDESC_FLAGS_GCPHYS 2
256	/** The parameter is a HC physical address. */
257	#define REMPARMDESC_FLAGS_HCPHYS 3
258	/** The parameter type is a kind of floating point. */
259	#define REMPARMDESC_FLAGS_FLOAT 4
260	/** The parameter value is a struct. This type takes a size. */
261	#define REMPARMDESC_FLAGS_STRUCT 5
262	/** The parameter is an elipsis. */
263	#define REMPARMDESC_FLAGS_ELLIPSIS 6
264	/** The parameter is a va_list. */
265	#define REMPARMDESC_FLAGS_VALIST 7
266	/** The parameter is a function pointer. pvExtra is a PREMFNDESC. */
267	#define REMPARMDESC_FLAGS_PFN 8
268	/** The parameter type mask. */
269	#define REMPARMDESC_FLAGS_TYPE_MASK 15
270	/** The parameter size field is valid. */
271	#define REMPARMDESC_FLAGS_SIZE RT_BIT(7)
272	/** @} */
273
274	/**
275	* Function descriptor.
276	*/
277	typedef struct REMFNDESC
278	{
279	/** The function name. */
280	const char *pszName;
281	/** Exports: Pointer to the function pointer.
282	* Imports: Pointer to the function. */
283	void *pv;
284	/** Array of parameter descriptors. */
285	PCREMPARMDESC paParams;
286	/** The number of parameter descriptors pointed to by paParams. */
287	uint8_t cParams;
288	/** Function flags (REMFNDESC_FLAGS_). /
289	uint8_t fFlags;
290	/** The size of the return value. */
291	uint8_t cbReturn;
292	/** Pointer to the wrapper code for imports. */
293	void *pvWrapper;
294	} REMFNDESC, *PREMFNDESC;
295	/** Pointer to a constant function descriptor. */
296	typedef const REMFNDESC *PCREMFNDESC;
297
298	/** @name Function descriptor flags.
299	* @{ */
300	/** The return type is void. */
301	#define REMFNDESC_FLAGS_RET_VOID 0
302	/** The return type is a kind of integer passed in rax/eax. This includes pointers. */
303	#define REMFNDESC_FLAGS_RET_INT 1
304	/** The return type is a kind of floating point. */
305	#define REMFNDESC_FLAGS_RET_FLOAT 2
306	/** The return value is a struct. This type take a size. */
307	#define REMFNDESC_FLAGS_RET_STRUCT 3
308	/** The return type mask. */
309	#define REMFNDESC_FLAGS_RET_TYPE_MASK 7
310	/** The argument list contains one or more va_list arguments (i.e. problems). */
311	#define REMFNDESC_FLAGS_VALIST RT_BIT(6)
312	/** The function has an ellipsis (i.e. a problem). */
313	#define REMFNDESC_FLAGS_ELLIPSIS RT_BIT(7)
314	/** @} */
315
316	/**
317	* Chunk of read-write-executable memory.
318	*/
319	typedef struct REMEXECMEM
320	{
321	/** The number of bytes left. */
322	struct REMEXECMEM *pNext;
323	/** The size of this chunk. */
324	uint32_t cb;
325	/** The offset of the next code block. */
326	uint32_t off;
327	#if ARCH_BITS == 32
328	uint32_t padding;
329	#endif
330	} REMEXECMEM, *PREMEXECMEM;
331
332
333	/*******************************************************************************
334	* Global Variables *
335	*******************************************************************************/
336	#ifndef USE_REM_STUBS
337	/** Loader handle of the REM object/DLL. */
338	static RTLDRMOD g_ModREM2 = NIL_RTLDRMOD;
339	/** Pointer to the memory containing the loaded REM2 object/DLL. */
340	static void *g_pvREM2 = NULL;
341	/** The size of the memory g_pvREM2 is pointing to. */
342	static size_t g_cbREM2 = 0;
343	# ifdef VBOX_WITHOUT_REM_LDR_CYCLE
344	/** Loader handle of the VBoxVMM DLL. */
345	static RTLDRMOD g_ModVMM = NIL_RTLDRMOD;
346	# endif
347
348	/** Linux object export addresses.
349	* These are references from the assembly wrapper code.
350	* @{ */
351	static DECLCALLBACKPTR(int, pfnREMR3Init)(PVM);
352	static DECLCALLBACKPTR(int, pfnREMR3InitFinalize)(PVM);
353	static DECLCALLBACKPTR(int, pfnREMR3Term)(PVM);
354	static DECLCALLBACKPTR(void, pfnREMR3Reset)(PVM);
355	static DECLCALLBACKPTR(int, pfnREMR3Step)(PVM, PVMCPU);
356	static DECLCALLBACKPTR(int, pfnREMR3BreakpointSet)(PVM, RTGCUINTPTR);
357	static DECLCALLBACKPTR(int, pfnREMR3BreakpointClear)(PVM, RTGCUINTPTR);
358	static DECLCALLBACKPTR(int, pfnREMR3EmulateInstruction)(PVM, PVMCPU);
359	static DECLCALLBACKPTR(int, pfnREMR3Run)(PVM, PVMCPU);
360	static DECLCALLBACKPTR(int, pfnREMR3State)(PVM, PVMCPU);
361	static DECLCALLBACKPTR(int, pfnREMR3StateBack)(PVM, PVMCPU);
362	static DECLCALLBACKPTR(void, pfnREMR3StateUpdate)(PVM, PVMCPU);
363	static DECLCALLBACKPTR(void, pfnREMR3A20Set)(PVM, PVMCPU, bool);
364	static DECLCALLBACKPTR(void, pfnREMR3ReplayHandlerNotifications)(PVM pVM);
365	static DECLCALLBACKPTR(void, pfnREMR3NotifyPhysRamRegister)(PVM, RTGCPHYS, RTGCPHYS, unsigned);
366	static DECLCALLBACKPTR(void, pfnREMR3NotifyPhysRamDeregister)(PVM, RTGCPHYS, RTUINT);
367	static DECLCALLBACKPTR(void, pfnREMR3NotifyPhysRomRegister)(PVM, RTGCPHYS, RTUINT, void *, bool);
368	static DECLCALLBACKPTR(void, pfnREMR3NotifyHandlerPhysicalModify)(PVM, PGMPHYSHANDLERTYPE, RTGCPHYS, RTGCPHYS, RTGCPHYS, bool, bool);
369	static DECLCALLBACKPTR(void, pfnREMR3NotifyHandlerPhysicalRegister)(PVM, PGMPHYSHANDLERTYPE, RTGCPHYS, RTGCPHYS, bool);
370	static DECLCALLBACKPTR(void, pfnREMR3NotifyHandlerPhysicalDeregister)(PVM, PGMPHYSHANDLERTYPE, RTGCPHYS, RTGCPHYS, bool, bool);
371	static DECLCALLBACKPTR(void, pfnREMR3NotifyInterruptSet)(PVM, PVMCPU);
372	static DECLCALLBACKPTR(void, pfnREMR3NotifyInterruptClear)(PVM, PVMCPU);
373	static DECLCALLBACKPTR(void, pfnREMR3NotifyTimerPending)(PVM, PVMCPU);
374	static DECLCALLBACKPTR(void, pfnREMR3NotifyDmaPending)(PVM);
375	static DECLCALLBACKPTR(void, pfnREMR3NotifyQueuePending)(PVM);
376	static DECLCALLBACKPTR(void, pfnREMR3NotifyFF)(PVM);
377	static DECLCALLBACKPTR(int, pfnREMR3NotifyCodePageChanged)(PVM, PVMCPU, RTGCPTR);
378	static DECLCALLBACKPTR(void, pfnREMR3NotifyPendingInterrupt)(PVM, PVMCPU, uint8_t);
379	static DECLCALLBACKPTR(uint32_t, pfnREMR3QueryPendingInterrupt)(PVM, PVMCPU);
380	static DECLCALLBACKPTR(int, pfnREMR3DisasEnableStepping)(PVM, bool);
381	static DECLCALLBACKPTR(bool, pfnREMR3IsPageAccessHandled)(PVM, RTGCPHYS);
382	/** @} */
383
384	/** Export and import parameter descriptors.
385	* @{
386	*/
387	/* Common args. */
388	static const REMPARMDESC g_aArgsSIZE_T[] =
389	{
390	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
391	};
392	static const REMPARMDESC g_aArgsPTR[] =
393	{
394	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL }
395	};
396	static const REMPARMDESC g_aArgsSIZE_TTag[] =
397	{
398	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
399	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
400	};
401	static const REMPARMDESC g_aArgsPTRTag[] =
402	{
403	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
404	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
405	};
406	static const REMPARMDESC g_aArgsPTR_SIZE_T[] =
407	{
408	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
409	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
410	};
411	static const REMPARMDESC g_aArgsSIZE_TTagLoc[] =
412	{
413	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
414	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
415	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
416	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned int), NULL },
417	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
418	};
419	static const REMPARMDESC g_aArgsPTRLoc[] =
420	{
421	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
422	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
423	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned int), NULL },
424	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
425	};
426	static const REMPARMDESC g_aArgsVM[] =
427	{
428	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL }
429	};
430	static const REMPARMDESC g_aArgsVMCPU[] =
431	{
432	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL }
433	};
434
435	static const REMPARMDESC g_aArgsVMandVMCPU[] =
436	{
437	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
438	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL }
439	};
440
441	/* REM args */
442	static const REMPARMDESC g_aArgsBreakpoint[] =
443	{
444	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
445	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINTPTR), NULL }
446	};
447	static const REMPARMDESC g_aArgsA20Set[] =
448	{
449	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
450	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
451	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
452	};
453	static const REMPARMDESC g_aArgsNotifyPhysRamRegister[] =
454	{
455	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
456	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
457	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
458	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
459	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
460	};
461	static const REMPARMDESC g_aArgsNotifyPhysRamChunkRegister[] =
462	{
463	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
464	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
465	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
466	{ REMPARMDESC_FLAGS_INT, sizeof(RTHCUINTPTR), NULL },
467	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
468	};
469	static const REMPARMDESC g_aArgsNotifyPhysRamDeregister[] =
470	{
471	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
472	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
473	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL }
474	};
475	static const REMPARMDESC g_aArgsNotifyPhysRomRegister[] =
476	{
477	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
478	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
479	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
480	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
481	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
482	};
483	static const REMPARMDESC g_aArgsNotifyHandlerPhysicalModify[] =
484	{
485	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
486	{ REMPARMDESC_FLAGS_INT, sizeof(PGMPHYSHANDLERTYPE), NULL },
487	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
488	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
489	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
490	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL },
491	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
492	};
493	static const REMPARMDESC g_aArgsNotifyHandlerPhysicalRegister[] =
494	{
495	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
496	{ REMPARMDESC_FLAGS_INT, sizeof(PGMPHYSHANDLERTYPE), NULL },
497	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
498	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
499	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
500	};
501	static const REMPARMDESC g_aArgsNotifyHandlerPhysicalDeregister[] =
502	{
503	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
504	{ REMPARMDESC_FLAGS_INT, sizeof(PGMPHYSHANDLERTYPE), NULL },
505	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
506	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
507	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL },
508	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
509	};
510	static const REMPARMDESC g_aArgsNotifyCodePageChanged[] =
511	{
512	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
513	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
514	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINTPTR), NULL }
515	};
516	static const REMPARMDESC g_aArgsNotifyPendingInterrupt[] =
517	{
518	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
519	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
520	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
521	};
522	static const REMPARMDESC g_aArgsDisasEnableStepping[] =
523	{
524	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
525	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
526	};
527	static const REMPARMDESC g_aArgsIsPageAccessHandled[] =
528	{
529	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
530	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }
531	};
532
533	# ifndef VBOX_USE_BITNESS_SELECTOR
534
535	/* VMM args */
536	static const REMPARMDESC g_aArgsCPUMGetGuestCpl[] =
537	{
538	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
539	};
540
541	/* CPUMQueryGuestMsr args */
542	static const REMPARMDESC g_aArgsCPUMQueryGuestMsr[] =
543	{
544	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
545	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
546	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t *), NULL },
547	};
548
549	/* CPUMSetGuestMsr args */
550	static const REMPARMDESC g_aArgsCPUMSetGuestMsr[] =
551	{
552	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
553	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
554	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL },
555	};
556
557	static const REMPARMDESC g_aArgsCPUMGetGuestCpuId[] =
558	{
559	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
560	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
561	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
562	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
563	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
564	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
565	};
566
567	static const REMPARMDESC g_aArgsCPUMR3RemEnter[] =
568	{
569	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
570	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
571	};
572
573	static const REMPARMDESC g_aArgsCPUMR3RemLeave[] =
574	{
575	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
576	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
577	};
578
579	static const REMPARMDESC g_aArgsCPUMSetChangedFlags[] =
580	{
581	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
582	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
583	};
584
585	static const REMPARMDESC g_aArgsCPUMQueryGuestCtxPtr[] =
586	{
587	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL }
588	};
589	static const REMPARMDESC g_aArgsCSAMR3MonitorPage[] =
590	{
591	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
592	{ REMPARMDESC_FLAGS_INT, sizeof(RTRCPTR), NULL },
593	{ REMPARMDESC_FLAGS_INT, sizeof(CSAMTAG), NULL }
594	};
595	static const REMPARMDESC g_aArgsCSAMR3UnmonitorPage[] =
596	{
597	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
598	{ REMPARMDESC_FLAGS_INT, sizeof(RTRCPTR), NULL },
599	{ REMPARMDESC_FLAGS_INT, sizeof(CSAMTAG), NULL }
600	};
601
602	static const REMPARMDESC g_aArgsCSAMR3RecordCallAddress[] =
603	{
604	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
605	{ REMPARMDESC_FLAGS_INT, sizeof(RTRCPTR), NULL }
606	};
607
608	# if defined(VBOX_WITH_DEBUGGER) && !(defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64)) /* the callbacks are problematic */
609	static const REMPARMDESC g_aArgsDBGCRegisterCommands[] =
610	{
611	{ REMPARMDESC_FLAGS_INT, sizeof(PCDBGCCMD), NULL },
612	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
613	};
614	# endif
615	static const REMPARMDESC g_aArgsDBGFR3DisasInstrEx[] =
616	{
617	{ REMPARMDESC_FLAGS_INT, sizeof(PUVM), NULL },
618	{ REMPARMDESC_FLAGS_INT, sizeof(VMCPUID), NULL },
619	{ REMPARMDESC_FLAGS_INT, sizeof(RTSEL), NULL },
620	{ REMPARMDESC_FLAGS_INT, sizeof(RTGCPTR), NULL },
621	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
622	{ REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
623	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
624	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
625	};
626	static const REMPARMDESC g_aArgsDBGFR3DisasInstrCurrentLogInternal[] =
627	{
628	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
629	{ REMPARMDESC_FLAGS_INT, sizeof(char *), NULL }
630	};
631	static const REMPARMDESC g_aArgsDBGFR3Info[] =
632	{
633	{ REMPARMDESC_FLAGS_INT, sizeof(PUVM), NULL },
634	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
635	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
636	{ REMPARMDESC_FLAGS_INT, sizeof(PCDBGFINFOHLP), NULL }
637	};
638	static const REMPARMDESC g_aArgsDBGFR3AsSymbolByAddr[] =
639	{
640	{ REMPARMDESC_FLAGS_INT, sizeof(PUVM), NULL },
641	{ REMPARMDESC_FLAGS_INT, sizeof(RTDBGAS), NULL },
642	{ REMPARMDESC_FLAGS_INT, sizeof(PCDBGFADDRESS), NULL },
643	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
644	{ REMPARMDESC_FLAGS_GCPTR, sizeof(PRTGCINTPTR), NULL },
645	{ REMPARMDESC_FLAGS_INT, sizeof(PRTDBGSYMBOL), NULL },
646	{ REMPARMDESC_FLAGS_INT, sizeof(PRTDBGMOD), NULL }
647	};
648	static const REMPARMDESC g_aArgsDBGFR3AddrFromFlat[] =
649	{
650	{ REMPARMDESC_FLAGS_INT, sizeof(PUVM), NULL },
651	{ REMPARMDESC_FLAGS_INT, sizeof(PDBGFADDRESS), NULL },
652	{ REMPARMDESC_FLAGS_INT, sizeof(RTGCUINTPTR), NULL }
653	};
654	static const REMPARMDESC g_aArgsDISInstrToStr[] =
655	{
656	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t const *), NULL },
657	{ REMPARMDESC_FLAGS_INT, sizeof(DISCPUMODE), NULL },
658	{ REMPARMDESC_FLAGS_INT, sizeof(PDISCPUSTATE), NULL },
659	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
660	{ REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
661	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
662	};
663	static const REMPARMDESC g_aArgsEMR3FatalError[] =
664	{
665	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
666	{ REMPARMDESC_FLAGS_INT, sizeof(int), NULL }
667	};
668	static const REMPARMDESC g_aArgsEMSetInhibitInterruptsPC[] =
669	{
670	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
671	{ REMPARMDESC_FLAGS_INT, sizeof(RTGCPTR), NULL }
672	};
673	static const REMPARMDESC g_aArgsHMR3CanExecuteGuest[] =
674	{
675	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
676	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
677	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
678	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
679	};
680	static const REMPARMDESC g_aArgsIOMIOPortRead[] =
681	{
682	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
683	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
684	{ REMPARMDESC_FLAGS_INT, sizeof(RTIOPORT), NULL },
685	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
686	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
687	};
688	static const REMPARMDESC g_aArgsIOMIOPortWrite[] =
689	{
690	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
691	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
692	{ REMPARMDESC_FLAGS_INT, sizeof(RTIOPORT), NULL },
693	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
694	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
695	};
696	static const REMPARMDESC g_aArgsIOMMMIORead[] =
697	{
698	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
699	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
700	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
701	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
702	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
703	};
704	static const REMPARMDESC g_aArgsIOMMMIOWrite[] =
705	{
706	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
707	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
708	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
709	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
710	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
711	};
712	static const REMPARMDESC g_aArgsMMR3HeapAlloc[] =
713	{
714	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
715	{ REMPARMDESC_FLAGS_INT, sizeof(MMTAG), NULL },
716	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
717	};
718	static const REMPARMDESC g_aArgsMMR3HeapAllocZ[] =
719	{
720	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
721	{ REMPARMDESC_FLAGS_INT, sizeof(MMTAG), NULL },
722	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
723	};
724	static const REMPARMDESC g_aArgsPATMIsPatchGCAddr[] =
725	{
726	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
727	{ REMPARMDESC_FLAGS_INT, sizeof(RTRCUINTPTR), NULL }
728	};
729	static const REMPARMDESC g_aArgsPATMR3QueryOpcode[] =
730	{
731	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
732	{ REMPARMDESC_FLAGS_INT, sizeof(RTRCPTR), NULL },
733	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL }
734	};
735	static const REMPARMDESC g_aArgsPDMApicGetBase[] =
736	{
737	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
738	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t *), NULL }
739	};
740	static const REMPARMDESC g_aArgsPDMApicGetTPR[] =
741	{
742	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
743	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL },
744	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL },
745	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL }
746	};
747	static const REMPARMDESC g_aArgsPDMApicSetBase[] =
748	{
749	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
750	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL }
751	};
752	static const REMPARMDESC g_aArgsPDMApicSetTPR[] =
753	{
754	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
755	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
756	};
757	static const REMPARMDESC g_aArgsPDMGetInterrupt[] =
758	{
759	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
760	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL }
761	};
762	static const REMPARMDESC g_aArgsPDMIsaSetIrq[] =
763	{
764	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
765	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL },
766	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL },
767	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
768	};
769	static const REMPARMDESC g_aArgsPDMR3CritSectInit[] =
770	{
771	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
772	{ REMPARMDESC_FLAGS_INT, sizeof(PPDMCRITSECT), NULL },
773	/* RT_SRC_POS_DECL */
774	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
775	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned int), NULL },
776	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
777	{ REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
778	{ REMPARMDESC_FLAGS_ELLIPSIS, 0 }
779	};
780	static const REMPARMDESC g_aArgsPDMCritSectEnter[] =
781	{
782	{ REMPARMDESC_FLAGS_INT, sizeof(PPDMCRITSECT), NULL },
783	{ REMPARMDESC_FLAGS_INT, sizeof(int), NULL }
784	};
785	static const REMPARMDESC g_aArgsPDMCritSectEnterDebug[] =
786	{
787	{ REMPARMDESC_FLAGS_INT, sizeof(PPDMCRITSECT), NULL },
788	{ REMPARMDESC_FLAGS_INT, sizeof(int), NULL },
789	{ REMPARMDESC_FLAGS_INT, sizeof(RTHCUINTPTR), NULL },
790	/* RT_SRC_POS_DECL */
791	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
792	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
793	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
794	};
795	static const REMPARMDESC g_aArgsPGMGetGuestMode[] =
796	{
797	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
798	};
799	static const REMPARMDESC g_aArgsPGMGstGetPage[] =
800	{
801	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
802	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL },
803	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t *), NULL },
804	{ REMPARMDESC_FLAGS_INT, sizeof(PRTGCPHYS), NULL }
805	};
806	static const REMPARMDESC g_aArgsPGMInvalidatePage[] =
807	{
808	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
809	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL }
810	};
811	static const REMPARMDESC g_aArgsPGMR3PhysTlbGCPhys2Ptr[] =
812	{
813	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
814	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
815	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL },
816	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL }
817	};
818	static const REMPARMDESC g_aArgsPGM3PhysGrowRange[] =
819	{
820	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
821	{ REMPARMDESC_FLAGS_INT, sizeof(PCRTGCPHYS), NULL }
822	};
823	static const REMPARMDESC g_aArgsPGMPhysIsGCPhysValid[] =
824	{
825	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
826	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }
827	};
828	static const REMPARMDESC g_aArgsPGMPhysRead[] =
829	{
830	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
831	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
832	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
833	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
834	};
835	static const REMPARMDESC g_aArgsPGMPhysSimpleReadGCPtr[] =
836	{
837	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
838	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
839	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL },
840	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
841	};
842	static const REMPARMDESC g_aArgsPGMPhysWrite[] =
843	{
844	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
845	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
846	{ REMPARMDESC_FLAGS_INT, sizeof(const void *), NULL },
847	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
848	};
849	static const REMPARMDESC g_aArgsPGMChangeMode[] =
850	{
851	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
852	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL },
853	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL },
854	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL }
855	};
856	static const REMPARMDESC g_aArgsPGMFlushTLB[] =
857	{
858	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
859	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL },
860	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
861	};
862	static const REMPARMDESC g_aArgsPGMR3PhysReadUxx[] =
863	{
864	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
865	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }
866	};
867	static const REMPARMDESC g_aArgsPGMR3PhysWriteU8[] =
868	{
869	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
870	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
871	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
872	};
873	static const REMPARMDESC g_aArgsPGMR3PhysWriteU16[] =
874	{
875	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
876	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
877	{ REMPARMDESC_FLAGS_INT, sizeof(uint16_t), NULL }
878	};
879	static const REMPARMDESC g_aArgsPGMR3PhysWriteU32[] =
880	{
881	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
882	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
883	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
884	};
885	static const REMPARMDESC g_aArgsPGMR3PhysWriteU64[] =
886	{
887	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
888	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
889	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL }
890	};
891	static const REMPARMDESC g_aArgsRTMemReallocTag[] =
892	{
893	{ REMPARMDESC_FLAGS_INT, sizeof(void*), NULL },
894	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
895	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
896	};
897	static const REMPARMDESC g_aArgsRTMemEfRealloc[] =
898	{
899	{ REMPARMDESC_FLAGS_INT, sizeof(void*), NULL },
900	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
901	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
902	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
903	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned int), NULL },
904	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
905	};
906	static const REMPARMDESC g_aArgsSSMR3GetGCPtr[] =
907	{
908	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
909	{ REMPARMDESC_FLAGS_INT, sizeof(PRTGCPTR), NULL }
910	};
911	static const REMPARMDESC g_aArgsSSMR3GetMem[] =
912	{
913	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
914	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
915	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
916	};
917	static const REMPARMDESC g_aArgsSSMR3GetU32[] =
918	{
919	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
920	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
921	};
922	static const REMPARMDESC g_aArgsSSMR3GetUInt[] =
923	{
924	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
925	{ REMPARMDESC_FLAGS_INT, sizeof(PRTUINT), NULL }
926	};
927	static const REMPARMDESC g_aArgsSSMR3PutGCPtr[] =
928	{
929	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
930	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL }
931	};
932	static const REMPARMDESC g_aArgsSSMR3PutMem[] =
933	{
934	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
935	{ REMPARMDESC_FLAGS_INT, sizeof(const void *), NULL },
936	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
937	};
938	static const REMPARMDESC g_aArgsSSMR3PutU32[] =
939	{
940	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
941	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
942	};
943	static const REMPARMDESC g_aArgsSSMR3PutUInt[] =
944	{
945	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
946	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
947	};
948
949	static const REMPARMDESC g_aArgsSSMIntLiveExecCallback[] =
950	{
951	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
952	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
953	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
954	};
955	static REMFNDESC g_SSMIntLiveExecCallback =
956	{
957	"SSMIntLiveExecCallback", NULL, &g_aArgsSSMIntLiveExecCallback[0], RT_ELEMENTS(g_aArgsSSMIntLiveExecCallback), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL
958	};
959
960	static const REMPARMDESC g_aArgsSSMIntLiveVoteCallback[] =
961	{
962	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
963	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
964	};
965	static REMFNDESC g_SSMIntLiveVoteCallback =
966	{
967	"SSMIntLiveVoteCallback", NULL, &g_aArgsSSMIntLiveVoteCallback[0], RT_ELEMENTS(g_aArgsSSMIntLiveVoteCallback), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL
968	};
969
970	static const REMPARMDESC g_aArgsSSMIntCallback[] =
971	{
972	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
973	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
974	};
975	static REMFNDESC g_SSMIntCallback =
976	{
977	"SSMIntCallback", NULL, &g_aArgsSSMIntCallback[0], RT_ELEMENTS(g_aArgsSSMIntCallback), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL
978	};
979
980	static const REMPARMDESC g_aArgsSSMIntLoadExecCallback[] =
981	{
982	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
983	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
984	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
985	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
986	};
987	static REMFNDESC g_SSMIntLoadExecCallback =
988	{
989	"SSMIntLoadExecCallback", NULL, &g_aArgsSSMIntLoadExecCallback[0], RT_ELEMENTS(g_aArgsSSMIntLoadExecCallback), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL
990	};
991	/* Note: don't forget about the handwritten assembly wrapper when changing this! */
992	static const REMPARMDESC g_aArgsSSMR3RegisterInternal[] =
993	{
994	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
995	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
996	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
997	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
998	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
999	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLIVEPREP), &g_SSMIntCallback },
1000	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLIVEEXEC), &g_SSMIntLiveExecCallback },
1001	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLIVEVOTE), &g_SSMIntLiveVoteCallback },
1002	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTSAVEPREP), &g_SSMIntCallback },
1003	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTSAVEEXEC), &g_SSMIntCallback },
1004	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTSAVEDONE), &g_SSMIntCallback },
1005	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLOADPREP), &g_SSMIntCallback },
1006	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLOADEXEC), &g_SSMIntLoadExecCallback },
1007	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLOADDONE), &g_SSMIntCallback },
1008	};
1009
1010	static const REMPARMDESC g_aArgsSTAMR3Register[] =
1011	{
1012	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
1013	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
1014	{ REMPARMDESC_FLAGS_INT, sizeof(STAMTYPE), NULL },
1015	{ REMPARMDESC_FLAGS_INT, sizeof(STAMVISIBILITY), NULL },
1016	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1017	{ REMPARMDESC_FLAGS_INT, sizeof(STAMUNIT), NULL },
1018	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
1019	};
1020	static const REMPARMDESC g_aArgsSTAMR3Deregister[] =
1021	{
1022	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
1023	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1024	};
1025	static const REMPARMDESC g_aArgsTRPMAssertTrap[] =
1026	{
1027	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
1028	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL },
1029	{ REMPARMDESC_FLAGS_INT, sizeof(TRPMEVENT), NULL }
1030	};
1031	static const REMPARMDESC g_aArgsTRPMQueryTrap[] =
1032	{
1033	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
1034	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL },
1035	{ REMPARMDESC_FLAGS_INT, sizeof(TRPMEVENT *), NULL }
1036	};
1037	static const REMPARMDESC g_aArgsTRPMSetErrorCode[] =
1038	{
1039	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
1040	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINT), NULL }
1041	};
1042	static const REMPARMDESC g_aArgsTRPMSetFaultAddress[] =
1043	{
1044	{ REMPARMDESC_FLAGS_INT, sizeof(PVMCPU), NULL },
1045	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINT), NULL }
1046	};
1047	static const REMPARMDESC g_aArgsVMR3ReqCallWait[] =
1048	{
1049	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
1050	{ REMPARMDESC_FLAGS_INT, sizeof(VMCPUID), NULL },
1051	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
1052	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
1053	{ REMPARMDESC_FLAGS_ELLIPSIS, 0, NULL }
1054	};
1055	static const REMPARMDESC g_aArgsVMR3ReqFree[] =
1056	{
1057	{ REMPARMDESC_FLAGS_INT, sizeof(PVMREQ), NULL }
1058	};
1059
1060	/* IPRT args */
1061	static const REMPARMDESC g_aArgsRTAssertMsg1[] =
1062	{
1063	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1064	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
1065	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1066	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
1067	};
1068	static const REMPARMDESC g_aArgsRTAssertMsg2[] =
1069	{
1070	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1071	{ REMPARMDESC_FLAGS_ELLIPSIS, 0, NULL }
1072	};
1073	static const REMPARMDESC g_aArgsRTAssertMsg2V[] =
1074	{
1075	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1076	{ REMPARMDESC_FLAGS_VALIST, 0, NULL }
1077	};
1078	static const REMPARMDESC g_aArgsRTLogFlags[] =
1079	{
1080	{ REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL },
1081	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
1082	};
1083	static const REMPARMDESC g_aArgsRTLogFlush[] =
1084	{
1085	{ REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL }
1086	};
1087	static const REMPARMDESC g_aArgsRTLogLoggerEx[] =
1088	{
1089	{ REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL },
1090	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
1091	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
1092	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1093	{ REMPARMDESC_FLAGS_ELLIPSIS, 0, NULL }
1094	};
1095	static const REMPARMDESC g_aArgsRTLogLoggerExV[] =
1096	{
1097	{ REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL },
1098	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
1099	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
1100	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1101	{ REMPARMDESC_FLAGS_VALIST, 0, NULL }
1102	};
1103	static const REMPARMDESC g_aArgsRTLogPrintf[] =
1104	{
1105	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1106	{ REMPARMDESC_FLAGS_ELLIPSIS, 0, NULL }
1107	};
1108	static const REMPARMDESC g_aArgsRTMemProtect[] =
1109	{
1110	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
1111	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
1112	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
1113	};
1114	static const REMPARMDESC g_aArgsRTStrPrintf[] =
1115	{
1116	{ REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
1117	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
1118	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1119	{ REMPARMDESC_FLAGS_ELLIPSIS, 0, NULL }
1120	};
1121	static const REMPARMDESC g_aArgsRTStrPrintfV[] =
1122	{
1123	{ REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
1124	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
1125	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
1126	{ REMPARMDESC_FLAGS_VALIST, 0, NULL }
1127	};
1128	static const REMPARMDESC g_aArgsThread[] =
1129	{
1130	{ REMPARMDESC_FLAGS_INT, sizeof(RTTHREAD), NULL }
1131	};
1132
1133
1134	/* CRT args */
1135	static const REMPARMDESC g_aArgsmemcpy[] =
1136	{
1137	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
1138	{ REMPARMDESC_FLAGS_INT, sizeof(const void *), NULL },
1139	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
1140	};
1141	static const REMPARMDESC g_aArgsmemset[] =
1142	{
1143	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
1144	{ REMPARMDESC_FLAGS_INT, sizeof(int), NULL },
1145	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
1146	};
1147
1148	# endif /* !VBOX_USE_BITNESS_SELECTOR */
1149
1150	/** @} */
1151
1152	/**
1153	* Descriptors for the exported functions.
1154	*/
1155	static const REMFNDESC g_aExports[] =
1156	{ /* pszName, (void )pv, pParams, cParams, fFlags, cb, pvWrapper. /
1157	{ "REMR3Init", (void *)&pfnREMR3Init, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1158	{ "REMR3InitFinalize", (void *)&pfnREMR3InitFinalize, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1159	{ "REMR3Term", (void *)&pfnREMR3Term, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1160	{ "REMR3Reset", (void *)&pfnREMR3Reset, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1161	{ "REMR3Step", (void *)&pfnREMR3Step, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1162	{ "REMR3BreakpointSet", (void *)&pfnREMR3BreakpointSet, &g_aArgsBreakpoint[0], RT_ELEMENTS(g_aArgsBreakpoint), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1163	{ "REMR3BreakpointClear", (void *)&pfnREMR3BreakpointClear, &g_aArgsBreakpoint[0], RT_ELEMENTS(g_aArgsBreakpoint), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1164	{ "REMR3EmulateInstruction", (void *)&pfnREMR3EmulateInstruction, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1165	{ "REMR3Run", (void *)&pfnREMR3Run, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1166	{ "REMR3State", (void *)&pfnREMR3State, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1167	{ "REMR3StateBack", (void *)&pfnREMR3StateBack, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1168	{ "REMR3StateUpdate", (void *)&pfnREMR3StateUpdate, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1169	{ "REMR3A20Set", (void *)&pfnREMR3A20Set, &g_aArgsA20Set[0], RT_ELEMENTS(g_aArgsA20Set), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1170	{ "REMR3ReplayHandlerNotifications", (void *)&pfnREMR3ReplayHandlerNotifications, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1171	{ "REMR3NotifyPhysRamRegister", (void *)&pfnREMR3NotifyPhysRamRegister, &g_aArgsNotifyPhysRamRegister[0], RT_ELEMENTS(g_aArgsNotifyPhysRamRegister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1172	{ "REMR3NotifyPhysRamDeregister", (void *)&pfnREMR3NotifyPhysRamDeregister, &g_aArgsNotifyPhysRamDeregister[0], RT_ELEMENTS(g_aArgsNotifyPhysRamDeregister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1173	{ "REMR3NotifyPhysRomRegister", (void *)&pfnREMR3NotifyPhysRomRegister, &g_aArgsNotifyPhysRomRegister[0], RT_ELEMENTS(g_aArgsNotifyPhysRomRegister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1174	{ "REMR3NotifyHandlerPhysicalModify", (void *)&pfnREMR3NotifyHandlerPhysicalModify, &g_aArgsNotifyHandlerPhysicalModify[0], RT_ELEMENTS(g_aArgsNotifyHandlerPhysicalModify), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1175	{ "REMR3NotifyHandlerPhysicalRegister", (void *)&pfnREMR3NotifyHandlerPhysicalRegister, &g_aArgsNotifyHandlerPhysicalRegister[0], RT_ELEMENTS(g_aArgsNotifyHandlerPhysicalRegister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1176	{ "REMR3NotifyHandlerPhysicalDeregister", (void *)&pfnREMR3NotifyHandlerPhysicalDeregister, &g_aArgsNotifyHandlerPhysicalDeregister[0], RT_ELEMENTS(g_aArgsNotifyHandlerPhysicalDeregister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1177	{ "REMR3NotifyInterruptSet", (void *)&pfnREMR3NotifyInterruptSet, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1178	{ "REMR3NotifyInterruptClear", (void *)&pfnREMR3NotifyInterruptClear, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1179	{ "REMR3NotifyTimerPending", (void *)&pfnREMR3NotifyTimerPending, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1180	{ "REMR3NotifyDmaPending", (void *)&pfnREMR3NotifyDmaPending, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1181	{ "REMR3NotifyQueuePending", (void *)&pfnREMR3NotifyQueuePending, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1182	{ "REMR3NotifyFF", (void *)&pfnREMR3NotifyFF, &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1183	{ "REMR3NotifyCodePageChanged", (void *)&pfnREMR3NotifyCodePageChanged, &g_aArgsNotifyCodePageChanged[0], RT_ELEMENTS(g_aArgsNotifyCodePageChanged), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1184	{ "REMR3NotifyPendingInterrupt", (void *)&pfnREMR3NotifyPendingInterrupt, &g_aArgsNotifyPendingInterrupt[0], RT_ELEMENTS(g_aArgsNotifyPendingInterrupt), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1185	{ "REMR3QueryPendingInterrupt", (void *)&pfnREMR3QueryPendingInterrupt, &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1186	{ "REMR3DisasEnableStepping", (void *)&pfnREMR3DisasEnableStepping, &g_aArgsDisasEnableStepping[0], RT_ELEMENTS(g_aArgsDisasEnableStepping), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1187	{ "REMR3IsPageAccessHandled", (void *)&pfnREMR3IsPageAccessHandled, &g_aArgsIsPageAccessHandled[0], RT_ELEMENTS(g_aArgsIsPageAccessHandled), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL }
1188	};
1189
1190	# ifndef VBOX_USE_BITNESS_SELECTOR
1191
1192	# ifdef VBOX_WITHOUT_REM_LDR_CYCLE
1193	# define VMM_FN(name) NULL
1194	# else
1195	# define VMM_FN(name) (void *)(uintptr_t)& name
1196	# endif
1197
1198	/**
1199	* Descriptors for the functions imported from VBoxVMM.
1200	*/
1201	static REMFNDESC g_aVMMImports[] =
1202	{
1203	{ "CPUMR3RemEnter", VMM_FN(CPUMR3RemEnter), &g_aArgsCPUMR3RemEnter[0], RT_ELEMENTS(g_aArgsCPUMR3RemEnter), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1204	{ "CPUMR3RemLeave", VMM_FN(CPUMR3RemLeave), &g_aArgsCPUMR3RemLeave[0], RT_ELEMENTS(g_aArgsCPUMR3RemLeave), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1205	{ "CPUMSetChangedFlags", VMM_FN(CPUMSetChangedFlags), &g_aArgsCPUMSetChangedFlags[0], RT_ELEMENTS(g_aArgsCPUMSetChangedFlags), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1206	{ "CPUMGetGuestCPL", VMM_FN(CPUMGetGuestCPL), &g_aArgsCPUMGetGuestCpl[0], RT_ELEMENTS(g_aArgsCPUMGetGuestCpl), REMFNDESC_FLAGS_RET_INT, sizeof(unsigned), NULL },
1207	{ "CPUMQueryGuestMsr", VMM_FN(CPUMQueryGuestMsr), &g_aArgsCPUMQueryGuestMsr[0], RT_ELEMENTS(g_aArgsCPUMQueryGuestMsr), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
1208	{ "CPUMSetGuestMsr", VMM_FN(CPUMSetGuestMsr), &g_aArgsCPUMSetGuestMsr[0], RT_ELEMENTS(g_aArgsCPUMSetGuestMsr), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1209	{ "CPUMGetGuestCpuId", VMM_FN(CPUMGetGuestCpuId), &g_aArgsCPUMGetGuestCpuId[0], RT_ELEMENTS(g_aArgsCPUMGetGuestCpuId), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1210	{ "CPUMGetGuestEAX", VMM_FN(CPUMGetGuestEAX), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1211	{ "CPUMGetGuestEBP", VMM_FN(CPUMGetGuestEBP), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1212	{ "CPUMGetGuestEBX", VMM_FN(CPUMGetGuestEBX), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1213	{ "CPUMGetGuestECX", VMM_FN(CPUMGetGuestECX), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1214	{ "CPUMGetGuestEDI", VMM_FN(CPUMGetGuestEDI), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1215	{ "CPUMGetGuestEDX", VMM_FN(CPUMGetGuestEDX), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1216	{ "CPUMGetGuestEIP", VMM_FN(CPUMGetGuestEIP), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1217	{ "CPUMGetGuestESI", VMM_FN(CPUMGetGuestESI), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1218	{ "CPUMGetGuestESP", VMM_FN(CPUMGetGuestESP), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1219	{ "CPUMGetGuestCS", VMM_FN(CPUMGetGuestCS), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(RTSEL), NULL },
1220	{ "CPUMGetGuestSS", VMM_FN(CPUMGetGuestSS), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(RTSEL), NULL },
1221	{ "CPUMGetGuestCpuVendor", VMM_FN(CPUMGetGuestCpuVendor), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(CPUMCPUVENDOR), NULL },
1222	{ "CPUMQueryGuestCtxPtr", VMM_FN(CPUMQueryGuestCtxPtr), &g_aArgsCPUMQueryGuestCtxPtr[0], RT_ELEMENTS(g_aArgsCPUMQueryGuestCtxPtr), REMFNDESC_FLAGS_RET_INT, sizeof(PCPUMCTX), NULL },
1223	{ "CSAMR3MonitorPage", VMM_FN(CSAMR3MonitorPage), &g_aArgsCSAMR3MonitorPage[0], RT_ELEMENTS(g_aArgsCSAMR3MonitorPage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1224	{ "CSAMR3UnmonitorPage", VMM_FN(CSAMR3UnmonitorPage), &g_aArgsCSAMR3UnmonitorPage[0], RT_ELEMENTS(g_aArgsCSAMR3UnmonitorPage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1225	{ "CSAMR3RecordCallAddress", VMM_FN(CSAMR3RecordCallAddress), &g_aArgsCSAMR3RecordCallAddress[0], RT_ELEMENTS(g_aArgsCSAMR3RecordCallAddress), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1226	# if defined(VBOX_WITH_DEBUGGER) && !(defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64)) /* the callbacks are problematic */
1227	{ "DBGCRegisterCommands", VMM_FN(DBGCRegisterCommands), &g_aArgsDBGCRegisterCommands[0], RT_ELEMENTS(g_aArgsDBGCRegisterCommands), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1228	# endif
1229	{ "DBGFR3DisasInstrEx", VMM_FN(DBGFR3DisasInstrEx), &g_aArgsDBGFR3DisasInstrEx[0], RT_ELEMENTS(g_aArgsDBGFR3DisasInstrEx), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1230	{ "DBGFR3DisasInstrCurrentLogInternal", VMM_FN(DBGFR3DisasInstrCurrentLogInternal), &g_aArgsDBGFR3DisasInstrCurrentLogInternal[0], RT_ELEMENTS(g_aArgsDBGFR3DisasInstrCurrentLogInternal),REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1231	{ "DBGFR3Info", VMM_FN(DBGFR3Info), &g_aArgsDBGFR3Info[0], RT_ELEMENTS(g_aArgsDBGFR3Info), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1232	{ "DBGFR3InfoLogRelHlp", VMM_FN(DBGFR3InfoLogRelHlp), NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
1233	{ "DBGFR3AsSymbolByAddr", VMM_FN(DBGFR3AsSymbolByAddr), &g_aArgsDBGFR3AsSymbolByAddr[0], RT_ELEMENTS(g_aArgsDBGFR3AsSymbolByAddr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1234	{ "DBGFR3AddrFromFlat", VMM_FN(DBGFR3AddrFromFlat), &g_aArgsDBGFR3AddrFromFlat[0], RT_ELEMENTS(g_aArgsDBGFR3AddrFromFlat), REMFNDESC_FLAGS_RET_INT, sizeof(PDBGFADDRESS), NULL },
1235	{ "DISInstrToStr", VMM_FN(DISInstrToStr), &g_aArgsDISInstrToStr[0], RT_ELEMENTS(g_aArgsDISInstrToStr), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1236	{ "EMR3FatalError", VMM_FN(EMR3FatalError), &g_aArgsEMR3FatalError[0], RT_ELEMENTS(g_aArgsEMR3FatalError), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1237	{ "EMRemLock", VMM_FN(EMRemLock), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1238	{ "EMRemUnlock", VMM_FN(EMRemUnlock), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1239	{ "EMRemIsLockOwner", VMM_FN(EMRemIsLockOwner), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, sizeof(bool), NULL },
1240	{ "EMGetInhibitInterruptsPC", VMM_FN(EMGetInhibitInterruptsPC), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(RTGCPTR), NULL },
1241	{ "EMSetInhibitInterruptsPC", VMM_FN(EMSetInhibitInterruptsPC), &g_aArgsEMSetInhibitInterruptsPC[0], RT_ELEMENTS(g_aArgsEMSetInhibitInterruptsPC), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1242	{ "HMIsEnabledNotMacro", VMM_FN(HMIsEnabledNotMacro), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1243	{ "HMR3CanExecuteGuest", VMM_FN(HMR3CanExecuteGuest), &g_aArgsHMR3CanExecuteGuest[0], RT_ELEMENTS(g_aArgsHMR3CanExecuteGuest), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1244	{ "IOMIOPortRead", VMM_FN(IOMIOPortRead), &g_aArgsIOMIOPortRead[0], RT_ELEMENTS(g_aArgsIOMIOPortRead), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1245	{ "IOMIOPortWrite", VMM_FN(IOMIOPortWrite), &g_aArgsIOMIOPortWrite[0], RT_ELEMENTS(g_aArgsIOMIOPortWrite), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1246	{ "IOMMMIORead", VMM_FN(IOMMMIORead), &g_aArgsIOMMMIORead[0], RT_ELEMENTS(g_aArgsIOMMMIORead), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1247	{ "IOMMMIOWrite", VMM_FN(IOMMMIOWrite), &g_aArgsIOMMMIOWrite[0], RT_ELEMENTS(g_aArgsIOMMMIOWrite), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1248	{ "MMR3HeapAlloc", VMM_FN(MMR3HeapAlloc), &g_aArgsMMR3HeapAlloc[0], RT_ELEMENTS(g_aArgsMMR3HeapAlloc), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
1249	{ "MMR3HeapAllocZ", VMM_FN(MMR3HeapAllocZ), &g_aArgsMMR3HeapAllocZ[0], RT_ELEMENTS(g_aArgsMMR3HeapAllocZ), REMFNDESC_FLAGS_RET_INT, sizeof(void *), NULL },
1250	{ "MMR3PhysGetRamSize", VMM_FN(MMR3PhysGetRamSize), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
1251	{ "PATMIsPatchGCAddr", VMM_FN(PATMIsPatchGCAddr), &g_aArgsPATMIsPatchGCAddr[0], RT_ELEMENTS(g_aArgsPATMIsPatchGCAddr), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1252	{ "PATMR3QueryOpcode", VMM_FN(PATMR3QueryOpcode), &g_aArgsPATMR3QueryOpcode[0], RT_ELEMENTS(g_aArgsPATMR3QueryOpcode), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1253	{ "PDMApicGetBase", VMM_FN(PDMApicGetBase), &g_aArgsPDMApicGetBase[0], RT_ELEMENTS(g_aArgsPDMApicGetBase), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1254	{ "PDMApicGetTPR", VMM_FN(PDMApicGetTPR), &g_aArgsPDMApicGetTPR[0], RT_ELEMENTS(g_aArgsPDMApicGetTPR), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1255	{ "PDMApicSetBase", VMM_FN(PDMApicSetBase), &g_aArgsPDMApicSetBase[0], RT_ELEMENTS(g_aArgsPDMApicSetBase), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1256	{ "PDMApicSetTPR", VMM_FN(PDMApicSetTPR), &g_aArgsPDMApicSetTPR[0], RT_ELEMENTS(g_aArgsPDMApicSetTPR), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1257	{ "PDMR3DmaRun", VMM_FN(PDMR3DmaRun), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1258	{ "PDMR3CritSectInit", VMM_FN(PDMR3CritSectInit), &g_aArgsPDMR3CritSectInit[0], RT_ELEMENTS(g_aArgsPDMR3CritSectInit), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1259	{ "PDMCritSectEnter", VMM_FN(PDMCritSectEnter), &g_aArgsPDMCritSectEnter[0], RT_ELEMENTS(g_aArgsPDMCritSectEnter), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1260	{ "PDMCritSectLeave", VMM_FN(PDMCritSectLeave), &g_aArgsPTR[0], RT_ELEMENTS(g_aArgsPTR), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1261	# ifdef VBOX_STRICT
1262	{ "PDMCritSectEnterDebug", VMM_FN(PDMCritSectEnterDebug), &g_aArgsPDMCritSectEnterDebug[0], RT_ELEMENTS(g_aArgsPDMCritSectEnterDebug), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1263	# endif
1264	{ "PDMGetInterrupt", VMM_FN(PDMGetInterrupt), &g_aArgsPDMGetInterrupt[0], RT_ELEMENTS(g_aArgsPDMGetInterrupt), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1265	{ "PDMIsaSetIrq", VMM_FN(PDMIsaSetIrq), &g_aArgsPDMIsaSetIrq[0], RT_ELEMENTS(g_aArgsPDMIsaSetIrq), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1266	{ "PGMGetGuestMode", VMM_FN(PGMGetGuestMode), &g_aArgsPGMGetGuestMode[0], RT_ELEMENTS(g_aArgsPGMGetGuestMode), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1267	{ "PGMGstGetPage", VMM_FN(PGMGstGetPage), &g_aArgsPGMGstGetPage[0], RT_ELEMENTS(g_aArgsPGMGstGetPage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1268	{ "PGMInvalidatePage", VMM_FN(PGMInvalidatePage), &g_aArgsPGMInvalidatePage[0], RT_ELEMENTS(g_aArgsPGMInvalidatePage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1269	{ "PGMPhysIsGCPhysValid", VMM_FN(PGMPhysIsGCPhysValid), &g_aArgsPGMPhysIsGCPhysValid[0], RT_ELEMENTS(g_aArgsPGMPhysIsGCPhysValid), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1270	{ "PGMPhysIsA20Enabled", VMM_FN(PGMPhysIsA20Enabled), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1271	{ "PGMPhysRead", VMM_FN(PGMPhysRead), &g_aArgsPGMPhysRead[0], RT_ELEMENTS(g_aArgsPGMPhysRead), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1272	{ "PGMPhysSimpleReadGCPtr", VMM_FN(PGMPhysSimpleReadGCPtr), &g_aArgsPGMPhysSimpleReadGCPtr[0], RT_ELEMENTS(g_aArgsPGMPhysSimpleReadGCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1273	{ "PGMPhysWrite", VMM_FN(PGMPhysWrite), &g_aArgsPGMPhysWrite[0], RT_ELEMENTS(g_aArgsPGMPhysWrite), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1274	{ "PGMChangeMode", VMM_FN(PGMChangeMode), &g_aArgsPGMChangeMode[0], RT_ELEMENTS(g_aArgsPGMChangeMode), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1275	{ "PGMFlushTLB", VMM_FN(PGMFlushTLB), &g_aArgsPGMFlushTLB[0], RT_ELEMENTS(g_aArgsPGMFlushTLB), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1276	{ "PGMCr0WpEnabled", VMM_FN(PGMCr0WpEnabled), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1277	{ "PGMR3PhysReadU8", VMM_FN(PGMR3PhysReadU8), &g_aArgsPGMR3PhysReadUxx[0], RT_ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint8_t), NULL },
1278	{ "PGMR3PhysReadU16", VMM_FN(PGMR3PhysReadU16), &g_aArgsPGMR3PhysReadUxx[0], RT_ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint16_t), NULL },
1279	{ "PGMR3PhysReadU32", VMM_FN(PGMR3PhysReadU32), &g_aArgsPGMR3PhysReadUxx[0], RT_ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1280	{ "PGMR3PhysReadU64", VMM_FN(PGMR3PhysReadU64), &g_aArgsPGMR3PhysReadUxx[0], RT_ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
1281	{ "PGMR3PhysWriteU8", VMM_FN(PGMR3PhysWriteU8), &g_aArgsPGMR3PhysWriteU8[0], RT_ELEMENTS(g_aArgsPGMR3PhysWriteU8), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1282	{ "PGMR3PhysWriteU16", VMM_FN(PGMR3PhysWriteU16), &g_aArgsPGMR3PhysWriteU16[0], RT_ELEMENTS(g_aArgsPGMR3PhysWriteU16), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1283	{ "PGMR3PhysWriteU32", VMM_FN(PGMR3PhysWriteU32), &g_aArgsPGMR3PhysWriteU32[0], RT_ELEMENTS(g_aArgsPGMR3PhysWriteU32), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1284	{ "PGMR3PhysWriteU64", VMM_FN(PGMR3PhysWriteU64), &g_aArgsPGMR3PhysWriteU64[0], RT_ELEMENTS(g_aArgsPGMR3PhysWriteU32), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1285	{ "PGMR3PhysTlbGCPhys2Ptr", VMM_FN(PGMR3PhysTlbGCPhys2Ptr), &g_aArgsPGMR3PhysTlbGCPhys2Ptr[0], RT_ELEMENTS(g_aArgsPGMR3PhysTlbGCPhys2Ptr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1286	{ "PGMIsLockOwner", VMM_FN(PGMIsLockOwner), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1287	{ "SSMR3GetGCPtr", VMM_FN(SSMR3GetGCPtr), &g_aArgsSSMR3GetGCPtr[0], RT_ELEMENTS(g_aArgsSSMR3GetGCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1288	{ "SSMR3GetMem", VMM_FN(SSMR3GetMem), &g_aArgsSSMR3GetMem[0], RT_ELEMENTS(g_aArgsSSMR3GetMem), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1289	{ "SSMR3GetU32", VMM_FN(SSMR3GetU32), &g_aArgsSSMR3GetU32[0], RT_ELEMENTS(g_aArgsSSMR3GetU32), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1290	{ "SSMR3GetUInt", VMM_FN(SSMR3GetUInt), &g_aArgsSSMR3GetUInt[0], RT_ELEMENTS(g_aArgsSSMR3GetUInt), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1291	{ "SSMR3PutGCPtr", VMM_FN(SSMR3PutGCPtr), &g_aArgsSSMR3PutGCPtr[0], RT_ELEMENTS(g_aArgsSSMR3PutGCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1292	{ "SSMR3PutMem", VMM_FN(SSMR3PutMem), &g_aArgsSSMR3PutMem[0], RT_ELEMENTS(g_aArgsSSMR3PutMem), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1293	{ "SSMR3PutU32", VMM_FN(SSMR3PutU32), &g_aArgsSSMR3PutU32[0], RT_ELEMENTS(g_aArgsSSMR3PutU32), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1294	{ "SSMR3PutUInt", VMM_FN(SSMR3PutUInt), &g_aArgsSSMR3PutUInt[0], RT_ELEMENTS(g_aArgsSSMR3PutUInt), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1295	{ "SSMR3RegisterInternal", VMM_FN(SSMR3RegisterInternal), &g_aArgsSSMR3RegisterInternal[0], RT_ELEMENTS(g_aArgsSSMR3RegisterInternal), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1296	{ "STAMR3Register", VMM_FN(STAMR3Register), &g_aArgsSTAMR3Register[0], RT_ELEMENTS(g_aArgsSTAMR3Register), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1297	{ "STAMR3Deregister", VMM_FN(STAMR3Deregister), &g_aArgsSTAMR3Deregister[0], RT_ELEMENTS(g_aArgsSTAMR3Deregister), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1298	{ "TMCpuTickGet", VMM_FN(TMCpuTickGet), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
1299	{ "TMR3NotifySuspend", VMM_FN(TMR3NotifySuspend), &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1300	{ "TMR3NotifyResume", VMM_FN(TMR3NotifyResume), &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1301	{ "TMNotifyEndOfExecution", VMM_FN(TMNotifyEndOfExecution), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1302	{ "TMNotifyStartOfExecution", VMM_FN(TMNotifyStartOfExecution), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1303	{ "TMTimerPollBool", VMM_FN(TMTimerPollBool), &g_aArgsVMandVMCPU[0], RT_ELEMENTS(g_aArgsVMandVMCPU), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1304	{ "TMR3TimerQueuesDo", VMM_FN(TMR3TimerQueuesDo), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1305	{ "TRPMAssertTrap", VMM_FN(TRPMAssertTrap), &g_aArgsTRPMAssertTrap[0], RT_ELEMENTS(g_aArgsTRPMAssertTrap), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1306	{ "TRPMGetErrorCode", VMM_FN(TRPMGetErrorCode), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(RTGCUINT), NULL },
1307	{ "TRPMGetFaultAddress", VMM_FN(TRPMGetFaultAddress), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(RTGCUINTPTR),NULL },
1308	{ "TRPMQueryTrap", VMM_FN(TRPMQueryTrap), &g_aArgsTRPMQueryTrap[0], RT_ELEMENTS(g_aArgsTRPMQueryTrap), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1309	{ "TRPMResetTrap", VMM_FN(TRPMResetTrap), &g_aArgsVMCPU[0], RT_ELEMENTS(g_aArgsVMCPU), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1310	{ "TRPMSetErrorCode", VMM_FN(TRPMSetErrorCode), &g_aArgsTRPMSetErrorCode[0], RT_ELEMENTS(g_aArgsTRPMSetErrorCode), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1311	{ "TRPMSetFaultAddress", VMM_FN(TRPMSetFaultAddress), &g_aArgsTRPMSetFaultAddress[0], RT_ELEMENTS(g_aArgsTRPMSetFaultAddress), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1312	{ "VMMGetCpu", VMM_FN(VMMGetCpu), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(PVMCPU), NULL },
1313	{ "VMR3ReqPriorityCallWait", VMM_FN(VMR3ReqPriorityCallWait), &g_aArgsVMR3ReqCallWait[0], RT_ELEMENTS(g_aArgsVMR3ReqCallWait), REMFNDESC_FLAGS_RET_INT \| REMFNDESC_FLAGS_ELLIPSIS, sizeof(int), NULL },
1314	{ "VMR3ReqFree", VMM_FN(VMR3ReqFree), &g_aArgsVMR3ReqFree[0], RT_ELEMENTS(g_aArgsVMR3ReqFree), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1315	// { "", VMM_FN(), &g_aArgsVM[0], RT_ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1316	};
1317
1318
1319	/**
1320	* Descriptors for the functions imported from VBoxRT.
1321	*/
1322	static REMFNDESC g_aRTImports[] =
1323	{
1324	{ "RTAssertMsg1", (void *)(uintptr_t)&RTAssertMsg1, &g_aArgsRTAssertMsg1[0], RT_ELEMENTS(g_aArgsRTAssertMsg1), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1325	{ "RTAssertMsg1Weak", (void *)(uintptr_t)&RTAssertMsg1Weak, &g_aArgsRTAssertMsg1[0], RT_ELEMENTS(g_aArgsRTAssertMsg1), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1326	{ "RTAssertMsg2", (void *)(uintptr_t)&RTAssertMsg2, &g_aArgsRTAssertMsg2[0], RT_ELEMENTS(g_aArgsRTAssertMsg2), REMFNDESC_FLAGS_RET_VOID \| REMFNDESC_FLAGS_ELLIPSIS, 0, NULL },
1327	{ "RTAssertMsg2V", (void *)(uintptr_t)&RTAssertMsg2V, &g_aArgsRTAssertMsg2V[0], RT_ELEMENTS(g_aArgsRTAssertMsg2V), REMFNDESC_FLAGS_RET_VOID \| REMFNDESC_FLAGS_VALIST, 0, NULL },
1328	{ "RTAssertMsg2Weak", (void *)(uintptr_t)&RTAssertMsg2Weak, &g_aArgsRTAssertMsg2[0], RT_ELEMENTS(g_aArgsRTAssertMsg2), REMFNDESC_FLAGS_RET_VOID \| REMFNDESC_FLAGS_ELLIPSIS, 0, NULL },
1329	{ "RTAssertShouldPanic", (void *)(uintptr_t)&RTAssertShouldPanic, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1330	{ "RTLogDefaultInstance", (void *)(uintptr_t)&RTLogDefaultInstance, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(PRTLOGGER), NULL },
1331	{ "RTLogRelDefaultInstance", (void *)(uintptr_t)&RTLogRelDefaultInstance, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(PRTLOGGER), NULL },
1332	{ "RTLogFlags", (void *)(uintptr_t)&RTLogFlags, &g_aArgsRTLogFlags[0], RT_ELEMENTS(g_aArgsRTLogFlags), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1333	{ "RTLogFlush", (void *)(uintptr_t)&RTLogFlush, &g_aArgsRTLogFlush[0], RT_ELEMENTS(g_aArgsRTLogFlush), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1334	{ "RTLogLoggerEx", (void *)(uintptr_t)&RTLogLoggerEx, &g_aArgsRTLogLoggerEx[0], RT_ELEMENTS(g_aArgsRTLogLoggerEx), REMFNDESC_FLAGS_RET_VOID \| REMFNDESC_FLAGS_ELLIPSIS, 0, NULL },
1335	{ "RTLogLoggerExV", (void *)(uintptr_t)&RTLogLoggerExV, &g_aArgsRTLogLoggerExV[0], RT_ELEMENTS(g_aArgsRTLogLoggerExV), REMFNDESC_FLAGS_RET_VOID \| REMFNDESC_FLAGS_VALIST, 0, NULL },
1336	{ "RTLogPrintf", (void *)(uintptr_t)&RTLogPrintf, &g_aArgsRTLogPrintf[0], RT_ELEMENTS(g_aArgsRTLogPrintf), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1337	{ "RTLogRelPrintf", (void *)(uintptr_t)&RTLogRelPrintf, &g_aArgsRTLogPrintf[0], RT_ELEMENTS(g_aArgsRTLogPrintf), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1338	{ "RTMemAllocTag", (void )(uintptr_t)&RTMemAllocTag, &g_aArgsSIZE_TTag[0], RT_ELEMENTS(g_aArgsSIZE_TTag), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1339	{ "RTMemAllocZTag", (void )(uintptr_t)&RTMemAllocZTag, &g_aArgsSIZE_TTag[0], RT_ELEMENTS(g_aArgsSIZE_TTag), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1340	{ "RTMemReallocTag", (void )(uintptr_t)&RTMemReallocTag, &g_aArgsRTMemReallocTag[0], RT_ELEMENTS(g_aArgsRTMemReallocTag), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1341	{ "RTMemExecAllocTag", (void )(uintptr_t)&RTMemExecAllocTag, &g_aArgsSIZE_TTag[0], RT_ELEMENTS(g_aArgsSIZE_TTag), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1342	{ "RTMemExecFree", (void *)(uintptr_t)&RTMemExecFree, &g_aArgsPTR_SIZE_T[0], RT_ELEMENTS(g_aArgsPTR_SIZE_T), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1343	{ "RTMemFree", (void *)(uintptr_t)&RTMemFree, &g_aArgsPTR[0], RT_ELEMENTS(g_aArgsPTR), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1344	{ "RTMemPageAllocTag", (void )(uintptr_t)&RTMemPageAllocTag, &g_aArgsSIZE_TTag[0], RT_ELEMENTS(g_aArgsSIZE_TTag), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1345	{ "RTMemPageFree", (void *)(uintptr_t)&RTMemPageFree, &g_aArgsPTR_SIZE_T[0], RT_ELEMENTS(g_aArgsPTR_SIZE_T), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1346	{ "RTMemProtect", (void *)(uintptr_t)&RTMemProtect, &g_aArgsRTMemProtect[0], RT_ELEMENTS(g_aArgsRTMemProtect), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1347	{ "RTMemEfAlloc", (void )(uintptr_t)&RTMemEfAlloc, &g_aArgsSIZE_TTagLoc[0], RT_ELEMENTS(g_aArgsSIZE_TTagLoc), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1348	{ "RTMemEfAllocZ", (void )(uintptr_t)&RTMemEfAllocZ, &g_aArgsSIZE_TTagLoc[0], RT_ELEMENTS(g_aArgsSIZE_TTagLoc), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1349	{ "RTMemEfRealloc", (void )(uintptr_t)&RTMemEfRealloc, &g_aArgsRTMemEfRealloc[0], RT_ELEMENTS(g_aArgsRTMemEfRealloc), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1350	{ "RTMemEfFree", (void *)(uintptr_t)&RTMemEfFree, &g_aArgsPTRLoc[0], RT_ELEMENTS(g_aArgsPTRLoc), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1351	{ "RTStrPrintf", (void *)(uintptr_t)&RTStrPrintf, &g_aArgsRTStrPrintf[0], RT_ELEMENTS(g_aArgsRTStrPrintf), REMFNDESC_FLAGS_RET_INT \| REMFNDESC_FLAGS_ELLIPSIS, sizeof(size_t), NULL },
1352	{ "RTStrPrintfV", (void *)(uintptr_t)&RTStrPrintfV, &g_aArgsRTStrPrintfV[0], RT_ELEMENTS(g_aArgsRTStrPrintfV), REMFNDESC_FLAGS_RET_INT \| REMFNDESC_FLAGS_VALIST, sizeof(size_t), NULL },
1353	{ "RTThreadSelf", (void *)(uintptr_t)&RTThreadSelf, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(RTTHREAD), NULL },
1354	{ "RTThreadNativeSelf", (void *)(uintptr_t)&RTThreadNativeSelf, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(RTNATIVETHREAD), NULL },
1355	{ "RTLockValidatorWriteLockGetCount", (void *)(uintptr_t)&RTLockValidatorWriteLockGetCount, &g_aArgsThread[0], 0, REMFNDESC_FLAGS_RET_INT, sizeof(int32_t), NULL },
1356	};
1357
1358
1359	/**
1360	* Descriptors for the functions imported from VBoxRT.
1361	*/
1362	static REMFNDESC g_aCRTImports[] =
1363	{
1364	{ "memcpy", (void )(uintptr_t)&memcpy, &g_aArgsmemcpy[0], RT_ELEMENTS(g_aArgsmemcpy), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1365	{ "memset", (void )(uintptr_t)&memset, &g_aArgsmemset[0], RT_ELEMENTS(g_aArgsmemset), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL }
1366	/*
1367	floor floor
1368	memcpy memcpy
1369	sqrt sqrt
1370	sqrtf sqrtf
1371	*/
1372	};
1373
1374
1375	# if defined(USE_REM_CALLING_CONVENTION_GLUE) \|\| defined(USE_REM_IMPORT_JUMP_GLUE)
1376	/** LIFO of read-write-executable memory chunks used for wrappers. */
1377	static PREMEXECMEM g_pExecMemHead;
1378	# endif
1379	# endif /* !VBOX_USE_BITNESS_SELECTOR */
1380
1381
1382
1383	/*******************************************************************************
1384	* Internal Functions *
1385	*******************************************************************************/
1386	# ifndef VBOX_USE_BITNESS_SELECTOR
1387	static int remGenerateExportGlue(PRTUINTPTR pValue, PCREMFNDESC pDesc);
1388
1389	# ifdef USE_REM_CALLING_CONVENTION_GLUE
1390	DECLASM(int) WrapGCC2MSC0Int(void); DECLASM(int) WrapGCC2MSC0Int_EndProc(void);
1391	DECLASM(int) WrapGCC2MSC1Int(void); DECLASM(int) WrapGCC2MSC1Int_EndProc(void);
1392	DECLASM(int) WrapGCC2MSC2Int(void); DECLASM(int) WrapGCC2MSC2Int_EndProc(void);
1393	DECLASM(int) WrapGCC2MSC3Int(void); DECLASM(int) WrapGCC2MSC3Int_EndProc(void);
1394	DECLASM(int) WrapGCC2MSC4Int(void); DECLASM(int) WrapGCC2MSC4Int_EndProc(void);
1395	DECLASM(int) WrapGCC2MSC5Int(void); DECLASM(int) WrapGCC2MSC5Int_EndProc(void);
1396	DECLASM(int) WrapGCC2MSC6Int(void); DECLASM(int) WrapGCC2MSC6Int_EndProc(void);
1397	DECLASM(int) WrapGCC2MSC7Int(void); DECLASM(int) WrapGCC2MSC7Int_EndProc(void);
1398	DECLASM(int) WrapGCC2MSC8Int(void); DECLASM(int) WrapGCC2MSC8Int_EndProc(void);
1399	DECLASM(int) WrapGCC2MSC9Int(void); DECLASM(int) WrapGCC2MSC9Int_EndProc(void);
1400	DECLASM(int) WrapGCC2MSC10Int(void); DECLASM(int) WrapGCC2MSC10Int_EndProc(void);
1401	DECLASM(int) WrapGCC2MSC11Int(void); DECLASM(int) WrapGCC2MSC11Int_EndProc(void);
1402	DECLASM(int) WrapGCC2MSC12Int(void); DECLASM(int) WrapGCC2MSC12Int_EndProc(void);
1403	DECLASM(int) WrapGCC2MSCVariadictInt(void); DECLASM(int) WrapGCC2MSCVariadictInt_EndProc(void);
1404	DECLASM(int) WrapGCC2MSC_SSMR3RegisterInternal(void); DECLASM(int) WrapGCC2MSC_SSMR3RegisterInternal_EndProc(void);
1405
1406	DECLASM(int) WrapMSC2GCC0Int(void); DECLASM(int) WrapMSC2GCC0Int_EndProc(void);
1407	DECLASM(int) WrapMSC2GCC1Int(void); DECLASM(int) WrapMSC2GCC1Int_EndProc(void);
1408	DECLASM(int) WrapMSC2GCC2Int(void); DECLASM(int) WrapMSC2GCC2Int_EndProc(void);
1409	DECLASM(int) WrapMSC2GCC3Int(void); DECLASM(int) WrapMSC2GCC3Int_EndProc(void);
1410	DECLASM(int) WrapMSC2GCC4Int(void); DECLASM(int) WrapMSC2GCC4Int_EndProc(void);
1411	DECLASM(int) WrapMSC2GCC5Int(void); DECLASM(int) WrapMSC2GCC5Int_EndProc(void);
1412	DECLASM(int) WrapMSC2GCC6Int(void); DECLASM(int) WrapMSC2GCC6Int_EndProc(void);
1413	DECLASM(int) WrapMSC2GCC7Int(void); DECLASM(int) WrapMSC2GCC7Int_EndProc(void);
1414	DECLASM(int) WrapMSC2GCC8Int(void); DECLASM(int) WrapMSC2GCC8Int_EndProc(void);
1415	DECLASM(int) WrapMSC2GCC9Int(void); DECLASM(int) WrapMSC2GCC9Int_EndProc(void);
1416	# endif
1417
1418
1419	# if defined(USE_REM_CALLING_CONVENTION_GLUE) \|\| defined(USE_REM_IMPORT_JUMP_GLUE)
1420	/**
1421	* Allocates a block of memory for glue code.
1422	*
1423	* The returned memory is padded with INT3s.
1424	*
1425	* @returns Pointer to the allocated memory.
1426	* @param The amount of memory to allocate.
1427	*/
1428	static void *remAllocGlue(size_t cb)
1429	{
1430	PREMEXECMEM pCur = g_pExecMemHead;
1431	uint32_t cbAligned = (uint32_t)RT_ALIGN_32(cb, 32);
1432	while (pCur)
1433	{
1434	if (pCur->cb - pCur->off >= cbAligned)
1435	{
1436	void pv = (uint8_t )pCur + pCur->off;
1437	pCur->off += cbAligned;
1438	return memset(pv, 0xcc, cbAligned);
1439	}
1440	pCur = pCur->pNext;
1441	}
1442
1443	/* add a new chunk */
1444	AssertReturn(_64K - RT_ALIGN_Z(sizeof(*pCur), 32) > cbAligned, NULL);
1445	pCur = (PREMEXECMEM)RTMemExecAlloc(_64K);
1446	AssertReturn(pCur, NULL);
1447	pCur->cb = _64K;
1448	pCur->off = RT_ALIGN_32(sizeof(*pCur), 32) + cbAligned;
1449	pCur->pNext = g_pExecMemHead;
1450	g_pExecMemHead = pCur;
1451	return memset((uint8_t )pCur + RT_ALIGN_Z(sizeof(pCur), 32), 0xcc, cbAligned);
1452	}
1453	# endif /* USE_REM_CALLING_CONVENTION_GLUE \|\| USE_REM_IMPORT_JUMP_GLUE */
1454
1455
1456	# ifdef USE_REM_CALLING_CONVENTION_GLUE
1457	/**
1458	* Checks if a function is all straight forward integers.
1459	*
1460	* @returns True if it's simple, false if it's bothersome.
1461	* @param pDesc The function descriptor.
1462	*/
1463	static bool remIsFunctionAllInts(PCREMFNDESC pDesc)
1464	{
1465	if ( ( (pDesc->fFlags & REMFNDESC_FLAGS_RET_TYPE_MASK) != REMFNDESC_FLAGS_RET_INT
1466	\|\| pDesc->cbReturn > sizeof(uint64_t))
1467	&& (pDesc->fFlags & REMFNDESC_FLAGS_RET_TYPE_MASK) != REMFNDESC_FLAGS_RET_VOID)
1468	return false;
1469	unsigned i = pDesc->cParams;
1470	while (i-- > 0)
1471	switch (pDesc->paParams[i].fFlags & REMPARMDESC_FLAGS_TYPE_MASK)
1472	{
1473	case REMPARMDESC_FLAGS_INT:
1474	case REMPARMDESC_FLAGS_GCPTR:
1475	case REMPARMDESC_FLAGS_GCPHYS:
1476	case REMPARMDESC_FLAGS_HCPHYS:
1477	break;
1478
1479	default:
1480	AssertReleaseMsgFailed(("Invalid param flags %#x for #%d of %s!\n", pDesc->paParams[i].fFlags, i, pDesc->pszName));
1481	case REMPARMDESC_FLAGS_VALIST:
1482	case REMPARMDESC_FLAGS_ELLIPSIS:
1483	case REMPARMDESC_FLAGS_FLOAT:
1484	case REMPARMDESC_FLAGS_STRUCT:
1485	case REMPARMDESC_FLAGS_PFN:
1486	return false;
1487	}
1488	return true;
1489	}
1490
1491
1492	/**
1493	* Checks if the function has an ellipsis (...) argument.
1494	*
1495	* @returns true if it has an ellipsis, otherwise false.
1496	* @param pDesc The function descriptor.
1497	*/
1498	static bool remHasFunctionEllipsis(PCREMFNDESC pDesc)
1499	{
1500	unsigned i = pDesc->cParams;
1501	while (i-- > 0)
1502	if ((pDesc->paParams[i].fFlags & REMPARMDESC_FLAGS_TYPE_MASK) == REMPARMDESC_FLAGS_ELLIPSIS)
1503	return true;
1504	return false;
1505	}
1506
1507
1508	/**
1509	* Checks if the function uses floating point (FP) arguments or return value.
1510	*
1511	* @returns true if it uses floating point, otherwise false.
1512	* @param pDesc The function descriptor.
1513	*/
1514	static bool remIsFunctionUsingFP(PCREMFNDESC pDesc)
1515	{
1516	if ((pDesc->fFlags & REMFNDESC_FLAGS_RET_TYPE_MASK) == REMFNDESC_FLAGS_RET_FLOAT)
1517	return true;
1518	unsigned i = pDesc->cParams;
1519	while (i-- > 0)
1520	if ((pDesc->paParams[i].fFlags & REMPARMDESC_FLAGS_TYPE_MASK) == REMPARMDESC_FLAGS_FLOAT)
1521	return true;
1522	return false;
1523	}
1524
1525
1526	/** @name The export and import fixups.
1527	* @{ */
1528	# define REM_FIXUP_32_REAL_STUFF UINT32_C(0xdeadbeef)
1529	# define REM_FIXUP_64_REAL_STUFF UINT64_C(0xdeadf00df00ddead)
1530	# define REM_FIXUP_64_DESC UINT64_C(0xdead00010001dead)
1531	# define REM_FIXUP_64_LOG_ENTRY UINT64_C(0xdead00020002dead)
1532	# define REM_FIXUP_64_LOG_EXIT UINT64_C(0xdead00030003dead)
1533	# define REM_FIXUP_64_WRAP_GCC_CB UINT64_C(0xdead00040004dead)
1534	/** @} */
1535
1536
1537	/**
1538	* Entry logger function.
1539	*
1540	* @param pDesc The description.
1541	*/
1542	DECLASM(void) remLogEntry(PCREMFNDESC pDesc)
1543	{
1544	RTPrintf("calling %s\n", pDesc->pszName);
1545	}
1546
1547
1548	/**
1549	* Exit logger function.
1550	*
1551	* @param pDesc The description.
1552	* @param pvRet The return code.
1553	*/
1554	DECLASM(void) remLogExit(PCREMFNDESC pDesc, void *pvRet)
1555	{
1556	RTPrintf("returning %p from %s\n", pvRet, pDesc->pszName);
1557	}
1558
1559
1560	/**
1561	* Creates a wrapper for the specified callback function at run time.
1562	*
1563	* @param pDesc The function descriptor.
1564	* @param pValue Upon entry *pValue contains the address of the function to be wrapped.
1565	* Upon return *pValue contains the address of the wrapper glue function.
1566	* @param iParam The parameter index in the function descriptor (0 based).
1567	* If UINT32_MAX pDesc is the descriptor for *pValue.
1568	*/
1569	DECLASM(void) remWrapGCCCallback(PCREMFNDESC pDesc, PRTUINTPTR pValue, uint32_t iParam)
1570	{
1571	AssertPtr(pDesc);
1572	AssertPtr(pValue);
1573
1574	/*
1575	* Simple?
1576	*/
1577	if (!*pValue)
1578	return;
1579
1580	/*
1581	* Locate the right function descriptor.
1582	*/
1583	if (iParam != UINT32_MAX)
1584	{
1585	AssertRelease(iParam < pDesc->cParams);
1586	pDesc = (PCREMFNDESC)pDesc->paParams[iParam].pvExtra;
1587	AssertPtr(pDesc);
1588	}
1589
1590	/*
1591	* When we get serious, here is where to insert the hash table lookup.
1592	*/
1593
1594	/*
1595	* Create a new glue patch.
1596	*/
1597	# ifdef RT_OS_WINDOWS
1598	int rc = remGenerateExportGlue(pValue, pDesc);
1599	# else
1600	# error "port me"
1601	# endif
1602	AssertReleaseRC(rc);
1603
1604	/*
1605	* Add it to the hash (later)
1606	*/
1607	}
1608
1609
1610	/**
1611	* Fixes export glue.
1612	*
1613	* @param pvGlue The glue code.
1614	* @param cb The size of the glue code.
1615	* @param pvExport The address of the export we're wrapping.
1616	* @param pDesc The export descriptor.
1617	*/
1618	static void remGenerateExportGlueFixup(void *pvGlue, size_t cb, uintptr_t uExport, PCREMFNDESC pDesc)
1619	{
1620	union
1621	{
1622	uint8_t *pu8;
1623	int32_t *pi32;
1624	uint32_t *pu32;
1625	uint64_t *pu64;
1626	void *pv;
1627	} u;
1628	u.pv = pvGlue;
1629
1630	while (cb >= 4)
1631	{
1632	/** @todo add defines for the fixup constants... */
1633	if (*u.pu32 == REM_FIXUP_32_REAL_STUFF)
1634	{
1635	/* 32-bit rel jmp/call to real export. */
1636	*u.pi32 = uExport - (uintptr_t)(u.pi32 + 1);
1637	Assert((uintptr_t)(u.pi32 + 1) + *u.pi32 == uExport);
1638	u.pi32++;
1639	cb -= 4;
1640	continue;
1641	}
1642	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_REAL_STUFF)
1643	{
1644	/* 64-bit address to the real export. */
1645	*u.pu64++ = uExport;
1646	cb -= 8;
1647	continue;
1648	}
1649	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_DESC)
1650	{
1651	/* 64-bit address to the descriptor. */
1652	*u.pu64++ = (uintptr_t)pDesc;
1653	cb -= 8;
1654	continue;
1655	}
1656	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_WRAP_GCC_CB)
1657	{
1658	/* 64-bit address to the entry logger function. */
1659	*u.pu64++ = (uintptr_t)remWrapGCCCallback;
1660	cb -= 8;
1661	continue;
1662	}
1663	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_ENTRY)
1664	{
1665	/* 64-bit address to the entry logger function. */
1666	*u.pu64++ = (uintptr_t)remLogEntry;
1667	cb -= 8;
1668	continue;
1669	}
1670	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_EXIT)
1671	{
1672	/* 64-bit address to the entry logger function. */
1673	*u.pu64++ = (uintptr_t)remLogExit;
1674	cb -= 8;
1675	continue;
1676	}
1677
1678	/* move on. */
1679	u.pu8++;
1680	cb--;
1681	}
1682	}
1683
1684
1685	/**
1686	* Fixes import glue.
1687	*
1688	* @param pvGlue The glue code.
1689	* @param cb The size of the glue code.
1690	* @param pDesc The import descriptor.
1691	*/
1692	static void remGenerateImportGlueFixup(void *pvGlue, size_t cb, PCREMFNDESC pDesc)
1693	{
1694	union
1695	{
1696	uint8_t *pu8;
1697	int32_t *pi32;
1698	uint32_t *pu32;
1699	uint64_t *pu64;
1700	void *pv;
1701	} u;
1702	u.pv = pvGlue;
1703
1704	while (cb >= 4)
1705	{
1706	if (*u.pu32 == REM_FIXUP_32_REAL_STUFF)
1707	{
1708	/* 32-bit rel jmp/call to real function. */
1709	*u.pi32 = (uintptr_t)pDesc->pv - (uintptr_t)(u.pi32 + 1);
1710	Assert((uintptr_t)(u.pi32 + 1) + *u.pi32 == (uintptr_t)pDesc->pv);
1711	u.pi32++;
1712	cb -= 4;
1713	continue;
1714	}
1715	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_REAL_STUFF)
1716	{
1717	/* 64-bit address to the real function. */
1718	*u.pu64++ = (uintptr_t)pDesc->pv;
1719	cb -= 8;
1720	continue;
1721	}
1722	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_DESC)
1723	{
1724	/* 64-bit address to the descriptor. */
1725	*u.pu64++ = (uintptr_t)pDesc;
1726	cb -= 8;
1727	continue;
1728	}
1729	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_WRAP_GCC_CB)
1730	{
1731	/* 64-bit address to the entry logger function. */
1732	*u.pu64++ = (uintptr_t)remWrapGCCCallback;
1733	cb -= 8;
1734	continue;
1735	}
1736	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_ENTRY)
1737	{
1738	/* 64-bit address to the entry logger function. */
1739	*u.pu64++ = (uintptr_t)remLogEntry;
1740	cb -= 8;
1741	continue;
1742	}
1743	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_EXIT)
1744	{
1745	/* 64-bit address to the entry logger function. */
1746	*u.pu64++ = (uintptr_t)remLogExit;
1747	cb -= 8;
1748	continue;
1749	}
1750
1751	/* move on. */
1752	u.pu8++;
1753	cb--;
1754	}
1755	}
1756
1757	# endif /* USE_REM_CALLING_CONVENTION_GLUE */
1758
1759
1760	/**
1761	* Generate wrapper glue code for an export.
1762	*
1763	* This is only used on win64 when loading a 64-bit linux module. So, on other
1764	* platforms it will not do anything.
1765	*
1766	* @returns VBox status code.
1767	* @param pValue IN: Where to get the address of the function to wrap.
1768	* OUT: Where to store the glue address.
1769	* @param pDesc The export descriptor.
1770	*/
1771	static int remGenerateExportGlue(PRTUINTPTR pValue, PCREMFNDESC pDesc)
1772	{
1773	# ifdef USE_REM_CALLING_CONVENTION_GLUE
1774	uintptr_t ppfn = (uintptr_t )pDesc->pv;
1775
1776	uintptr_t pfn = 0; /* a little hack for the callback glue */
1777	if (!ppfn)
1778	ppfn = &pfn;
1779
1780	if (!*ppfn)
1781	{
1782	if (remIsFunctionAllInts(pDesc))
1783	{
1784	static const struct { void pvStart, pvEnd; } s_aTemplates[] =
1785	{
1786	{ (void )&WrapMSC2GCC0Int, (void )&WrapMSC2GCC0Int_EndProc },
1787	{ (void )&WrapMSC2GCC1Int, (void )&WrapMSC2GCC1Int_EndProc },
1788	{ (void )&WrapMSC2GCC2Int, (void )&WrapMSC2GCC2Int_EndProc },
1789	{ (void )&WrapMSC2GCC3Int, (void )&WrapMSC2GCC3Int_EndProc },
1790	{ (void )&WrapMSC2GCC4Int, (void )&WrapMSC2GCC4Int_EndProc },
1791	{ (void )&WrapMSC2GCC5Int, (void )&WrapMSC2GCC5Int_EndProc },
1792	{ (void )&WrapMSC2GCC6Int, (void )&WrapMSC2GCC6Int_EndProc },
1793	{ (void )&WrapMSC2GCC7Int, (void )&WrapMSC2GCC7Int_EndProc },
1794	{ (void )&WrapMSC2GCC8Int, (void )&WrapMSC2GCC8Int_EndProc },
1795	{ (void )&WrapMSC2GCC9Int, (void )&WrapMSC2GCC9Int_EndProc },
1796	};
1797	const unsigned i = pDesc->cParams;
1798	AssertReleaseMsg(i < RT_ELEMENTS(s_aTemplates), ("%d (%s)\n", i, pDesc->pszName));
1799
1800	/* duplicate the patch. */
1801	const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
1802	uint8_t pb = (uint8_t )remAllocGlue(cb);
1803	AssertReturn(pb, VERR_NO_MEMORY);
1804	memcpy(pb, s_aTemplates[i].pvStart, cb);
1805
1806	/* fix it up. */
1807	remGenerateExportGlueFixup(pb, cb, *pValue, pDesc);
1808	*ppfn = (uintptr_t)pb;
1809	}
1810	else
1811	{
1812	/* custom hacks - it's simpler to make assembly templates than writing a more generic code generator... */
1813	static const struct { const char *pszName; PFNRT pvStart, pvEnd; } s_aTemplates[] =
1814	{
1815	{ "somefunction", (PFNRT)&WrapMSC2GCC9Int, (PFNRT)&WrapMSC2GCC9Int_EndProc },
1816	};
1817	unsigned i;
1818	for (i = 0; i < RT_ELEMENTS(s_aTemplates); i++)
1819	if (!strcmp(pDesc->pszName, s_aTemplates[i].pszName))
1820	break;
1821	AssertReleaseMsgReturn(i < RT_ELEMENTS(s_aTemplates), ("Not implemented! %s\n", pDesc->pszName), VERR_NOT_IMPLEMENTED);
1822
1823	/* duplicate the patch. */
1824	const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
1825	uint8_t pb = (uint8_t )remAllocGlue(cb);
1826	AssertReturn(pb, VERR_NO_MEMORY);
1827	memcpy(pb, s_aTemplates[i].pvStart, cb);
1828
1829	/* fix it up. */
1830	remGenerateExportGlueFixup(pb, cb, *pValue, pDesc);
1831	*ppfn = (uintptr_t)pb;
1832	}
1833	}
1834	pValue = ppfn;
1835	return VINF_SUCCESS;
1836	# else /* !USE_REM_CALLING_CONVENTION_GLUE */
1837	return VINF_SUCCESS;
1838	# endif /* !USE_REM_CALLING_CONVENTION_GLUE */
1839	}
1840
1841
1842	/**
1843	* Generate wrapper glue code for an import.
1844	*
1845	* This is only used on win64 when loading a 64-bit linux module. So, on other
1846	* platforms it will simply return the address of the imported function
1847	* without generating any glue code.
1848	*
1849	* @returns VBox status code.
1850	* @param pValue Where to store the glue address.
1851	* @param pDesc The export descriptor.
1852	*/
1853	static int remGenerateImportGlue(PRTUINTPTR pValue, PREMFNDESC pDesc)
1854	{
1855	# if defined(USE_REM_CALLING_CONVENTION_GLUE) \|\| defined(USE_REM_IMPORT_JUMP_GLUE)
1856	if (!pDesc->pvWrapper)
1857	{
1858	# ifdef USE_REM_CALLING_CONVENTION_GLUE
1859	if (remIsFunctionAllInts(pDesc))
1860	{
1861	static const struct { void pvStart, pvEnd; } s_aTemplates[] =
1862	{
1863	{ (void )&WrapGCC2MSC0Int, (void )&WrapGCC2MSC0Int_EndProc },
1864	{ (void )&WrapGCC2MSC1Int, (void )&WrapGCC2MSC1Int_EndProc },
1865	{ (void )&WrapGCC2MSC2Int, (void )&WrapGCC2MSC2Int_EndProc },
1866	{ (void )&WrapGCC2MSC3Int, (void )&WrapGCC2MSC3Int_EndProc },
1867	{ (void )&WrapGCC2MSC4Int, (void )&WrapGCC2MSC4Int_EndProc },
1868	{ (void )&WrapGCC2MSC5Int, (void )&WrapGCC2MSC5Int_EndProc },
1869	{ (void )&WrapGCC2MSC6Int, (void )&WrapGCC2MSC6Int_EndProc },
1870	{ (void )&WrapGCC2MSC7Int, (void )&WrapGCC2MSC7Int_EndProc },
1871	{ (void )&WrapGCC2MSC8Int, (void )&WrapGCC2MSC8Int_EndProc },
1872	{ (void )&WrapGCC2MSC9Int, (void )&WrapGCC2MSC9Int_EndProc },
1873	{ (void )&WrapGCC2MSC10Int, (void )&WrapGCC2MSC10Int_EndProc },
1874	{ (void )&WrapGCC2MSC11Int, (void )&WrapGCC2MSC11Int_EndProc },
1875	{ (void )&WrapGCC2MSC12Int, (void )&WrapGCC2MSC12Int_EndProc }
1876	};
1877	const unsigned i = pDesc->cParams;
1878	AssertReleaseMsg(i < RT_ELEMENTS(s_aTemplates), ("%d (%s)\n", i, pDesc->pszName));
1879
1880	/* duplicate the patch. */
1881	const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
1882	pDesc->pvWrapper = remAllocGlue(cb);
1883	AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
1884	memcpy(pDesc->pvWrapper, s_aTemplates[i].pvStart, cb);
1885
1886	/* fix it up. */
1887	remGenerateImportGlueFixup((uint8_t *)pDesc->pvWrapper, cb, pDesc);
1888	}
1889	else if ( remHasFunctionEllipsis(pDesc)
1890	&& !remIsFunctionUsingFP(pDesc))
1891	{
1892	/* duplicate the patch. */
1893	const size_t cb = (uintptr_t)&WrapGCC2MSCVariadictInt_EndProc - (uintptr_t)&WrapGCC2MSCVariadictInt;
1894	pDesc->pvWrapper = remAllocGlue(cb);
1895	AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
1896	memcpy(pDesc->pvWrapper, (void *)&WrapGCC2MSCVariadictInt, cb);
1897
1898	/* fix it up. */
1899	remGenerateImportGlueFixup((uint8_t *)pDesc->pvWrapper, cb, pDesc);
1900	}
1901	else
1902	{
1903	/* custom hacks - it's simpler to make assembly templates than writing a more generic code generator... */
1904	static const struct { const char *pszName; PFNRT pvStart, pvEnd; } s_aTemplates[] =
1905	{
1906	{ "SSMR3RegisterInternal", (PFNRT)&WrapGCC2MSC_SSMR3RegisterInternal, (PFNRT)&WrapGCC2MSC_SSMR3RegisterInternal_EndProc },
1907	};
1908	unsigned i;
1909	for (i = 0; i < RT_ELEMENTS(s_aTemplates); i++)
1910	if (!strcmp(pDesc->pszName, s_aTemplates[i].pszName))
1911	break;
1912	AssertReleaseMsgReturn(i < RT_ELEMENTS(s_aTemplates), ("Not implemented! %s\n", pDesc->pszName), VERR_NOT_IMPLEMENTED);
1913
1914	/* duplicate the patch. */
1915	const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
1916	pDesc->pvWrapper = remAllocGlue(cb);
1917	AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
1918	memcpy(pDesc->pvWrapper, s_aTemplates[i].pvStart, cb);
1919
1920	/* fix it up. */
1921	remGenerateImportGlueFixup((uint8_t *)pDesc->pvWrapper, cb, pDesc);
1922	}
1923	# else /* !USE_REM_CALLING_CONVENTION_GLUE */
1924
1925	/*
1926	* Generate a jump patch.
1927	*/
1928	uint8_t *pb;
1929	# ifdef RT_ARCH_AMD64
1930	pDesc->pvWrapper = pb = (uint8_t *)remAllocGlue(32);
1931	AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
1932	/*pb++ = 0xcc;/
1933	*pb++ = 0xff;
1934	*pb++ = 0x24;
1935	*pb++ = 0x25;
1936	(uint32_t )pb = (uintptr_t)pb + 5;
1937	pb += 5;
1938	(uint64_t )pb = (uint64_t)pDesc->pv;
1939	# else
1940	pDesc->pvWrapper = pb = (uint8_t *)remAllocGlue(8);
1941	AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
1942	*pb++ = 0xea;
1943	(uint32_t )pb = (uint32_t)pDesc->pv;
1944	# endif
1945	# endif /* !USE_REM_CALLING_CONVENTION_GLUE */
1946	}
1947	*pValue = (uintptr_t)pDesc->pvWrapper;
1948	# else /* !USE_REM_CALLING_CONVENTION_GLUE */
1949	*pValue = (uintptr_t)pDesc->pv;
1950	# endif /* !USE_REM_CALLING_CONVENTION_GLUE */
1951	return VINF_SUCCESS;
1952	}
1953
1954
1955	/**
1956	* Resolve an external symbol during RTLdrGetBits().
1957	*
1958	* @returns iprt status code.
1959	* @param hLdrMod The loader module handle.
1960	* @param pszModule Module name.
1961	* @param pszSymbol Symbol name, NULL if uSymbol should be used.
1962	* @param uSymbol Symbol ordinal, ~0 if pszSymbol should be used.
1963	* @param pValue Where to store the symbol value (address).
1964	* @param pvUser User argument.
1965	*/
1966	static DECLCALLBACK(int) remGetImport(RTLDRMOD hLdrMod, const char pszModule, const char pszSymbol, unsigned uSymbol, RTUINTPTR pValue, void pvUser)
1967	{
1968	unsigned i;
1969	for (i = 0; i < RT_ELEMENTS(g_aVMMImports); i++)
1970	if (!strcmp(g_aVMMImports[i].pszName, pszSymbol))
1971	return remGenerateImportGlue(pValue, &g_aVMMImports[i]);
1972	for (i = 0; i < RT_ELEMENTS(g_aRTImports); i++)
1973	if (!strcmp(g_aRTImports[i].pszName, pszSymbol))
1974	return remGenerateImportGlue(pValue, &g_aRTImports[i]);
1975	for (i = 0; i < RT_ELEMENTS(g_aCRTImports); i++)
1976	if (!strcmp(g_aCRTImports[i].pszName, pszSymbol))
1977	return remGenerateImportGlue(pValue, &g_aCRTImports[i]);
1978	LogRel(("Missing REM Import: %s\n", pszSymbol));
1979	# if 1
1980	*pValue = 0;
1981	AssertMsgFailed(("%s.%s\n", pszModule, pszSymbol));
1982	return VERR_SYMBOL_NOT_FOUND;
1983	# else
1984	return remGenerateImportGlue(pValue, &g_aCRTImports[0]);
1985	# endif
1986	}
1987
1988	/**
1989	* Loads the linux object, resolves all imports and exports.
1990	*
1991	* @returns VBox status code.
1992	*/
1993	static int remLoadLinuxObj(void)
1994	{
1995	size_t offFilename;
1996	char szPath[RTPATH_MAX];
1997	int rc = RTPathAppPrivateArch(szPath, sizeof(szPath) - 32);
1998	AssertRCReturn(rc, rc);
1999	offFilename = strlen(szPath);
2000
2001	# ifdef VBOX_WITHOUT_REM_LDR_CYCLE
2002	/*
2003	* Resolve all the VBoxVMM references.
2004	*/
2005	if (g_ModVMM != NIL_RTLDRMOD)
2006	{
2007	rc = SUPR3HardenedLdrLoadAppPriv("VBoxVMM", &g_ModVMM, RTLDRLOAD_FLAGS_LOCAL, NULL);
2008	AssertRCReturn(rc, rc);
2009	for (size_t i = 0; i < RT_ELEMENTS(g_aVMMImports); i++)
2010	{
2011	rc = RTLdrGetSymbol(g_ModVMM, g_aVMMImports[i].pszName, &g_aVMMImports[i].pv);
2012	AssertLogRelMsgRCReturn(rc, ("RTLdrGetSymbol(VBoxVMM,%s,) -> %Rrc\n", g_aVMMImports[i].pszName, rc), rc);
2013	}
2014	}
2015	# endif
2016
2017	/*
2018	* Load the VBoxREM2.rel object/DLL.
2019	*/
2020	strcpy(&szPath[offFilename], "/VBoxREM2.rel");
2021	rc = RTLdrOpen(szPath, 0, RTLDRARCH_HOST, &g_ModREM2);
2022	if (RT_SUCCESS(rc))
2023	{
2024	g_cbREM2 = RTLdrSize(g_ModREM2);
2025	g_pvREM2 = RTMemExecAlloc(g_cbREM2);
2026	if (g_pvREM2)
2027	{
2028	RTPathChangeToUnixSlashes(szPath, true);
2029	# ifdef DEBUG /* How to load the VBoxREM2.rel symbols into the GNU debugger. */
2030	RTPrintf("VBoxREMWrapper: (gdb) add-symbol-file %s 0x%p\n", szPath, g_pvREM2);
2031	# endif
2032	LogRel(("REM: Loading %s at 0x%p (%d bytes)\n"
2033	"REM: (gdb) add-symbol-file %s 0x%p\n",
2034	szPath, g_pvREM2, RTLdrSize(g_ModREM2), szPath, g_pvREM2));
2035	rc = RTLdrGetBits(g_ModREM2, g_pvREM2, (RTUINTPTR)g_pvREM2, remGetImport, NULL);
2036	if (RT_SUCCESS(rc))
2037	{
2038	/*
2039	* Resolve exports.
2040	*/
2041	unsigned i;
2042	for (i = 0; i < RT_ELEMENTS(g_aExports); i++)
2043	{
2044	RTUINTPTR Value;
2045	rc = RTLdrGetSymbolEx(g_ModREM2, g_pvREM2, (RTUINTPTR)g_pvREM2, g_aExports[i].pszName, &Value);
2046	AssertMsgRC(rc, ("%s rc=%Rrc\n", g_aExports[i].pszName, rc));
2047	if (RT_FAILURE(rc))
2048	break;
2049	rc = remGenerateExportGlue(&Value, &g_aExports[i]);
2050	if (RT_FAILURE(rc))
2051	break;
2052	(void )g_aExports[i].pv = (void )(uintptr_t)Value;
2053	}
2054	return rc;
2055	}
2056
2057	RTMemExecFree(g_pvREM2, g_cbREM2);
2058	g_pvREM2 = NULL;
2059	}
2060	g_cbREM2 = 0;
2061	RTLdrClose(g_ModREM2);
2062	g_ModREM2 = NIL_RTLDRMOD;
2063	}
2064	LogRel(("REM: failed loading '%s', rc=%Rrc\n", szPath, rc));
2065	return rc;
2066	}
2067
2068
2069	/**
2070	* Unloads the linux object, freeing up all resources (dlls and
2071	* import glue) we allocated during remLoadLinuxObj().
2072	*/
2073	static void remUnloadLinuxObj(void)
2074	{
2075	unsigned i;
2076
2077	/* close modules. */
2078	RTLdrClose(g_ModREM2);
2079	g_ModREM2 = NIL_RTLDRMOD;
2080	RTMemExecFree(g_pvREM2, g_cbREM2);
2081	g_pvREM2 = NULL;
2082	g_cbREM2 = 0;
2083
2084	/* clear the pointers. */
2085	for (i = 0; i < RT_ELEMENTS(g_aExports); i++)
2086	(void *)g_aExports[i].pv = NULL;
2087	# if defined(USE_REM_CALLING_CONVENTION_GLUE) \|\| defined(USE_REM_IMPORT_JUMP_GLUE)
2088	for (i = 0; i < RT_ELEMENTS(g_aVMMImports); i++)
2089	g_aVMMImports[i].pvWrapper = NULL;
2090	for (i = 0; i < RT_ELEMENTS(g_aRTImports); i++)
2091	g_aRTImports[i].pvWrapper = NULL;
2092	for (i = 0; i < RT_ELEMENTS(g_aCRTImports); i++)
2093	g_aCRTImports[i].pvWrapper = NULL;
2094
2095	/* free wrapper memory. */
2096	while (g_pExecMemHead)
2097	{
2098	PREMEXECMEM pCur = g_pExecMemHead;
2099	g_pExecMemHead = pCur->pNext;
2100	memset(pCur, 0xcc, pCur->cb);
2101	RTMemExecFree(pCur, pCur->cb);
2102	}
2103	# endif
2104	}
2105
2106	# else /* VBOX_USE_BITNESS_SELECTOR */
2107
2108	/**
2109	* Checks if 64-bit support is enabled.
2110	*
2111	* @returns true / false.
2112	* @param pVM Pointer to the shared VM structure.
2113	*/
2114	static bool remIs64bitEnabled(PVM pVM)
2115	{
2116	bool f;
2117	int rc;
2118
2119	# ifdef VBOX_WITHOUT_REM_LDR_CYCLE
2120	if (g_ModVMM == NIL_RTLDRMOD)
2121	{
2122	rc = SUPR3HardenedLdrLoadAppPriv("VBoxVMM", &g_ModVMM, RTLDRLOAD_FLAGS_LOCAL, NULL);
2123	AssertRCReturn(rc, false);
2124	}
2125
2126	DECLCALLBACKMEMBER(PCFGMNODE, pfnCFGMR3GetRoot)(PVM);
2127	rc = RTLdrGetSymbol(g_ModVMM, "CFGMR3GetRoot", (void **)&pfnCFGMR3GetRoot);
2128	AssertRCReturn(rc, false);
2129
2130	DECLCALLBACKMEMBER(PCFGMNODE, pfnCFGMR3GetChild)(PCFGMNODE, const char *);
2131	rc = RTLdrGetSymbol(g_ModVMM, "CFGMR3GetChild", (void **)&pfnCFGMR3GetChild);
2132	AssertRCReturn(rc, false);
2133
2134	DECLCALLBACKMEMBER(int, pfnCFGMR3QueryBoolDef)(PCFGMNODE, const char , bool , bool);
2135	rc = RTLdrGetSymbol(g_ModVMM, "CFGMR3QueryBoolDef", (void **)&pfnCFGMR3QueryBoolDef);
2136	AssertRCReturn(rc, false);
2137
2138	rc = pfnCFGMR3QueryBoolDef(pfnCFGMR3GetChild(pfnCFGMR3GetRoot(pVM), "REM"), "64bitEnabled", &f, false);
2139	# else
2140	rc = CFGMR3QueryBoolDef(CFGMR3GetChild(CFGMR3GetRoot(pVM), "REM"), "64bitEnabled", &f, false);
2141	# endif
2142	AssertRCReturn(rc, false);
2143	return f;
2144	}
2145
2146
2147	/**
2148	* Loads real REM object, resolves all exports (imports are done by native loader).
2149	*
2150	* @returns VBox status code.
2151	*/
2152	static int remLoadProperObj(PVM pVM)
2153	{
2154	/*
2155	* Load the VBoxREM32/64 object/DLL.
2156	*/
2157	const char *pszModule = remIs64bitEnabled(pVM) ? "VBoxREM64" : "VBoxREM32";
2158	int rc = SUPR3HardenedLdrLoadAppPriv(pszModule, &g_ModREM2, RTLDRLOAD_FLAGS_LOCAL, NULL);
2159	if (RT_SUCCESS(rc))
2160	{
2161	LogRel(("REM: %s\n", pszModule));
2162
2163	/*
2164	* Resolve exports.
2165	*/
2166	unsigned i;
2167	for (i = 0; i < RT_ELEMENTS(g_aExports); i++)
2168	{
2169	void *pvValue;
2170	rc = RTLdrGetSymbol(g_ModREM2, g_aExports[i].pszName, &pvValue);
2171	AssertLogRelMsgRCBreak(rc, ("%s rc=%Rrc\n", g_aExports[i].pszName, rc));
2172	(void *)g_aExports[i].pv = pvValue;
2173	}
2174	}
2175
2176	return rc;
2177	}
2178
2179
2180	/**
2181	* Unloads the real REM object.
2182	*/
2183	static void remUnloadProperObj(void)
2184	{
2185	/* close module. */
2186	RTLdrClose(g_ModREM2);
2187	g_ModREM2 = NIL_RTLDRMOD;
2188	}
2189
2190	# endif /* VBOX_USE_BITNESS_SELECTOR */
2191	#endif /* USE_REM_STUBS */
2192
2193	REMR3DECL(int) REMR3Init(PVM pVM)
2194	{
2195	#ifdef USE_REM_STUBS
2196	return VINF_SUCCESS;
2197
2198	#elif defined(VBOX_USE_BITNESS_SELECTOR)
2199	if (!pfnREMR3Init)
2200	{
2201	int rc = remLoadProperObj(pVM);
2202	if (RT_FAILURE(rc))
2203	return rc;
2204	}
2205	return pfnREMR3Init(pVM);
2206
2207	#else
2208	if (!pfnREMR3Init)
2209	{
2210	int rc = remLoadLinuxObj();
2211	if (RT_FAILURE(rc))
2212	return rc;
2213	}
2214	return pfnREMR3Init(pVM);
2215	#endif
2216	}
2217
2218	REMR3DECL(int) REMR3InitFinalize(PVM pVM)
2219	{
2220	#ifndef USE_REM_STUBS
2221	Assert(VALID_PTR(pfnREMR3InitFinalize));
2222	return pfnREMR3InitFinalize(pVM);
2223	#endif
2224	}
2225
2226	REMR3DECL(int) REMR3Term(PVM pVM)
2227	{
2228	#ifdef USE_REM_STUBS
2229	return VINF_SUCCESS;
2230
2231	#elif defined(VBOX_USE_BITNESS_SELECTOR)
2232	int rc;
2233	Assert(VALID_PTR(pfnREMR3Term));
2234	rc = pfnREMR3Term(pVM);
2235	remUnloadProperObj();
2236	return rc;
2237
2238	#else
2239	int rc;
2240	Assert(VALID_PTR(pfnREMR3Term));
2241	rc = pfnREMR3Term(pVM);
2242	remUnloadLinuxObj();
2243	return rc;
2244	#endif
2245	}
2246
2247	REMR3DECL(void) REMR3Reset(PVM pVM)
2248	{
2249	#ifndef USE_REM_STUBS
2250	Assert(VALID_PTR(pfnREMR3Reset));
2251	pfnREMR3Reset(pVM);
2252	#endif
2253	}
2254
2255	REMR3DECL(int) REMR3Step(PVM pVM, PVMCPU pVCpu)
2256	{
2257	#ifdef USE_REM_STUBS
2258	return VERR_NOT_IMPLEMENTED;
2259	#else
2260	Assert(VALID_PTR(pfnREMR3Step));
2261	return pfnREMR3Step(pVM, pVCpu);
2262	#endif
2263	}
2264
2265	REMR3DECL(int) REMR3BreakpointSet(PVM pVM, RTGCUINTPTR Address)
2266	{
2267	#ifdef USE_REM_STUBS
2268	return VERR_REM_NO_MORE_BP_SLOTS;
2269	#else
2270	Assert(VALID_PTR(pfnREMR3BreakpointSet));
2271	return pfnREMR3BreakpointSet(pVM, Address);
2272	#endif
2273	}
2274
2275	REMR3DECL(int) REMR3BreakpointClear(PVM pVM, RTGCUINTPTR Address)
2276	{
2277	#ifdef USE_REM_STUBS
2278	return VERR_NOT_IMPLEMENTED;
2279	#else
2280	Assert(VALID_PTR(pfnREMR3BreakpointClear));
2281	return pfnREMR3BreakpointClear(pVM, Address);
2282	#endif
2283	}
2284
2285	REMR3DECL(int) REMR3EmulateInstruction(PVM pVM, PVMCPU pVCpu)
2286	{
2287	#ifdef USE_REM_STUBS
2288	return VERR_NOT_IMPLEMENTED;
2289	#else
2290	Assert(VALID_PTR(pfnREMR3EmulateInstruction));
2291	return pfnREMR3EmulateInstruction(pVM, pVCpu);
2292	#endif
2293	}
2294
2295	REMR3DECL(int) REMR3Run(PVM pVM, PVMCPU pVCpu)
2296	{
2297	#ifdef USE_REM_STUBS
2298	return VERR_NOT_IMPLEMENTED;
2299	#else
2300	Assert(VALID_PTR(pfnREMR3Run));
2301	return pfnREMR3Run(pVM, pVCpu);
2302	#endif
2303	}
2304
2305	REMR3DECL(int) REMR3State(PVM pVM, PVMCPU pVCpu)
2306	{
2307	#ifdef USE_REM_STUBS
2308	return VERR_NOT_IMPLEMENTED;
2309	#else
2310	Assert(VALID_PTR(pfnREMR3State));
2311	return pfnREMR3State(pVM, pVCpu);
2312	#endif
2313	}
2314
2315	REMR3DECL(int) REMR3StateBack(PVM pVM, PVMCPU pVCpu)
2316	{
2317	#ifdef USE_REM_STUBS
2318	return VERR_NOT_IMPLEMENTED;
2319	#else
2320	Assert(VALID_PTR(pfnREMR3StateBack));
2321	return pfnREMR3StateBack(pVM, pVCpu);
2322	#endif
2323	}
2324
2325	REMR3DECL(void) REMR3StateUpdate(PVM pVM, PVMCPU pVCpu)
2326	{
2327	#ifndef USE_REM_STUBS
2328	Assert(VALID_PTR(pfnREMR3StateUpdate));
2329	pfnREMR3StateUpdate(pVM, pVCpu);
2330	#endif
2331	}
2332
2333	REMR3DECL(void) REMR3A20Set(PVM pVM, PVMCPU pVCpu, bool fEnable)
2334	{
2335	#ifndef USE_REM_STUBS
2336	Assert(VALID_PTR(pfnREMR3A20Set));
2337	pfnREMR3A20Set(pVM, pVCpu, fEnable);
2338	#endif
2339	}
2340
2341	REMR3DECL(void) REMR3ReplayHandlerNotifications(PVM pVM)
2342	{
2343	#ifndef USE_REM_STUBS
2344	Assert(VALID_PTR(pfnREMR3ReplayHandlerNotifications));
2345	pfnREMR3ReplayHandlerNotifications(pVM);
2346	#endif
2347	}
2348
2349	REMR3DECL(int) REMR3NotifyCodePageChanged(PVM pVM, PVMCPU pVCpu, RTGCPTR pvCodePage)
2350	{
2351	#ifdef USE_REM_STUBS
2352	return VINF_SUCCESS;
2353	#else
2354	Assert(VALID_PTR(pfnREMR3NotifyCodePageChanged));
2355	return pfnREMR3NotifyCodePageChanged(pVM, pVCpu, pvCodePage);
2356	#endif
2357	}
2358
2359	REMR3DECL(void) REMR3NotifyPhysRamRegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, unsigned fFlags)
2360	{
2361	#ifndef USE_REM_STUBS
2362	Assert(VALID_PTR(pfnREMR3NotifyPhysRamRegister));
2363	pfnREMR3NotifyPhysRamRegister(pVM, GCPhys, cb, fFlags);
2364	#endif
2365	}
2366
2367	REMR3DECL(void) REMR3NotifyPhysRomRegister(PVM pVM, RTGCPHYS GCPhys, RTUINT cb, void *pvCopy, bool fShadow)
2368	{
2369	#ifndef USE_REM_STUBS
2370	Assert(VALID_PTR(pfnREMR3NotifyPhysRomRegister));
2371	pfnREMR3NotifyPhysRomRegister(pVM, GCPhys, cb, pvCopy, fShadow);
2372	#endif
2373	}
2374
2375	REMR3DECL(void) REMR3NotifyPhysRamDeregister(PVM pVM, RTGCPHYS GCPhys, RTUINT cb)
2376	{
2377	#ifndef USE_REM_STUBS
2378	Assert(VALID_PTR(pfnREMR3NotifyPhysRamDeregister));
2379	pfnREMR3NotifyPhysRamDeregister(pVM, GCPhys, cb);
2380	#endif
2381	}
2382
2383	REMR3DECL(void) REMR3NotifyHandlerPhysicalRegister(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler)
2384	{
2385	#ifndef USE_REM_STUBS
2386	Assert(VALID_PTR(pfnREMR3NotifyHandlerPhysicalRegister));
2387	pfnREMR3NotifyHandlerPhysicalRegister(pVM, enmType, GCPhys, cb, fHasHCHandler);
2388	#endif
2389	}
2390
2391	REMR3DECL(void) REMR3NotifyHandlerPhysicalDeregister(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler, bool fRestoreAsRAM)
2392	{
2393	#ifndef USE_REM_STUBS
2394	Assert(VALID_PTR(pfnREMR3NotifyHandlerPhysicalDeregister));
2395	pfnREMR3NotifyHandlerPhysicalDeregister(pVM, enmType, GCPhys, cb, fHasHCHandler, fRestoreAsRAM);
2396	#endif
2397	}
2398
2399	REMR3DECL(void) REMR3NotifyHandlerPhysicalModify(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhysOld, RTGCPHYS GCPhysNew, RTGCPHYS cb, bool fHasHCHandler, bool fRestoreAsRAM)
2400	{
2401	#ifndef USE_REM_STUBS
2402	Assert(VALID_PTR(pfnREMR3NotifyHandlerPhysicalModify));
2403	pfnREMR3NotifyHandlerPhysicalModify(pVM, enmType, GCPhysOld, GCPhysNew, cb, fHasHCHandler, fRestoreAsRAM);
2404	#endif
2405	}
2406
2407	REMR3DECL(bool) REMR3IsPageAccessHandled(PVM pVM, RTGCPHYS GCPhys)
2408	{
2409	#ifdef USE_REM_STUBS
2410	return false;
2411	#else
2412	Assert(VALID_PTR(pfnREMR3IsPageAccessHandled));
2413	return pfnREMR3IsPageAccessHandled(pVM, GCPhys);
2414	#endif
2415	}
2416
2417	REMR3DECL(int) REMR3DisasEnableStepping(PVM pVM, bool fEnable)
2418	{
2419	#ifdef USE_REM_STUBS
2420	return VERR_NOT_IMPLEMENTED;
2421	#else
2422	Assert(VALID_PTR(pfnREMR3DisasEnableStepping));
2423	return pfnREMR3DisasEnableStepping(pVM, fEnable);
2424	#endif
2425	}
2426
2427	REMR3DECL(void) REMR3NotifyPendingInterrupt(PVM pVM, PVMCPU pVCpu, uint8_t u8Interrupt)
2428	{
2429	#ifndef USE_REM_STUBS
2430	Assert(VALID_PTR(pfnREMR3NotifyPendingInterrupt));
2431	pfnREMR3NotifyPendingInterrupt(pVM, pVCpu, u8Interrupt);
2432	#endif
2433	}
2434
2435	REMR3DECL(uint32_t) REMR3QueryPendingInterrupt(PVM pVM, PVMCPU pVCpu)
2436	{
2437	#ifdef USE_REM_STUBS
2438	return REM_NO_PENDING_IRQ;
2439	#else
2440	Assert(VALID_PTR(pfnREMR3QueryPendingInterrupt));
2441	return pfnREMR3QueryPendingInterrupt(pVM, pVCpu);
2442	#endif
2443	}
2444
2445	REMR3DECL(void) REMR3NotifyInterruptSet(PVM pVM, PVMCPU pVCpu)
2446	{
2447	#ifndef USE_REM_STUBS
2448	Assert(VALID_PTR(pfnREMR3NotifyInterruptSet));
2449	pfnREMR3NotifyInterruptSet(pVM, pVCpu);
2450	#endif
2451	}
2452
2453	REMR3DECL(void) REMR3NotifyInterruptClear(PVM pVM, PVMCPU pVCpu)
2454	{
2455	#ifndef USE_REM_STUBS
2456	Assert(VALID_PTR(pfnREMR3NotifyInterruptClear));
2457	pfnREMR3NotifyInterruptClear(pVM, pVCpu);
2458	#endif
2459	}
2460
2461	REMR3DECL(void) REMR3NotifyTimerPending(PVM pVM, PVMCPU pVCpuDst)
2462	{
2463	#ifndef USE_REM_STUBS
2464	Assert(VALID_PTR(pfnREMR3NotifyTimerPending));
2465	pfnREMR3NotifyTimerPending(pVM, pVCpuDst);
2466	#endif
2467	}
2468
2469	REMR3DECL(void) REMR3NotifyDmaPending(PVM pVM)
2470	{
2471	#ifndef USE_REM_STUBS
2472	Assert(VALID_PTR(pfnREMR3NotifyDmaPending));
2473	pfnREMR3NotifyDmaPending(pVM);
2474	#endif
2475	}
2476
2477	REMR3DECL(void) REMR3NotifyQueuePending(PVM pVM)
2478	{
2479	#ifndef USE_REM_STUBS
2480	Assert(VALID_PTR(pfnREMR3NotifyQueuePending));
2481	pfnREMR3NotifyQueuePending(pVM);
2482	#endif
2483	}
2484
2485	REMR3DECL(void) REMR3NotifyFF(PVM pVM)
2486	{
2487	#ifndef USE_REM_STUBS
2488	/* the timer can call this early on, so don't be picky. */
2489	if (pfnREMR3NotifyFF)
2490	pfnREMR3NotifyFF(pVM);
2491	#endif
2492	}

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

source: vbox/trunk/src/recompiler/VBoxREMWrapper.cpp@ 51941

Download in other formats: