VBoxREMWrapper.cpp@ 4337

Last change on this file since 4337 was 4071, checked in by vboxsync, 17 years ago
Biggest check-in ever. New source code headers for all (C) innotek files.
Property svn:keywords set to `Id`
File size: 105.8 KB

Line
1	/* $Id: VBoxREMWrapper.cpp 4071 2007-08-07 17:07:59Z vboxsync $ */
2	/** @file
3	*
4	* VBoxREM Win64 DLL Wrapper.
5	*/
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* 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 comming 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	* %rax temporary register; with variable arguments passes information about the
68	* number of SSE registers used; 1st return register.
69	* [Not preserved]
70	* %rbx callee-saved register; optionally used as base pointer.
71	* [Preserved]
72	* %rcx used to pass 4th integer argument to functions.
73	* [Not preserved]
74	* %rdx used to pass 3rd argument to functions; 2nd return register
75	* [Not preserved]
76	* %rsp stack pointer
77	* [Preserved]
78	* %rbp callee-saved register; optionally used as frame pointer
79	* [Preserved]
80	* %rsi used to pass 2nd argument to functions
81	* [Not preserved]
82	* %rdi used to pass 1st argument to functions
83	* [Not preserved]
84	* %r8 used to pass 5th argument to functions
85	* [Not preserved]
86	* %r9 used to pass 6th argument to functions
87	* [Not preserved]
88	* %r10 temporary register, used for passing a functions static chain pointer
89	* [Not preserved]
90	* %r11 temporary register
91	* [Not preserved]
92	* %r12-r15 callee-saved registers
93	* [Preserved]
94	* %xmm0-%xmm1 used to pass and return floating point arguments
95	* [Not preserved]
96	* %xmm2-%xmm7 used to pass floating point arguments
97	* [Not preserved]
98	* %xmm8-%xmm15 temporary registers
99	* [Not preserved]
100	* %mmx0-%mmx7 temporary registers
101	* [Not preserved]
102	* %st0 temporary register; used to return long double arguments
103	* [Not preserved]
104	* %st1 temporary registers; used to return long double arguments
105	* [Not preserved]
106	* %st2-%st7 temporary registers
107	* [Not preserved]
108	* %fs Reserved for system use (as thread specific data register)
109	* [Not preserved]
110	*
111	* Direction flag is preserved as cleared.
112	* The stack must be aligned on a 16-byte boundrary before the 'call/jmp' instruction.
113	*
114	*
115	*
116	* MSC expects the following:
117	* rax return value, not preserved.
118	* rbx preserved.
119	* rcx 1st argument, integer, not preserved.
120	* rdx 2nd argument, integer, not preserved.
121	* rbp preserved.
122	* rsp preserved.
123	* rsi preserved.
124	* rdi preserved.
125	* r8 3rd argument, integer, not preserved.
126	* r9 4th argument, integer, not preserved.
127	* r10 scratch register, not preserved.
128	* r11 scratch register, not preserved.
129	* r12-r15 preserved.
130	* xmm0 1st argument, fp, return value, not preserved.
131	* xmm1 2st argument, fp, not preserved.
132	* xmm2 3st argument, fp, not preserved.
133	* xmm3 4st argument, fp, not preserved.
134	* xmm4-xmm5 scratch, not preserved.
135	* xmm6-xmm15 preserved.
136	*
137	* Dunno what the direction flag is...
138	* The stack must be aligned on a 16-byte boundrary before the 'call/jmp' instruction.
139	*
140	*
141	* Thus, When GCC code is calling MSC code we don't really have to preserve
142	* anything. But but MSC code is calling GCC code, we'll have to save esi and edi.
143	*
144	*/
145
146
147	/*******************************************************************************
148	* Defined Constants And Macros *
149	*******************************************************************************/
150	/** @def USE_REM_STUBS
151	* Define USE_REM_STUBS to stub the entire REM stuff. This is useful during
152	* early porting (before we start running stuff).
153	*/
154	#if defined(__DOXYGEN__)
155	# define USE_REM_STUBS
156	#endif
157
158	/** @def USE_REM_CALLING_CONVENTION_GLUE
159	* Define USE_REM_CALLING_CONVENTION_GLUE for platforms where it's necessary to
160	* use calling convention wrappers.
161	*/
162	#if (defined(RT_ARCH_AMD64) && defined(RT_OS_WINDOWS)) \|\| defined(__DOXYGEN__)
163	# define USE_REM_CALLING_CONVENTION_GLUE
164	#endif
165
166	/** @def USE_REM_IMPORT_JUMP_GLUE
167	* Define USE_REM_IMPORT_JUMP_GLUE for platforms where we need to
168	* emit some jump glue to deal with big addresses.
169	*/
170	#if (defined(RT_ARCH_AMD64) && !defined(USE_REM_CALLING_CONVENTION_GLUE) && !defined(RT_OS_DARWIN)) \|\| defined(__DOXYGEN__)
171	# define USE_REM_IMPORT_JUMP_GLUE
172	#endif
173
174
175	/*******************************************************************************
176	* Header Files *
177	*******************************************************************************/
178	#define LOG_GROUP LOG_GROUP_REM
179	#include <VBox/rem.h>
180	#include <VBox/vmm.h>
181	#include <VBox/dbgf.h>
182	#include <VBox/dbg.h>
183	#include <VBox/csam.h>
184	#include <VBox/mm.h>
185	#include <VBox/em.h>
186	#include <VBox/ssm.h>
187	#include <VBox/hwaccm.h>
188	#include <VBox/patm.h>
189	#include <VBox/pdm.h>
190	#include <VBox/pgm.h>
191	#include <VBox/iom.h>
192	#include <VBox/vm.h>
193	#include <VBox/err.h>
194	#include <VBox/log.h>
195	#include <VBox/dis.h>
196
197	#include <iprt/alloc.h>
198	#include <iprt/assert.h>
199	#include <iprt/ldr.h>
200	#include <iprt/param.h>
201	#include <iprt/path.h>
202	#include <iprt/string.h>
203	#include <iprt/stream.h>
204
205
206	/*******************************************************************************
207	* Structures and Typedefs *
208	*******************************************************************************/
209	/**
210	* Parameter descriptor.
211	*/
212	typedef struct REMPARMDESC
213	{
214	/** Parameter flags (REMPARMDESC_FLAGS_). /
215	uint8_t fFlags;
216	/** The parameter size if REMPARMDESC_FLAGS_SIZE is set. */
217	uint8_t cb;
218	/** Pointer to additional data.
219	* For REMPARMDESC_FLAGS_PFN this is a PREMFNDESC. */
220	void *pvExtra;
221
222	} REMPARMDESC, *PREMPARMDESC;
223	/** Pointer to a constant parameter descriptor. */
224	typedef const REMPARMDESC *PCREMPARMDESC;
225
226	/** @name Parameter descriptor flags.
227	* @{ */
228	/** The parameter type is a kind of integer which could fit in a register. This includes pointers. */
229	#define REMPARMDESC_FLAGS_INT 0
230	/** The parameter is a GC pointer. */
231	#define REMPARMDESC_FLAGS_GCPTR 1
232	/** The parameter is a GC physical address. */
233	#define REMPARMDESC_FLAGS_GCPHYS 2
234	/** The parameter is a HC physical address. */
235	#define REMPARMDESC_FLAGS_HCPHYS 3
236	/** The parameter type is a kind of floating point. */
237	#define REMPARMDESC_FLAGS_FLOAT 4
238	/** The parameter value is a struct. This type takes a size. */
239	#define REMPARMDESC_FLAGS_STRUCT 5
240	/** The parameter is an elipsis. */
241	#define REMPARMDESC_FLAGS_ELLIPSIS 6
242	/** The parameter is a va_list. */
243	#define REMPARMDESC_FLAGS_VALIST 7
244	/** The parameter is a function pointer. pvExtra is a PREMFNDESC. */
245	#define REMPARMDESC_FLAGS_PFN 8
246	/** The parameter type mask. */
247	#define REMPARMDESC_FLAGS_TYPE_MASK 15
248	/** The parameter size field is valid. */
249	#define REMPARMDESC_FLAGS_SIZE BIT(7)
250	/** @} */
251
252	/**
253	* Function descriptor.
254	*/
255	typedef struct REMFNDESC
256	{
257	/** The function name. */
258	const char *pszName;
259	/** Exports: Pointer to the function pointer.
260	* Imports: Pointer to the function. */
261	void *pv;
262	/** Array of parameter descriptors. */
263	PCREMPARMDESC paParams;
264	/** The number of parameter descriptors pointed to by paParams. */
265	uint8_t cParams;
266	/** Function flags (REMFNDESC_FLAGS_). /
267	uint8_t fFlags;
268	/** The size of the return value. */
269	uint8_t cbReturn;
270	/** Pointer to the wrapper code for imports. */
271	void *pvWrapper;
272	} REMFNDESC, *PREMFNDESC;
273	/** Pointer to a constant function descriptor. */
274	typedef const REMFNDESC *PCREMFNDESC;
275
276	/** @name Function descriptor flags.
277	* @{ */
278	/** The return type is void. */
279	#define REMFNDESC_FLAGS_RET_VOID 0
280	/** The return type is a kind of integer passed in rax/eax. This includes pointers. */
281	#define REMFNDESC_FLAGS_RET_INT 1
282	/** The return type is a kind of floating point. */
283	#define REMFNDESC_FLAGS_RET_FLOAT 2
284	/** The return value is a struct. This type take a size. */
285	#define REMFNDESC_FLAGS_RET_STRUCT 3
286	/** The return type mask. */
287	#define REMFNDESC_FLAGS_RET_TYPE_MASK 7
288	/** The argument list contains one or more va_list arguments (i.e. problems). */
289	#define REMFNDESC_FLAGS_VALIST BIT(6)
290	/** The function has an ellipsis (i.e. a problem). */
291	#define REMFNDESC_FLAGS_ELLIPSIS BIT(7)
292	/** @} */
293
294	/**
295	* Chunk of read-write-executable memory.
296	*/
297	typedef struct REMEXECMEM
298	{
299	/** The number of bytes left. */
300	struct REMEXECMEM *pNext;
301	/** The size of this chunk. */
302	uint32_t cb;
303	/** The offset of the next code block. */
304	uint32_t off;
305	#if ARCH_BITS == 32
306	uint32_t padding;
307	#endif
308	} REMEXECMEM, *PREMEXECMEM;
309
310
311	/*******************************************************************************
312	* Global Variables *
313	*******************************************************************************/
314	#ifndef USE_REM_STUBS
315	/** Loader handle of the REM object/DLL. */
316	static RTLDRMOD g_ModREM2;
317	/** Pointer to the memory containing the loaded REM2 object/DLL. */
318	static void *g_pvREM2;
319
320	/** Linux object export addresses.
321	* These are references from the assembly wrapper code.
322	* @{ */
323	static DECLCALLBACKPTR(int, pfnREMR3Init)(PVM);
324	static DECLCALLBACKPTR(int, pfnREMR3Term)(PVM);
325	static DECLCALLBACKPTR(void, pfnREMR3Reset)(PVM);
326	static DECLCALLBACKPTR(int, pfnREMR3Step)(PVM);
327	static DECLCALLBACKPTR(int, pfnREMR3BreakpointSet)(PVM, RTGCUINTPTR);
328	static DECLCALLBACKPTR(int, pfnREMR3BreakpointClear)(PVM, RTGCUINTPTR);
329	static DECLCALLBACKPTR(int, pfnREMR3EmulateInstruction)(PVM);
330	static DECLCALLBACKPTR(int, pfnREMR3Run)(PVM);
331	static DECLCALLBACKPTR(int, pfnREMR3State)(PVM);
332	static DECLCALLBACKPTR(int, pfnREMR3StateBack)(PVM);
333	static DECLCALLBACKPTR(void, pfnREMR3StateUpdate)(PVM);
334	static DECLCALLBACKPTR(void, pfnREMR3A20Set)(PVM, bool);
335	static DECLCALLBACKPTR(void, pfnREMR3ReplayInvalidatedPages)(PVM);
336	static DECLCALLBACKPTR(void, pfnREMR3ReplayHandlerNotifications)(PVM pVM);
337	static DECLCALLBACKPTR(void, pfnREMR3NotifyPhysRamRegister)(PVM, RTGCPHYS, RTUINT, void *, unsigned);
338	static DECLCALLBACKPTR(void, pfnREMR3NotifyPhysRamChunkRegister)(PVM, RTGCPHYS, RTUINT, RTHCUINTPTR, unsigned);
339	static DECLCALLBACKPTR(void, pfnREMR3NotifyPhysReserve)(PVM, RTGCPHYS, RTUINT);
340	static DECLCALLBACKPTR(void, pfnREMR3NotifyPhysRomRegister)(PVM, RTGCPHYS, RTUINT, void *);
341	static DECLCALLBACKPTR(void, pfnREMR3NotifyHandlerPhysicalModify)(PVM, PGMPHYSHANDLERTYPE, RTGCPHYS, RTGCPHYS, RTGCPHYS, bool, void *);
342	static DECLCALLBACKPTR(void, pfnREMR3NotifyHandlerPhysicalRegister)(PVM, PGMPHYSHANDLERTYPE, RTGCPHYS, RTGCPHYS, bool);
343	static DECLCALLBACKPTR(void, pfnREMR3NotifyHandlerPhysicalDeregister)(PVM, PGMPHYSHANDLERTYPE, RTGCPHYS, RTGCPHYS, bool, void *);
344	static DECLCALLBACKPTR(void, pfnREMR3NotifyInterruptSet)(PVM);
345	static DECLCALLBACKPTR(void, pfnREMR3NotifyInterruptClear)(PVM);
346	static DECLCALLBACKPTR(void, pfnREMR3NotifyTimerPending)(PVM);
347	static DECLCALLBACKPTR(void, pfnREMR3NotifyDmaPending)(PVM);
348	static DECLCALLBACKPTR(void, pfnREMR3NotifyQueuePending)(PVM);
349	static DECLCALLBACKPTR(void, pfnREMR3NotifyFF)(PVM);
350	static DECLCALLBACKPTR(int, pfnREMR3NotifyCodePageChanged)(PVM, RTGCPTR);
351	static DECLCALLBACKPTR(void, pfnREMR3NotifyPendingInterrupt)(PVM, uint8_t);
352	static DECLCALLBACKPTR(uint32_t, pfnREMR3QueryPendingInterrupt)(PVM);
353	static DECLCALLBACKPTR(int, pfnREMR3DisasEnableStepping)(PVM, bool);
354	static DECLCALLBACKPTR(bool, pfnREMR3IsPageAccessHandled)(PVM, RTGCPHYS);
355	/** @} */
356
357	/** Export and import parameter descriptors.
358	* @{
359	*/
360	/* Common args. */
361	static const REMPARMDESC g_aArgsSIZE_T[] =
362	{
363	{ REMPARMDESC_FLAGS_INT, sizeof(size_t) }
364	};
365	static const REMPARMDESC g_aArgsPTR[] =
366	{
367	{ REMPARMDESC_FLAGS_INT, sizeof(void *) }
368	};
369	static const REMPARMDESC g_aArgsVM[] =
370	{
371	{ REMPARMDESC_FLAGS_INT, sizeof(PVM) }
372	};
373
374	/* REM args */
375	static const REMPARMDESC g_aArgsBreakpoint[] =
376	{
377	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
378	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINTPTR), NULL }
379	};
380	static const REMPARMDESC g_aArgsA20Set[] =
381	{
382	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
383	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
384	};
385	static const REMPARMDESC g_aArgsNotifyPhysRamRegister[] =
386	{
387	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
388	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
389	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
390	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
391	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
392	};
393	static const REMPARMDESC g_aArgsNotifyPhysRamChunkRegister[] =
394	{
395	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
396	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
397	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
398	{ REMPARMDESC_FLAGS_INT, sizeof(RTHCUINTPTR), NULL },
399	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
400	};
401	static const REMPARMDESC g_aArgsNotifyPhysReserve[] =
402	{
403	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
404	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
405	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL }
406	};
407	static const REMPARMDESC g_aArgsNotifyPhysRomRegister[] =
408	{
409	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
410	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
411	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
412	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL }
413	};
414	static const REMPARMDESC g_aArgsNotifyHandlerPhysicalModify[] =
415	{
416	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
417	{ REMPARMDESC_FLAGS_INT, sizeof(PGMPHYSHANDLERTYPE), NULL },
418	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
419	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
420	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
421	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL },
422	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL }
423	};
424	static const REMPARMDESC g_aArgsNotifyHandlerPhysicalRegister[] =
425	{
426	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
427	{ REMPARMDESC_FLAGS_INT, sizeof(PGMPHYSHANDLERTYPE), NULL },
428	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
429	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
430	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
431	};
432	static const REMPARMDESC g_aArgsNotifyHandlerPhysicalDeregister[] =
433	{
434	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
435	{ REMPARMDESC_FLAGS_INT, sizeof(PGMPHYSHANDLERTYPE), NULL },
436	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
437	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
438	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL },
439	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL }
440	};
441	static const REMPARMDESC g_aArgsNotifyCodePageChanged[] =
442	{
443	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
444	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINTPTR), NULL }
445	};
446	static const REMPARMDESC g_aArgsNotifyPendingInterrupt[] =
447	{
448	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
449	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
450	};
451	static const REMPARMDESC g_aArgsDisasEnableStepping[] =
452	{
453	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
454	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
455	};
456	static const REMPARMDESC g_aArgsIsPageAccessHandled[] =
457	{
458	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
459	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }
460	};
461
462
463	/* VMM args */
464	static const REMPARMDESC g_aArgsCPUMGetGuestCpl[] =
465	{
466	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
467	{ REMPARMDESC_FLAGS_INT, sizeof(PCPUMCTXCORE), NULL },
468	};
469
470	static const REMPARMDESC g_aArgsCPUMGetGuestCpuId[] =
471	{
472	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
473	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
474	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
475	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
476	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
477	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
478	};
479	static const REMPARMDESC g_aArgsCPUMQueryGuestCtxPtr[] =
480	{
481	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
482	{ REMPARMDESC_FLAGS_INT, sizeof(PCPUMCTX *), NULL }
483	};
484	static const REMPARMDESC g_aArgsCSAMR3MonitorPage[] =
485	{
486	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
487	{ REMPARMDESC_FLAGS_INT, sizeof(RTGCPTR), NULL },
488	{ REMPARMDESC_FLAGS_INT, sizeof(CSAMTAG), NULL }
489	};
490	#if !(defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64)) /* the callbacks are problematic */
491	static const REMPARMDESC g_aArgsDBGCRegisterCommands[] =
492	{
493	{ REMPARMDESC_FLAGS_INT, sizeof(PCDBGCCMD), NULL },
494	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
495	};
496	#endif
497	static const REMPARMDESC g_aArgsDBGFR3DisasInstrEx[] =
498	{
499	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
500	{ REMPARMDESC_FLAGS_INT, sizeof(RTSEL), NULL },
501	{ REMPARMDESC_FLAGS_INT, sizeof(RTGCPTR), NULL },
502	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
503	{ REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
504	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
505	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
506	};
507	static const REMPARMDESC g_aArgsDBGFR3Info[] =
508	{
509	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
510	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
511	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
512	{ REMPARMDESC_FLAGS_INT, sizeof(PCDBGFINFOHLP), NULL }
513	};
514	static const REMPARMDESC g_aArgsDBGFR3SymbolByAddr[] =
515	{
516	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
517	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINTPTR), NULL },
518	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCINTPTR), NULL },
519	{ REMPARMDESC_FLAGS_INT, sizeof(PDBGFSYMBOL), NULL }
520	};
521	static const REMPARMDESC g_aArgsDISInstr[] =
522	{
523	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
524	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINTPTR), NULL },
525	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
526	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
527	{ REMPARMDESC_FLAGS_INT, sizeof(char *), NULL }
528	};
529	static const REMPARMDESC g_aArgsEMR3FatalError[] =
530	{
531	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
532	{ REMPARMDESC_FLAGS_INT, sizeof(int), NULL }
533	};
534	static const REMPARMDESC g_aArgsHWACCMR3CanExecuteGuest[] =
535	{
536	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
537	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
538	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
539	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
540	};
541	static const REMPARMDESC g_aArgsIOMIOPortRead[] =
542	{
543	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
544	{ REMPARMDESC_FLAGS_INT, sizeof(RTIOPORT), NULL },
545	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
546	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
547	};
548	static const REMPARMDESC g_aArgsIOMIOPortWrite[] =
549	{
550	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
551	{ REMPARMDESC_FLAGS_INT, sizeof(RTIOPORT), NULL },
552	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
553	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
554	};
555	static const REMPARMDESC g_aArgsIOMMMIORead[] =
556	{
557	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
558	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
559	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL },
560	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
561	};
562	static const REMPARMDESC g_aArgsIOMMMIOWrite[] =
563	{
564	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
565	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
566	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
567	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
568	};
569	static const REMPARMDESC g_aArgsMMR3HeapAlloc[] =
570	{
571	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
572	{ REMPARMDESC_FLAGS_INT, sizeof(MMTAG), NULL },
573	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
574	};
575	static const REMPARMDESC g_aArgsMMR3HeapAllocZ[] =
576	{
577	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
578	{ REMPARMDESC_FLAGS_INT, sizeof(MMTAG), NULL },
579	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
580	};
581	static const REMPARMDESC g_aArgsPATMIsPatchGCAddr[] =
582	{
583	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
584	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL }
585	};
586	static const REMPARMDESC g_aArgsPATMR3QueryOpcode[] =
587	{
588	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
589	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL },
590	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL }
591	};
592	static const REMPARMDESC g_aArgsPATMR3QueryPatchMem[] =
593	{
594	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
595	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
596	};
597	static const REMPARMDESC g_aArgsPDMApicGetBase[] =
598	{
599	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
600	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t *), NULL }
601	};
602	static const REMPARMDESC g_aArgsPDMApicGetTPR[] =
603	{
604	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
605	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL }
606	};
607	static const REMPARMDESC g_aArgsPDMApicSetBase[] =
608	{
609	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
610	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL }
611	};
612	static const REMPARMDESC g_aArgsPDMApicSetTPR[] =
613	{
614	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
615	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
616	};
617	static const REMPARMDESC g_aArgsPDMGetInterrupt[] =
618	{
619	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
620	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL }
621	};
622	static const REMPARMDESC g_aArgsPDMIsaSetIrq[] =
623	{
624	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
625	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL },
626	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
627	};
628	static const REMPARMDESC g_aArgsPGMGstGetPage[] =
629	{
630	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
631	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL },
632	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t *), NULL },
633	{ REMPARMDESC_FLAGS_INT, sizeof(PRTGCPHYS), NULL }
634	};
635	static const REMPARMDESC g_aArgsPGMInvalidatePage[] =
636	{
637	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
638	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL }
639	};
640	static const REMPARMDESC g_aArgsPGMPhysGCPhys2HCPtr[] =
641	{
642	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
643	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
644	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
645	{ REMPARMDESC_FLAGS_INT, sizeof(PRTHCPTR), NULL }
646	};
647	static const REMPARMDESC g_aArgsPGMPhysGCPtr2HCPtrByGstCR3[] =
648	{
649	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
650	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
651	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
652	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
653	{ REMPARMDESC_FLAGS_INT, sizeof(PRTHCPTR), NULL }
654	};
655	static const REMPARMDESC g_aArgsPGM3PhysGrowRange[] =
656	{
657	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
658	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }
659	};
660	static const REMPARMDESC g_aArgsPGMPhysIsGCPhysValid[] =
661	{
662	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
663	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }
664	};
665	static const REMPARMDESC g_aArgsPGMPhysRead[] =
666	{
667	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
668	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
669	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
670	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
671	};
672	static const REMPARMDESC g_aArgsPGMPhysReadGCPtr[] =
673	{
674	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
675	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
676	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL },
677	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
678	};
679	static const REMPARMDESC g_aArgsPGMPhysWrite[] =
680	{
681	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
682	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
683	{ REMPARMDESC_FLAGS_INT, sizeof(const void *), NULL },
684	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
685	};
686	static const REMPARMDESC g_aArgsPGMChangeMode[] =
687	{
688	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
689	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
690	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
691	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL }
692	};
693	static const REMPARMDESC g_aArgsPGMFlushTLB[] =
694	{
695	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
696	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
697	{ REMPARMDESC_FLAGS_INT, sizeof(bool), NULL }
698	};
699	static const REMPARMDESC g_aArgsPGMR3PhysReadUxx[] =
700	{
701	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
702	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL }
703	};
704	static const REMPARMDESC g_aArgsPGMR3PhysWriteU8[] =
705	{
706	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
707	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
708	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL }
709	};
710	static const REMPARMDESC g_aArgsPGMR3PhysWriteU16[] =
711	{
712	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
713	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
714	{ REMPARMDESC_FLAGS_INT, sizeof(uint16_t), NULL }
715	};
716	static const REMPARMDESC g_aArgsPGMR3PhysWriteU32[] =
717	{
718	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
719	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
720	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL }
721	};
722	static const REMPARMDESC g_aArgsPGMR3PhysWriteU64[] =
723	{
724	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
725	{ REMPARMDESC_FLAGS_GCPHYS, sizeof(RTGCPHYS), NULL },
726	{ REMPARMDESC_FLAGS_INT, sizeof(uint64_t), NULL }
727	};
728	static const REMPARMDESC g_aArgsSSMR3GetGCPtr[] =
729	{
730	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
731	{ REMPARMDESC_FLAGS_INT, sizeof(PRTGCPTR), NULL }
732	};
733	static const REMPARMDESC g_aArgsSSMR3GetMem[] =
734	{
735	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
736	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
737	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
738	};
739	static const REMPARMDESC g_aArgsSSMR3GetU32[] =
740	{
741	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
742	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t *), NULL }
743	};
744	static const REMPARMDESC g_aArgsSSMR3GetUInt[] =
745	{
746	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
747	{ REMPARMDESC_FLAGS_INT, sizeof(PRTUINT), NULL }
748	};
749	static const REMPARMDESC g_aArgsSSMR3PutGCPtr[] =
750	{
751	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
752	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCPTR), NULL }
753	};
754	static const REMPARMDESC g_aArgsSSMR3PutMem[] =
755	{
756	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
757	{ REMPARMDESC_FLAGS_INT, sizeof(const void *), NULL },
758	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
759	};
760	static const REMPARMDESC g_aArgsSSMR3PutU32[] =
761	{
762	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
763	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
764	};
765	static const REMPARMDESC g_aArgsSSMR3PutUInt[] =
766	{
767	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
768	{ REMPARMDESC_FLAGS_INT, sizeof(RTUINT), NULL },
769	};
770
771	static const REMPARMDESC g_aArgsSSMIntCallback[] =
772	{
773	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
774	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
775	};
776	static REMFNDESC g_SSMIntCallback =
777	{
778	"SSMIntCallback", NULL, &g_aArgsSSMIntCallback[0], ELEMENTS(g_aArgsSSMIntCallback), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL
779	};
780
781	static const REMPARMDESC g_aArgsSSMIntLoadExecCallback[] =
782	{
783	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
784	{ REMPARMDESC_FLAGS_INT, sizeof(PSSMHANDLE), NULL },
785	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
786	};
787	static REMFNDESC g_SSMIntLoadExecCallback =
788	{
789	"SSMIntLoadExecCallback", NULL, &g_aArgsSSMIntLoadExecCallback[0], ELEMENTS(g_aArgsSSMIntLoadExecCallback), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL
790	};
791	static const REMPARMDESC g_aArgsSSMR3RegisterInternal[] =
792	{
793	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
794	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
795	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
796	{ REMPARMDESC_FLAGS_INT, sizeof(uint32_t), NULL },
797	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
798	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTSAVEPREP), &g_SSMIntCallback },
799	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTSAVEEXEC), &g_SSMIntCallback },
800	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTSAVEDONE), &g_SSMIntCallback },
801	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLOADPREP), &g_SSMIntCallback },
802	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLOADEXEC), &g_SSMIntLoadExecCallback },
803	{ REMPARMDESC_FLAGS_PFN, sizeof(PFNSSMINTLOADDONE), &g_SSMIntCallback },
804	};
805
806	static const REMPARMDESC g_aArgsSTAMR3Register[] =
807	{
808	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
809	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
810	{ REMPARMDESC_FLAGS_INT, sizeof(STAMTYPE), NULL },
811	{ REMPARMDESC_FLAGS_INT, sizeof(STAMVISIBILITY), NULL },
812	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
813	{ REMPARMDESC_FLAGS_INT, sizeof(STAMUNIT), NULL },
814	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
815	};
816	static const REMPARMDESC g_aArgsTRPMAssertTrap[] =
817	{
818	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
819	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t), NULL },
820	{ REMPARMDESC_FLAGS_INT, sizeof(TRPMEVENT), NULL }
821	};
822	static const REMPARMDESC g_aArgsTRPMQueryTrap[] =
823	{
824	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
825	{ REMPARMDESC_FLAGS_INT, sizeof(uint8_t *), NULL },
826	{ REMPARMDESC_FLAGS_INT, sizeof(TRPMEVENT *), NULL }
827	};
828	static const REMPARMDESC g_aArgsTRPMSetErrorCode[] =
829	{
830	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
831	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINT), NULL }
832	};
833	static const REMPARMDESC g_aArgsTRPMSetFaultAddress[] =
834	{
835	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
836	{ REMPARMDESC_FLAGS_GCPTR, sizeof(RTGCUINT), NULL }
837	};
838	static const REMPARMDESC g_aArgsVMR3ReqCall[] =
839	{
840	{ REMPARMDESC_FLAGS_INT, sizeof(PVM), NULL },
841	{ REMPARMDESC_FLAGS_INT, sizeof(PVMREQ *), NULL },
842	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
843	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
844	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
845	{ REMPARMDESC_FLAGS_ELLIPSIS, 0 }
846	};
847	static const REMPARMDESC g_aArgsVMR3ReqFree[] =
848	{
849	{ REMPARMDESC_FLAGS_INT, sizeof(PVMREQ), NULL }
850	};
851
852
853	/* IPRT args */
854	static const REMPARMDESC g_aArgsAssertMsg1[] =
855	{
856	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
857	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
858	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
859	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
860	};
861	static const REMPARMDESC g_aArgsAssertMsg2[] =
862	{
863	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
864	{ REMPARMDESC_FLAGS_ELLIPSIS, 0 }
865	};
866	static const REMPARMDESC g_aArgsRTLogFlags[] =
867	{
868	{ REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL },
869	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL }
870	};
871	static const REMPARMDESC g_aArgsRTLogLoggerEx[] =
872	{
873	{ REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL },
874	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
875	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
876	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
877	{ REMPARMDESC_FLAGS_ELLIPSIS, 0 }
878	};
879	static const REMPARMDESC g_aArgsRTLogLoggerExV[] =
880	{
881	{ REMPARMDESC_FLAGS_INT, sizeof(PRTLOGGER), NULL },
882	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
883	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL },
884	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
885	{ REMPARMDESC_FLAGS_VALIST, 0 }
886	};
887	static const REMPARMDESC g_aArgsRTLogPrintf[] =
888	{
889	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
890	{ REMPARMDESC_FLAGS_ELLIPSIS, 0 }
891	};
892	static const REMPARMDESC g_aArgsRTMemProtect[] =
893	{
894	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
895	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
896	{ REMPARMDESC_FLAGS_INT, sizeof(unsigned), NULL }
897	};
898	static const REMPARMDESC g_aArgsRTStrPrintf[] =
899	{
900	{ REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
901	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
902	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
903	{ REMPARMDESC_FLAGS_ELLIPSIS, 0 }
904	};
905	static const REMPARMDESC g_aArgsRTStrPrintfV[] =
906	{
907	{ REMPARMDESC_FLAGS_INT, sizeof(char *), NULL },
908	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL },
909	{ REMPARMDESC_FLAGS_INT, sizeof(const char *), NULL },
910	{ REMPARMDESC_FLAGS_VALIST, 0 }
911	};
912
913
914	/* CRT args */
915	static const REMPARMDESC g_aArgsmemcpy[] =
916	{
917	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
918	{ REMPARMDESC_FLAGS_INT, sizeof(const void *), NULL },
919	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
920	};
921	static const REMPARMDESC g_aArgsmemset[] =
922	{
923	{ REMPARMDESC_FLAGS_INT, sizeof(void *), NULL },
924	{ REMPARMDESC_FLAGS_INT, sizeof(int), NULL },
925	{ REMPARMDESC_FLAGS_INT, sizeof(size_t), NULL }
926	};
927
928
929	/** @} */
930
931	/**
932	* Descriptors for the exported functions.
933	*/
934	static const REMFNDESC g_aExports[] =
935	{ /* pszName, (void )pv, pParams, cParams, fFlags, cb, pvWrapper. /
936	{ "REMR3Init", (void *)&pfnREMR3Init, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
937	{ "REMR3Term", (void *)&pfnREMR3Term, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
938	{ "REMR3Reset", (void *)&pfnREMR3Reset, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
939	{ "REMR3Step", (void *)&pfnREMR3Step, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
940	{ "REMR3BreakpointSet", (void *)&pfnREMR3BreakpointSet, &g_aArgsBreakpoint[0], ELEMENTS(g_aArgsBreakpoint), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
941	{ "REMR3BreakpointClear", (void *)&pfnREMR3BreakpointClear, &g_aArgsBreakpoint[0], ELEMENTS(g_aArgsBreakpoint), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
942	{ "REMR3EmulateInstruction", (void *)&pfnREMR3EmulateInstruction, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
943	{ "REMR3Run", (void *)&pfnREMR3Run, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
944	{ "REMR3State", (void *)&pfnREMR3State, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
945	{ "REMR3StateBack", (void *)&pfnREMR3StateBack, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
946	{ "REMR3StateUpdate", (void *)&pfnREMR3StateUpdate, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
947	{ "REMR3A20Set", (void *)&pfnREMR3A20Set, &g_aArgsA20Set[0], ELEMENTS(g_aArgsA20Set), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
948	{ "REMR3ReplayInvalidatedPages", (void *)&pfnREMR3ReplayInvalidatedPages, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
949	{ "REMR3ReplayHandlerNotifications", (void *)&pfnREMR3ReplayHandlerNotifications, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
950	{ "REMR3NotifyPhysRamRegister", (void *)&pfnREMR3NotifyPhysRamRegister, &g_aArgsNotifyPhysRamRegister[0], ELEMENTS(g_aArgsNotifyPhysRamRegister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
951	{ "REMR3NotifyPhysRamChunkRegister", (void *)&pfnREMR3NotifyPhysRamChunkRegister, &g_aArgsNotifyPhysRamChunkRegister[0], ELEMENTS(g_aArgsNotifyPhysRamChunkRegister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
952	{ "REMR3NotifyPhysReserve", (void *)&pfnREMR3NotifyPhysReserve, &g_aArgsNotifyPhysReserve[0], ELEMENTS(g_aArgsNotifyPhysReserve), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
953	{ "REMR3NotifyPhysRomRegister", (void *)&pfnREMR3NotifyPhysRomRegister, &g_aArgsNotifyPhysRomRegister[0], ELEMENTS(g_aArgsNotifyPhysRomRegister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
954	{ "REMR3NotifyHandlerPhysicalModify", (void *)&pfnREMR3NotifyHandlerPhysicalModify, &g_aArgsNotifyHandlerPhysicalModify[0], ELEMENTS(g_aArgsNotifyHandlerPhysicalModify), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
955	{ "REMR3NotifyHandlerPhysicalRegister", (void *)&pfnREMR3NotifyHandlerPhysicalRegister, &g_aArgsNotifyHandlerPhysicalRegister[0], ELEMENTS(g_aArgsNotifyHandlerPhysicalRegister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
956	{ "REMR3NotifyHandlerPhysicalDeregister", (void *)&pfnREMR3NotifyHandlerPhysicalDeregister, &g_aArgsNotifyHandlerPhysicalDeregister[0], ELEMENTS(g_aArgsNotifyHandlerPhysicalDeregister), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
957	{ "REMR3NotifyInterruptSet", (void *)&pfnREMR3NotifyInterruptSet, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
958	{ "REMR3NotifyInterruptClear", (void *)&pfnREMR3NotifyInterruptClear, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
959	{ "REMR3NotifyTimerPending", (void *)&pfnREMR3NotifyTimerPending, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
960	{ "REMR3NotifyDmaPending", (void *)&pfnREMR3NotifyDmaPending, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
961	{ "REMR3NotifyQueuePending", (void *)&pfnREMR3NotifyQueuePending, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
962	{ "REMR3NotifyFF", (void *)&pfnREMR3NotifyFF, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
963	{ "REMR3NotifyCodePageChanged", (void *)&pfnREMR3NotifyCodePageChanged, &g_aArgsNotifyCodePageChanged[0], ELEMENTS(g_aArgsNotifyCodePageChanged), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
964	{ "REMR3NotifyPendingInterrupt", (void *)&pfnREMR3NotifyPendingInterrupt, &g_aArgsNotifyPendingInterrupt[0], ELEMENTS(g_aArgsNotifyPendingInterrupt), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
965	{ "REMR3QueryPendingInterrupt", (void *)&pfnREMR3QueryPendingInterrupt, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
966	{ "REMR3DisasEnableStepping", (void *)&pfnREMR3DisasEnableStepping, &g_aArgsDisasEnableStepping[0], ELEMENTS(g_aArgsDisasEnableStepping), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
967	{ "REMR3IsPageAccessHandled", (void *)&pfnREMR3IsPageAccessHandled, &g_aArgsIsPageAccessHandled[0], ELEMENTS(g_aArgsIsPageAccessHandled), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL }
968	};
969
970
971	/**
972	* Descriptors for the functions imported from VBoxVMM.
973	*/
974	static REMFNDESC g_aVMMImports[] =
975	{
976	{ "CPUMAreHiddenSelRegsValid", (void *)(uintptr_t)&CPUMAreHiddenSelRegsValid, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
977	{ "CPUMGetAndClearChangedFlagsREM", (void *)(uintptr_t)&CPUMGetAndClearChangedFlagsREM, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(unsigned), NULL },
978	{ "CPUMGetGuestCPL", (void *)(uintptr_t)&CPUMGetGuestCPL, &g_aArgsCPUMGetGuestCpl[0], ELEMENTS(g_aArgsCPUMGetGuestCpl), REMFNDESC_FLAGS_RET_INT, sizeof(unsigned), NULL },
979	{ "CPUMGetGuestCpuId", (void *)(uintptr_t)&CPUMGetGuestCpuId, &g_aArgsCPUMGetGuestCpuId[0], ELEMENTS(g_aArgsCPUMGetGuestCpuId), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
980	{ "CPUMGetGuestEAX", (void *)(uintptr_t)&CPUMGetGuestEAX, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
981	{ "CPUMGetGuestEBP", (void *)(uintptr_t)&CPUMGetGuestEBP, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
982	{ "CPUMGetGuestEBX", (void *)(uintptr_t)&CPUMGetGuestEBX, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
983	{ "CPUMGetGuestECX", (void *)(uintptr_t)&CPUMGetGuestECX, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
984	{ "CPUMGetGuestEDI", (void *)(uintptr_t)&CPUMGetGuestEDI, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
985	{ "CPUMGetGuestEDX", (void *)(uintptr_t)&CPUMGetGuestEDX, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
986	{ "CPUMGetGuestEIP", (void *)(uintptr_t)&CPUMGetGuestEIP, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
987	{ "CPUMGetGuestESI", (void *)(uintptr_t)&CPUMGetGuestESI, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
988	{ "CPUMGetGuestESP", (void *)(uintptr_t)&CPUMGetGuestESP, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
989	{ "CPUMQueryGuestCtxPtr", (void *)(uintptr_t)&CPUMQueryGuestCtxPtr, &g_aArgsCPUMQueryGuestCtxPtr[0], ELEMENTS(g_aArgsCPUMQueryGuestCtxPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
990	{ "CSAMR3MonitorPage", (void *)(uintptr_t)&CSAMR3MonitorPage, &g_aArgsCSAMR3MonitorPage[0], ELEMENTS(g_aArgsCSAMR3MonitorPage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
991	#if !(defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64)) /* the callbacks are problematic */
992	{ "DBGCRegisterCommands", (void *)(uintptr_t)&DBGCRegisterCommands, &g_aArgsDBGCRegisterCommands[0], ELEMENTS(g_aArgsDBGCRegisterCommands), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
993	#endif
994	{ "DBGFR3DisasInstrEx", (void *)(uintptr_t)&DBGFR3DisasInstrEx, &g_aArgsDBGFR3DisasInstrEx[0], ELEMENTS(g_aArgsDBGFR3DisasInstrEx), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
995	{ "DBGFR3Info", (void *)(uintptr_t)&DBGFR3Info, &g_aArgsDBGFR3Info[0], ELEMENTS(g_aArgsDBGFR3Info), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
996	{ "DBGFR3InfoLogRelHlp", (void )(uintptr_t)&DBGFR3InfoLogRelHlp, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
997	{ "DBGFR3SymbolByAddr", (void *)(uintptr_t)&DBGFR3SymbolByAddr, &g_aArgsDBGFR3SymbolByAddr[0], ELEMENTS(g_aArgsDBGFR3SymbolByAddr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
998	{ "DISInstr", (void *)(uintptr_t)&DISInstr, &g_aArgsDISInstr[0], ELEMENTS(g_aArgsDISInstr), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
999	{ "EMR3FatalError", (void *)(uintptr_t)&EMR3FatalError, &g_aArgsEMR3FatalError[0], ELEMENTS(g_aArgsEMR3FatalError), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1000	{ "HWACCMR3CanExecuteGuest", (void *)(uintptr_t)&HWACCMR3CanExecuteGuest, &g_aArgsHWACCMR3CanExecuteGuest[0], ELEMENTS(g_aArgsHWACCMR3CanExecuteGuest), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1001	{ "IOMIOPortRead", (void *)(uintptr_t)&IOMIOPortRead, &g_aArgsIOMIOPortRead[0], ELEMENTS(g_aArgsIOMIOPortRead), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1002	{ "IOMIOPortWrite", (void *)(uintptr_t)&IOMIOPortWrite, &g_aArgsIOMIOPortWrite[0], ELEMENTS(g_aArgsIOMIOPortWrite), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1003	{ "IOMMMIORead", (void *)(uintptr_t)&IOMMMIORead, &g_aArgsIOMMMIORead[0], ELEMENTS(g_aArgsIOMMMIORead), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1004	{ "IOMMMIOWrite", (void *)(uintptr_t)&IOMMMIOWrite, &g_aArgsIOMMMIOWrite[0], ELEMENTS(g_aArgsIOMMMIOWrite), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1005	{ "MMR3HeapAlloc", (void )(uintptr_t)&MMR3HeapAlloc, &g_aArgsMMR3HeapAlloc[0], ELEMENTS(g_aArgsMMR3HeapAlloc), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1006	{ "MMR3HeapAllocZ", (void )(uintptr_t)&MMR3HeapAllocZ, &g_aArgsMMR3HeapAllocZ[0], ELEMENTS(g_aArgsMMR3HeapAllocZ), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1007	{ "MMR3PhysGetRamSize", (void *)(uintptr_t)&MMR3PhysGetRamSize, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
1008	{ "PATMIsPatchGCAddr", (void *)(uintptr_t)&PATMIsPatchGCAddr, &g_aArgsPATMIsPatchGCAddr[0], ELEMENTS(g_aArgsPATMIsPatchGCAddr), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1009	{ "PATMR3QueryOpcode", (void *)(uintptr_t)&PATMR3QueryOpcode, &g_aArgsPATMR3QueryOpcode[0], ELEMENTS(g_aArgsPATMR3QueryOpcode), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1010	{ "PATMR3QueryPatchMemGC", (void *)(uintptr_t)&PATMR3QueryPatchMemGC, &g_aArgsPATMR3QueryPatchMem[0], ELEMENTS(g_aArgsPATMR3QueryPatchMem), REMFNDESC_FLAGS_RET_INT, sizeof(RTGCPTR), NULL },
1011	{ "PATMR3QueryPatchMemHC", (void )(uintptr_t)&PATMR3QueryPatchMemHC, &g_aArgsPATMR3QueryPatchMem[0], ELEMENTS(g_aArgsPATMR3QueryPatchMem), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1012	{ "PDMApicGetBase", (void *)(uintptr_t)&PDMApicGetBase, &g_aArgsPDMApicGetBase[0], ELEMENTS(g_aArgsPDMApicGetBase), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1013	{ "PDMApicGetTPR", (void *)(uintptr_t)&PDMApicGetTPR, &g_aArgsPDMApicGetTPR[0], ELEMENTS(g_aArgsPDMApicGetTPR), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1014	{ "PDMApicSetBase", (void *)(uintptr_t)&PDMApicSetBase, &g_aArgsPDMApicSetBase[0], ELEMENTS(g_aArgsPDMApicSetBase), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1015	{ "PDMApicSetTPR", (void *)(uintptr_t)&PDMApicSetTPR, &g_aArgsPDMApicSetTPR[0], ELEMENTS(g_aArgsPDMApicSetTPR), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1016	{ "PDMR3DmaRun", (void *)(uintptr_t)&PDMR3DmaRun, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1017	{ "PDMGetInterrupt", (void *)(uintptr_t)&PDMGetInterrupt, &g_aArgsPDMGetInterrupt[0], ELEMENTS(g_aArgsPDMGetInterrupt), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1018	{ "PDMIsaSetIrq", (void *)(uintptr_t)&PDMIsaSetIrq, &g_aArgsPDMIsaSetIrq[0], ELEMENTS(g_aArgsPDMIsaSetIrq), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1019	{ "PGMGstGetPage", (void *)(uintptr_t)&PGMGstGetPage, &g_aArgsPGMGstGetPage[0], ELEMENTS(g_aArgsPGMGstGetPage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1020	{ "PGMInvalidatePage", (void *)(uintptr_t)&PGMInvalidatePage, &g_aArgsPGMInvalidatePage[0], ELEMENTS(g_aArgsPGMInvalidatePage), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1021	{ "PGMPhysGCPhys2HCPtr", (void *)(uintptr_t)&PGMPhysGCPhys2HCPtr, &g_aArgsPGMPhysGCPhys2HCPtr[0], ELEMENTS(g_aArgsPGMPhysGCPhys2HCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1022	{ "PGMPhysGCPtr2HCPtrByGstCR3", (void *)(uintptr_t)&PGMPhysGCPtr2HCPtrByGstCR3, &g_aArgsPGMPhysGCPtr2HCPtrByGstCR3[0], ELEMENTS(g_aArgsPGMPhysGCPtr2HCPtrByGstCR3), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1023	{ "PGM3PhysGrowRange", (void *)(uintptr_t)&PGM3PhysGrowRange, &g_aArgsPGM3PhysGrowRange[0], ELEMENTS(g_aArgsPGM3PhysGrowRange), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1024	{ "PGMPhysIsGCPhysValid", (void *)(uintptr_t)&PGMPhysIsGCPhysValid, &g_aArgsPGMPhysIsGCPhysValid[0], ELEMENTS(g_aArgsPGMPhysIsGCPhysValid), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1025	{ "PGMPhysIsA20Enabled", (void *)(uintptr_t)&PGMPhysIsA20Enabled, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1026	{ "PGMPhysRead", (void *)(uintptr_t)&PGMPhysRead, &g_aArgsPGMPhysRead[0], ELEMENTS(g_aArgsPGMPhysRead), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1027	{ "PGMPhysReadGCPtr", (void *)(uintptr_t)&PGMPhysReadGCPtr, &g_aArgsPGMPhysReadGCPtr[0], ELEMENTS(g_aArgsPGMPhysReadGCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1028	{ "PGMPhysReadGCPtr", (void *)(uintptr_t)&PGMPhysReadGCPtr, &g_aArgsPGMPhysReadGCPtr[0], ELEMENTS(g_aArgsPGMPhysReadGCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1029	{ "PGMPhysWrite", (void *)(uintptr_t)&PGMPhysWrite, &g_aArgsPGMPhysWrite[0], ELEMENTS(g_aArgsPGMPhysWrite), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1030	{ "PGMChangeMode", (void *)(uintptr_t)&PGMChangeMode, &g_aArgsPGMChangeMode[0], ELEMENTS(g_aArgsPGMChangeMode), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1031	{ "PGMFlushTLB", (void *)(uintptr_t)&PGMFlushTLB, &g_aArgsPGMFlushTLB[0], ELEMENTS(g_aArgsPGMFlushTLB), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1032	{ "PGMR3PhysReadByte", (void *)(uintptr_t)&PGMR3PhysReadByte, &g_aArgsPGMR3PhysReadUxx[0], ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint8_t), NULL },
1033	{ "PGMR3PhysReadDword", (void *)(uintptr_t)&PGMR3PhysReadDword, &g_aArgsPGMR3PhysReadUxx[0], ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint32_t), NULL },
1034	{ "PGMR3PhysReadWord", (void *)(uintptr_t)&PGMR3PhysReadWord, &g_aArgsPGMR3PhysReadUxx[0], ELEMENTS(g_aArgsPGMR3PhysReadUxx), REMFNDESC_FLAGS_RET_INT, sizeof(uint16_t), NULL },
1035	{ "PGMR3PhysWriteByte", (void *)(uintptr_t)&PGMR3PhysWriteByte, &g_aArgsPGMR3PhysWriteU8[0], ELEMENTS(g_aArgsPGMR3PhysWriteU8), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1036	{ "PGMR3PhysWriteDword", (void *)(uintptr_t)&PGMR3PhysWriteDword, &g_aArgsPGMR3PhysWriteU32[0], ELEMENTS(g_aArgsPGMR3PhysWriteU32), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1037	{ "PGMR3PhysWriteWord", (void *)(uintptr_t)&PGMR3PhysWriteWord, &g_aArgsPGMR3PhysWriteU16[0], ELEMENTS(g_aArgsPGMR3PhysWriteU16), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1038	{ "SSMR3GetGCPtr", (void *)(uintptr_t)&SSMR3GetGCPtr, &g_aArgsSSMR3GetGCPtr[0], ELEMENTS(g_aArgsSSMR3GetGCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1039	{ "SSMR3GetMem", (void *)(uintptr_t)&SSMR3GetMem, &g_aArgsSSMR3GetMem[0], ELEMENTS(g_aArgsSSMR3GetMem), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1040	{ "SSMR3GetU32", (void *)(uintptr_t)&SSMR3GetU32, &g_aArgsSSMR3GetU32[0], ELEMENTS(g_aArgsSSMR3GetU32), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1041	{ "SSMR3GetUInt", (void *)(uintptr_t)&SSMR3GetUInt, &g_aArgsSSMR3GetUInt[0], ELEMENTS(g_aArgsSSMR3GetUInt), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1042	{ "SSMR3PutGCPtr", (void *)(uintptr_t)&SSMR3PutGCPtr, &g_aArgsSSMR3PutGCPtr[0], ELEMENTS(g_aArgsSSMR3PutGCPtr), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1043	{ "SSMR3PutMem", (void *)(uintptr_t)&SSMR3PutMem, &g_aArgsSSMR3PutMem[0], ELEMENTS(g_aArgsSSMR3PutMem), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1044	{ "SSMR3PutU32", (void *)(uintptr_t)&SSMR3PutU32, &g_aArgsSSMR3PutU32[0], ELEMENTS(g_aArgsSSMR3PutU32), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1045	{ "SSMR3PutUInt", (void *)(uintptr_t)&SSMR3PutUInt, &g_aArgsSSMR3PutUInt[0], ELEMENTS(g_aArgsSSMR3PutUInt), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1046	{ "SSMR3RegisterInternal", (void *)(uintptr_t)&SSMR3RegisterInternal, &g_aArgsSSMR3RegisterInternal[0], ELEMENTS(g_aArgsSSMR3RegisterInternal), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1047	{ "STAMR3Register", (void *)(uintptr_t)&STAMR3Register, &g_aArgsSTAMR3Register[0], ELEMENTS(g_aArgsSTAMR3Register), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1048	{ "TMCpuTickGet", (void *)(uintptr_t)&TMCpuTickGet, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
1049	{ "TMCpuTickPause", (void *)(uintptr_t)&TMCpuTickPause, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1050	{ "TMCpuTickResume", (void *)(uintptr_t)&TMCpuTickResume, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1051	{ "TMTimerPoll", (void *)(uintptr_t)&TMTimerPoll, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(uint64_t), NULL },
1052	{ "TMR3TimerQueuesDo", (void *)(uintptr_t)&TMR3TimerQueuesDo, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1053	{ "TMVirtualPause", (void *)(uintptr_t)&TMVirtualPause, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1054	{ "TMVirtualResume", (void *)(uintptr_t)&TMVirtualResume, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1055	{ "TRPMAssertTrap", (void *)(uintptr_t)&TRPMAssertTrap, &g_aArgsTRPMAssertTrap[0], ELEMENTS(g_aArgsTRPMAssertTrap), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1056	{ "TRPMGetErrorCode", (void *)(uintptr_t)&TRPMGetErrorCode, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(RTGCUINT), NULL },
1057	{ "TRPMGetFaultAddress", (void *)(uintptr_t)&TRPMGetFaultAddress, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(RTGCUINTPTR),NULL },
1058	{ "TRPMQueryTrap", (void *)(uintptr_t)&TRPMQueryTrap, &g_aArgsTRPMQueryTrap[0], ELEMENTS(g_aArgsTRPMQueryTrap), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1059	{ "TRPMResetTrap", (void *)(uintptr_t)&TRPMResetTrap, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1060	{ "TRPMSetErrorCode", (void *)(uintptr_t)&TRPMSetErrorCode, &g_aArgsTRPMSetErrorCode[0], ELEMENTS(g_aArgsTRPMSetErrorCode), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1061	{ "TRPMSetFaultAddress", (void *)(uintptr_t)&TRPMSetFaultAddress, &g_aArgsTRPMSetFaultAddress[0], ELEMENTS(g_aArgsTRPMSetFaultAddress), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1062	{ "VMMR3Lock", (void *)(uintptr_t)&VMMR3Lock, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1063	{ "VMMR3Unlock", (void *)(uintptr_t)&VMMR3Unlock, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1064	{ "VMR3ReqCall", (void *)(uintptr_t)&VMR3ReqCall, &g_aArgsVMR3ReqCall[0], ELEMENTS(g_aArgsVMR3ReqCall), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1065	{ "VMR3ReqFree", (void *)(uintptr_t)&VMR3ReqFree, &g_aArgsVMR3ReqFree[0], ELEMENTS(g_aArgsVMR3ReqFree), REMFNDESC_FLAGS_RET_INT \| REMFNDESC_FLAGS_ELLIPSIS, sizeof(int), NULL },
1066	// { "", (void *)(uintptr_t)&, &g_aArgsVM[0], ELEMENTS(g_aArgsVM), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1067	};
1068
1069
1070	/**
1071	* Descriptors for the functions imported from VBoxRT.
1072	*/
1073	static REMFNDESC g_aRTImports[] =
1074	{
1075	{ "AssertMsg1", (void *)(uintptr_t)&AssertMsg1, &g_aArgsAssertMsg1[0], ELEMENTS(g_aArgsAssertMsg1), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1076	{ "AssertMsg2", (void *)(uintptr_t)&AssertMsg2, &g_aArgsAssertMsg2[0], ELEMENTS(g_aArgsAssertMsg2), REMFNDESC_FLAGS_RET_VOID \| REMFNDESC_FLAGS_ELLIPSIS, 0, NULL },
1077	{ "RTAssertDoBreakpoint", (void *)(uintptr_t)&RTAssertDoBreakpoint, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(bool), NULL },
1078	{ "RTLogDefaultInstance", (void *)(uintptr_t)&RTLogDefaultInstance, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(PRTLOGGER), NULL },
1079	{ "RTLogRelDefaultInstance", (void *)(uintptr_t)&RTLogRelDefaultInstance, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(PRTLOGGER), NULL },
1080	{ "RTLogFlags", (void *)(uintptr_t)&RTLogFlags, &g_aArgsRTLogFlags[0], ELEMENTS(g_aArgsRTLogFlags), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1081	{ "RTLogLoggerEx", (void *)(uintptr_t)&RTLogLoggerEx, &g_aArgsRTLogLoggerEx[0], ELEMENTS(g_aArgsRTLogLoggerEx), REMFNDESC_FLAGS_RET_VOID \| REMFNDESC_FLAGS_ELLIPSIS, 0, NULL },
1082	{ "RTLogLoggerExV", (void *)(uintptr_t)&RTLogLoggerExV, &g_aArgsRTLogLoggerExV[0], ELEMENTS(g_aArgsRTLogLoggerExV), REMFNDESC_FLAGS_RET_VOID \| REMFNDESC_FLAGS_VALIST, 0, NULL },
1083	{ "RTLogPrintf", (void *)(uintptr_t)&RTLogPrintf, &g_aArgsRTLogPrintf[0], ELEMENTS(g_aArgsRTLogPrintf), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1084	{ "RTMemAlloc", (void )(uintptr_t)&RTMemAlloc, &g_aArgsSIZE_T[0], ELEMENTS(g_aArgsSIZE_T), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1085	{ "RTMemExecAlloc", (void )(uintptr_t)&RTMemExecAlloc, &g_aArgsSIZE_T[0], ELEMENTS(g_aArgsSIZE_T), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1086	{ "RTMemExecFree", (void *)(uintptr_t)&RTMemExecFree, &g_aArgsPTR[0], ELEMENTS(g_aArgsPTR), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1087	{ "RTMemFree", (void *)(uintptr_t)&RTMemFree, &g_aArgsPTR[0], ELEMENTS(g_aArgsPTR), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1088	{ "RTMemPageAlloc", (void )(uintptr_t)&RTMemPageAlloc, &g_aArgsSIZE_T[0], ELEMENTS(g_aArgsSIZE_T), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1089	{ "RTMemPageFree", (void *)(uintptr_t)&RTMemPageFree, &g_aArgsPTR[0], ELEMENTS(g_aArgsPTR), REMFNDESC_FLAGS_RET_VOID, 0, NULL },
1090	{ "RTMemProtect", (void *)(uintptr_t)&RTMemProtect, &g_aArgsRTMemProtect[0], ELEMENTS(g_aArgsRTMemProtect), REMFNDESC_FLAGS_RET_INT, sizeof(int), NULL },
1091	{ "RTStrPrintf", (void *)(uintptr_t)&RTStrPrintf, &g_aArgsRTStrPrintf[0], ELEMENTS(g_aArgsRTStrPrintf), REMFNDESC_FLAGS_RET_INT \| REMFNDESC_FLAGS_ELLIPSIS, sizeof(size_t), NULL },
1092	{ "RTStrPrintfV", (void *)(uintptr_t)&RTStrPrintfV, &g_aArgsRTStrPrintfV[0], ELEMENTS(g_aArgsRTStrPrintfV), REMFNDESC_FLAGS_RET_INT \| REMFNDESC_FLAGS_VALIST, sizeof(size_t), NULL },
1093	{ "RTThreadNativeSelf", (void *)(uintptr_t)&RTThreadNativeSelf, NULL, 0, REMFNDESC_FLAGS_RET_INT, sizeof(RTNATIVETHREAD), NULL },
1094	};
1095
1096
1097	/**
1098	* Descriptors for the functions imported from VBoxRT.
1099	*/
1100	static REMFNDESC g_aCRTImports[] =
1101	{
1102	{ "memcpy", (void )(uintptr_t)&memcpy, &g_aArgsmemcpy[0], ELEMENTS(g_aArgsmemcpy), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL },
1103	{ "memset", (void )(uintptr_t)&memset, &g_aArgsmemset[0], ELEMENTS(g_aArgsmemset), REMFNDESC_FLAGS_RET_INT, sizeof(void ), NULL }
1104	/*
1105	floor floor
1106	memcpy memcpy
1107	sqrt sqrt
1108	sqrtf sqrtf
1109	*/
1110	};
1111
1112
1113	# if defined(USE_REM_CALLING_CONVENTION_GLUE) \|\| defined(USE_REM_IMPORT_JUMP_GLUE)
1114	/** LIFO of read-write-executable memory chunks used for wrappers. */
1115	static PREMEXECMEM g_pExecMemHead;
1116	# endif
1117
1118
1119	/*******************************************************************************
1120	* Internal Functions *
1121	*******************************************************************************/
1122	static int remGenerateExportGlue(PRTUINTPTR pValue, PCREMFNDESC pDesc);
1123
1124	# ifdef USE_REM_CALLING_CONVENTION_GLUE
1125	DECLASM(int) WrapGCC2MSC0Int(void); DECLASM(int) WrapGCC2MSC0Int_EndProc(void);
1126	DECLASM(int) WrapGCC2MSC1Int(void); DECLASM(int) WrapGCC2MSC1Int_EndProc(void);
1127	DECLASM(int) WrapGCC2MSC2Int(void); DECLASM(int) WrapGCC2MSC2Int_EndProc(void);
1128	DECLASM(int) WrapGCC2MSC3Int(void); DECLASM(int) WrapGCC2MSC3Int_EndProc(void);
1129	DECLASM(int) WrapGCC2MSC4Int(void); DECLASM(int) WrapGCC2MSC4Int_EndProc(void);
1130	DECLASM(int) WrapGCC2MSC5Int(void); DECLASM(int) WrapGCC2MSC5Int_EndProc(void);
1131	DECLASM(int) WrapGCC2MSC6Int(void); DECLASM(int) WrapGCC2MSC6Int_EndProc(void);
1132	DECLASM(int) WrapGCC2MSC7Int(void); DECLASM(int) WrapGCC2MSC7Int_EndProc(void);
1133	DECLASM(int) WrapGCC2MSC8Int(void); DECLASM(int) WrapGCC2MSC8Int_EndProc(void);
1134	DECLASM(int) WrapGCC2MSC9Int(void); DECLASM(int) WrapGCC2MSC9Int_EndProc(void);
1135	DECLASM(int) WrapGCC2MSC10Int(void); DECLASM(int) WrapGCC2MSC10Int_EndProc(void);
1136	DECLASM(int) WrapGCC2MSC11Int(void); DECLASM(int) WrapGCC2MSC11Int_EndProc(void);
1137	DECLASM(int) WrapGCC2MSC12Int(void); DECLASM(int) WrapGCC2MSC12Int_EndProc(void);
1138	DECLASM(int) WrapGCC2MSCVariadictInt(void); DECLASM(int) WrapGCC2MSCVariadictInt_EndProc(void);
1139	DECLASM(int) WrapGCC2MSC_SSMR3RegisterInternal(void); DECLASM(int) WrapGCC2MSC_SSMR3RegisterInternal_EndProc(void);
1140
1141	DECLASM(int) WrapMSC2GCC0Int(void); DECLASM(int) WrapMSC2GCC0Int_EndProc(void);
1142	DECLASM(int) WrapMSC2GCC1Int(void); DECLASM(int) WrapMSC2GCC1Int_EndProc(void);
1143	DECLASM(int) WrapMSC2GCC2Int(void); DECLASM(int) WrapMSC2GCC2Int_EndProc(void);
1144	DECLASM(int) WrapMSC2GCC3Int(void); DECLASM(int) WrapMSC2GCC3Int_EndProc(void);
1145	DECLASM(int) WrapMSC2GCC4Int(void); DECLASM(int) WrapMSC2GCC4Int_EndProc(void);
1146	DECLASM(int) WrapMSC2GCC5Int(void); DECLASM(int) WrapMSC2GCC5Int_EndProc(void);
1147	DECLASM(int) WrapMSC2GCC6Int(void); DECLASM(int) WrapMSC2GCC6Int_EndProc(void);
1148	DECLASM(int) WrapMSC2GCC7Int(void); DECLASM(int) WrapMSC2GCC7Int_EndProc(void);
1149	DECLASM(int) WrapMSC2GCC8Int(void); DECLASM(int) WrapMSC2GCC8Int_EndProc(void);
1150	DECLASM(int) WrapMSC2GCC9Int(void); DECLASM(int) WrapMSC2GCC9Int_EndProc(void);
1151	# endif
1152
1153
1154	# if defined(USE_REM_CALLING_CONVENTION_GLUE) \|\| defined(USE_REM_IMPORT_JUMP_GLUE)
1155	/**
1156	* Allocates a block of memory for glue code.
1157	*
1158	* The returned memory is padded with INT3s.
1159	*
1160	* @returns Pointer to the allocated memory.
1161	* @param The amount of memory to allocate.
1162	*/
1163	static void *remAllocGlue(size_t cb)
1164	{
1165	PREMEXECMEM pCur = g_pExecMemHead;
1166	uint32_t cbAligned = (uint32_t)RT_ALIGN_32(cb, 32);
1167	while (pCur)
1168	{
1169	if (pCur->cb - pCur->off >= cbAligned)
1170	{
1171	void pv = (uint8_t )pCur + pCur->off;
1172	pCur->off += cbAligned;
1173	return memset(pv, 0xcc, cbAligned);
1174	}
1175	pCur = pCur->pNext;
1176	}
1177
1178	/* add a new chunk */
1179	AssertReturn(_64K - RT_ALIGN_Z(sizeof(*pCur), 32) > cbAligned, NULL);
1180	pCur = (PREMEXECMEM)RTMemExecAlloc(_64K);
1181	AssertReturn(pCur, NULL);
1182	pCur->cb = _64K;
1183	pCur->off = RT_ALIGN_32(sizeof(*pCur), 32) + cbAligned;
1184	pCur->pNext = g_pExecMemHead;
1185	g_pExecMemHead = pCur;
1186	return memset((uint8_t )pCur + RT_ALIGN_Z(sizeof(pCur), 32), 0xcc, cbAligned);
1187	}
1188	# endif /* USE_REM_CALLING_CONVENTION_GLUE \|\| USE_REM_IMPORT_JUMP_GLUE */
1189
1190
1191	# ifdef USE_REM_CALLING_CONVENTION_GLUE
1192	/**
1193	* Checks if a function is all straight forward integers.
1194	*
1195	* @returns True if it's simple, false if it's bothersome.
1196	* @param pDesc The function descriptor.
1197	*/
1198	static bool remIsFunctionAllInts(PCREMFNDESC pDesc)
1199	{
1200	if ( ( (pDesc->fFlags & REMFNDESC_FLAGS_RET_TYPE_MASK) != REMFNDESC_FLAGS_RET_INT
1201	\|\| pDesc->cbReturn > sizeof(uint64_t))
1202	&& (pDesc->fFlags & REMFNDESC_FLAGS_RET_TYPE_MASK) != REMFNDESC_FLAGS_RET_VOID)
1203	return false;
1204	unsigned i = pDesc->cParams;
1205	while (i-- > 0)
1206	switch (pDesc->paParams[i].fFlags & REMPARMDESC_FLAGS_TYPE_MASK)
1207	{
1208	case REMPARMDESC_FLAGS_INT:
1209	case REMPARMDESC_FLAGS_GCPTR:
1210	case REMPARMDESC_FLAGS_GCPHYS:
1211	case REMPARMDESC_FLAGS_HCPHYS:
1212	break;
1213
1214	default:
1215	AssertReleaseMsgFailed(("Invalid param flags %#x for #%d of %s!\n", pDesc->paParams[i].fFlags, i, pDesc->pszName));
1216	case REMPARMDESC_FLAGS_VALIST:
1217	case REMPARMDESC_FLAGS_ELLIPSIS:
1218	case REMPARMDESC_FLAGS_FLOAT:
1219	case REMPARMDESC_FLAGS_STRUCT:
1220	case REMPARMDESC_FLAGS_PFN:
1221	return false;
1222	}
1223	return true;
1224	}
1225
1226
1227	/**
1228	* Checks if the function has an ellipsis (...) argument.
1229	*
1230	* @returns true if it has an ellipsis, otherwise false.
1231	* @param pDesc The function descriptor.
1232	*/
1233	static bool remHasFunctionEllipsis(PCREMFNDESC pDesc)
1234	{
1235	unsigned i = pDesc->cParams;
1236	while (i-- > 0)
1237	if ((pDesc->paParams[i].fFlags & REMPARMDESC_FLAGS_TYPE_MASK) == REMPARMDESC_FLAGS_ELLIPSIS)
1238	return true;
1239	return false;
1240	}
1241
1242
1243	/**
1244	* Checks if the function uses floating point (FP) arguments or return value.
1245	*
1246	* @returns true if it uses floating point, otherwise false.
1247	* @param pDesc The function descriptor.
1248	*/
1249	static bool remIsFunctionUsingFP(PCREMFNDESC pDesc)
1250	{
1251	if ((pDesc->fFlags & REMFNDESC_FLAGS_RET_TYPE_MASK) == REMFNDESC_FLAGS_RET_FLOAT)
1252	return true;
1253	unsigned i = pDesc->cParams;
1254	while (i-- > 0)
1255	if ((pDesc->paParams[i].fFlags & REMPARMDESC_FLAGS_TYPE_MASK) == REMPARMDESC_FLAGS_FLOAT)
1256	return true;
1257	return false;
1258	}
1259
1260
1261	/** @name The export and import fixups.
1262	* @{ */
1263	#define REM_FIXUP_32_REAL_STUFF UINT32_C(0xdeadbeef)
1264	#define REM_FIXUP_64_REAL_STUFF UINT64_C(0xdeadf00df00ddead)
1265	#define REM_FIXUP_64_DESC UINT64_C(0xdead00010001dead)
1266	#define REM_FIXUP_64_LOG_ENTRY UINT64_C(0xdead00020002dead)
1267	#define REM_FIXUP_64_LOG_EXIT UINT64_C(0xdead00030003dead)
1268	#define REM_FIXUP_64_WRAP_GCC_CB UINT64_C(0xdead00040004dead)
1269	/** @} */
1270
1271
1272	/**
1273	* Entry logger function.
1274	*
1275	* @param pDesc The description.
1276	*/
1277	DECLASM(void) remLogEntry(PCREMFNDESC pDesc)
1278	{
1279	RTPrintf("calling %s\n", pDesc->pszName);
1280	}
1281
1282
1283	/**
1284	* Exit logger function.
1285	*
1286	* @param pDesc The description.
1287	* @param pvRet The return code.
1288	*/
1289	DECLASM(void) remLogExit(PCREMFNDESC pDesc, void *pvRet)
1290	{
1291	RTPrintf("returning %p from %s\n", pvRet, pDesc->pszName);
1292	}
1293
1294
1295	/**
1296	* Creates a wrapper for the specified callback function at run time.
1297	*
1298	* @param pDesc The function descriptor.
1299	* @param pValue Upon entry *pValue contains the address of the function to be wrapped.
1300	* Upon return *pValue contains the address of the wrapper glue function.
1301	* @param iParam The parameter index in the function descriptor (0 based).
1302	* If UINT32_MAX pDesc is the descriptor for *pValue.
1303	*/
1304	DECLASM(void) remWrapGCCCallback(PCREMFNDESC pDesc, PRTUINTPTR pValue, uint32_t iParam)
1305	{
1306	AssertPtr(pDesc);
1307	AssertPtr(pValue);
1308
1309	/*
1310	* Simple?
1311	*/
1312	if (!*pValue)
1313	return;
1314
1315	/*
1316	* Locate the right function descriptor.
1317	*/
1318	if (iParam != UINT32_MAX)
1319	{
1320	AssertRelease(iParam < pDesc->cParams);
1321	pDesc = (PCREMFNDESC)pDesc->paParams[iParam].pvExtra;
1322	AssertPtr(pDesc);
1323	}
1324
1325	/*
1326	* When we get serious, here is where to insert the hash table lookup.
1327	*/
1328
1329	/*
1330	* Create a new glue patch.
1331	*/
1332	#ifdef RT_OS_WINDOWS
1333	int rc = remGenerateExportGlue(pValue, pDesc);
1334	#else
1335	#error "port me"
1336	#endif
1337	AssertReleaseRC(rc);
1338
1339	/*
1340	* Add it to the hash (later)
1341	*/
1342	}
1343
1344
1345	/**
1346	* Fixes export glue.
1347	*
1348	* @param pvGlue The glue code.
1349	* @param cb The size of the glue code.
1350	* @param pvExport The address of the export we're wrapping.
1351	* @param pDesc The export descriptor.
1352	*/
1353	static void remGenerateExportGlueFixup(void *pvGlue, size_t cb, uintptr_t uExport, PCREMFNDESC pDesc)
1354	{
1355	union
1356	{
1357	uint8_t *pu8;
1358	int32_t *pi32;
1359	uint32_t *pu32;
1360	uint64_t *pu64;
1361	void *pv;
1362	} u;
1363	u.pv = pvGlue;
1364
1365	while (cb >= 4)
1366	{
1367	/** @todo add defines for the fixup constants... */
1368	if (*u.pu32 == REM_FIXUP_32_REAL_STUFF)
1369	{
1370	/* 32-bit rel jmp/call to real export. */
1371	*u.pi32 = uExport - (uintptr_t)(u.pi32 + 1);
1372	Assert((uintptr_t)(u.pi32 + 1) + *u.pi32 == uExport);
1373	u.pi32++;
1374	cb -= 4;
1375	continue;
1376	}
1377	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_REAL_STUFF)
1378	{
1379	/* 64-bit address to the real export. */
1380	*u.pu64++ = uExport;
1381	cb -= 8;
1382	continue;
1383	}
1384	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_DESC)
1385	{
1386	/* 64-bit address to the descriptor. */
1387	*u.pu64++ = (uintptr_t)pDesc;
1388	cb -= 8;
1389	continue;
1390	}
1391	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_WRAP_GCC_CB)
1392	{
1393	/* 64-bit address to the entry logger function. */
1394	*u.pu64++ = (uintptr_t)remWrapGCCCallback;
1395	cb -= 8;
1396	continue;
1397	}
1398	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_ENTRY)
1399	{
1400	/* 64-bit address to the entry logger function. */
1401	*u.pu64++ = (uintptr_t)remLogEntry;
1402	cb -= 8;
1403	continue;
1404	}
1405	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_EXIT)
1406	{
1407	/* 64-bit address to the entry logger function. */
1408	*u.pu64++ = (uintptr_t)remLogExit;
1409	cb -= 8;
1410	continue;
1411	}
1412
1413	/* move on. */
1414	u.pu8++;
1415	cb--;
1416	}
1417	}
1418
1419
1420	/**
1421	* Fixes import glue.
1422	*
1423	* @param pvGlue The glue code.
1424	* @param cb The size of the glue code.
1425	* @param pDesc The import descriptor.
1426	*/
1427	static void remGenerateImportGlueFixup(void *pvGlue, size_t cb, PCREMFNDESC pDesc)
1428	{
1429	union
1430	{
1431	uint8_t *pu8;
1432	int32_t *pi32;
1433	uint32_t *pu32;
1434	uint64_t *pu64;
1435	void *pv;
1436	} u;
1437	u.pv = pvGlue;
1438
1439	while (cb >= 4)
1440	{
1441	if (*u.pu32 == REM_FIXUP_32_REAL_STUFF)
1442	{
1443	/* 32-bit rel jmp/call to real function. */
1444	*u.pi32 = (uintptr_t)pDesc->pv - (uintptr_t)(u.pi32 + 1);
1445	Assert((uintptr_t)(u.pi32 + 1) + *u.pi32 == (uintptr_t)pDesc->pv);
1446	u.pi32++;
1447	cb -= 4;
1448	continue;
1449	}
1450	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_REAL_STUFF)
1451	{
1452	/* 64-bit address to the real function. */
1453	*u.pu64++ = (uintptr_t)pDesc->pv;
1454	cb -= 8;
1455	continue;
1456	}
1457	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_DESC)
1458	{
1459	/* 64-bit address to the descriptor. */
1460	*u.pu64++ = (uintptr_t)pDesc;
1461	cb -= 8;
1462	continue;
1463	}
1464	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_WRAP_GCC_CB)
1465	{
1466	/* 64-bit address to the entry logger function. */
1467	*u.pu64++ = (uintptr_t)remWrapGCCCallback;
1468	cb -= 8;
1469	continue;
1470	}
1471	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_ENTRY)
1472	{
1473	/* 64-bit address to the entry logger function. */
1474	*u.pu64++ = (uintptr_t)remLogEntry;
1475	cb -= 8;
1476	continue;
1477	}
1478	if (cb >= 8 && *u.pu64 == REM_FIXUP_64_LOG_EXIT)
1479	{
1480	/* 64-bit address to the entry logger function. */
1481	*u.pu64++ = (uintptr_t)remLogExit;
1482	cb -= 8;
1483	continue;
1484	}
1485
1486	/* move on. */
1487	u.pu8++;
1488	cb--;
1489	}
1490	}
1491
1492	# endif /* USE_REM_CALLING_CONVENTION_GLUE */
1493
1494
1495	/**
1496	* Generate wrapper glue code for an export.
1497	*
1498	* This is only used on win64 when loading a 64-bit linux module. So, on other
1499	* platforms it will not do anything.
1500	*
1501	* @returns VBox status code.
1502	* @param pValue IN: Where to get the address of the function to wrap.
1503	* OUT: Where to store the glue address.
1504	* @param pDesc The export descriptor.
1505	*/
1506	static int remGenerateExportGlue(PRTUINTPTR pValue, PCREMFNDESC pDesc)
1507	{
1508	# ifdef USE_REM_CALLING_CONVENTION_GLUE
1509	uintptr_t ppfn = (uintptr_t )pDesc->pv;
1510
1511	uintptr_t pfn = 0; /* a little hack for the callback glue */
1512	if (!ppfn)
1513	ppfn = &pfn;
1514
1515	if (!*ppfn)
1516	{
1517	if (remIsFunctionAllInts(pDesc))
1518	{
1519	static const struct { void pvStart, pvEnd; } s_aTemplates[] =
1520	{
1521	{ (void )&WrapMSC2GCC0Int, (void )&WrapMSC2GCC0Int_EndProc },
1522	{ (void )&WrapMSC2GCC1Int, (void )&WrapMSC2GCC1Int_EndProc },
1523	{ (void )&WrapMSC2GCC2Int, (void )&WrapMSC2GCC2Int_EndProc },
1524	{ (void )&WrapMSC2GCC3Int, (void )&WrapMSC2GCC3Int_EndProc },
1525	{ (void )&WrapMSC2GCC4Int, (void )&WrapMSC2GCC4Int_EndProc },
1526	{ (void )&WrapMSC2GCC5Int, (void )&WrapMSC2GCC5Int_EndProc },
1527	{ (void )&WrapMSC2GCC6Int, (void )&WrapMSC2GCC6Int_EndProc },
1528	{ (void )&WrapMSC2GCC7Int, (void )&WrapMSC2GCC7Int_EndProc },
1529	{ (void )&WrapMSC2GCC8Int, (void )&WrapMSC2GCC8Int_EndProc },
1530	{ (void )&WrapMSC2GCC9Int, (void )&WrapMSC2GCC9Int_EndProc },
1531	};
1532	const unsigned i = pDesc->cParams;
1533	AssertReleaseMsg(i < ELEMENTS(s_aTemplates), ("%d (%s)\n", i, pDesc->pszName));
1534
1535	/* duplicate the patch. */
1536	const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
1537	uint8_t pb = (uint8_t )remAllocGlue(cb);
1538	AssertReturn(pb, VERR_NO_MEMORY);
1539	memcpy(pb, s_aTemplates[i].pvStart, cb);
1540
1541	/* fix it up. */
1542	remGenerateExportGlueFixup(pb, cb, *pValue, pDesc);
1543	*ppfn = (uintptr_t)pb;
1544	}
1545	else
1546	{
1547	/* custom hacks - it's simpler to make assembly templates than writing a more generic code generator... */
1548	static const struct { const char *pszName; PFNRT pvStart, pvEnd; } s_aTemplates[] =
1549	{
1550	{ "somefunction", (PFNRT)&WrapMSC2GCC9Int, (PFNRT)&WrapMSC2GCC9Int_EndProc },
1551	};
1552	unsigned i;
1553	for (i = 0; i < RT_ELEMENTS(s_aTemplates); i++)
1554	if (!strcmp(pDesc->pszName, s_aTemplates[i].pszName))
1555	break;
1556	AssertReleaseMsgReturn(i < RT_ELEMENTS(s_aTemplates), ("Not implemented! %s\n", pDesc->pszName), VERR_NOT_IMPLEMENTED);
1557
1558	/* duplicate the patch. */
1559	const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
1560	uint8_t pb = (uint8_t )remAllocGlue(cb);
1561	AssertReturn(pb, VERR_NO_MEMORY);
1562	memcpy(pb, s_aTemplates[i].pvStart, cb);
1563
1564	/* fix it up. */
1565	remGenerateExportGlueFixup(pb, cb, *pValue, pDesc);
1566	*ppfn = (uintptr_t)pb;
1567	}
1568	}
1569	pValue = ppfn;
1570	return VINF_SUCCESS;
1571	# else /* !USE_REM_CALLING_CONVENTION_GLUE */
1572	return VINF_SUCCESS;
1573	# endif /* !USE_REM_CALLING_CONVENTION_GLUE */
1574	}
1575
1576
1577	/**
1578	* Generate wrapper glue code for an import.
1579	*
1580	* This is only used on win64 when loading a 64-bit linux module. So, on other
1581	* platforms it will simply return the address of the imported function
1582	* without generating any glue code.
1583	*
1584	* @returns VBox status code.
1585	* @param pValue Where to store the glue address.
1586	* @param pDesc The export descriptor.
1587	*/
1588	static int remGenerateImportGlue(PRTUINTPTR pValue, PREMFNDESC pDesc)
1589	{
1590	# if defined(USE_REM_CALLING_CONVENTION_GLUE) \|\| defined(USE_REM_IMPORT_JUMP_GLUE)
1591	if (!pDesc->pvWrapper)
1592	{
1593	# ifdef USE_REM_CALLING_CONVENTION_GLUE
1594	if (remIsFunctionAllInts(pDesc))
1595	{
1596	static const struct { void pvStart, pvEnd; } s_aTemplates[] =
1597	{
1598	{ (void )&WrapGCC2MSC0Int, (void )&WrapGCC2MSC0Int_EndProc },
1599	{ (void )&WrapGCC2MSC1Int, (void )&WrapGCC2MSC1Int_EndProc },
1600	{ (void )&WrapGCC2MSC2Int, (void )&WrapGCC2MSC2Int_EndProc },
1601	{ (void )&WrapGCC2MSC3Int, (void )&WrapGCC2MSC3Int_EndProc },
1602	{ (void )&WrapGCC2MSC4Int, (void )&WrapGCC2MSC4Int_EndProc },
1603	{ (void )&WrapGCC2MSC5Int, (void )&WrapGCC2MSC5Int_EndProc },
1604	{ (void )&WrapGCC2MSC6Int, (void )&WrapGCC2MSC6Int_EndProc },
1605	{ (void )&WrapGCC2MSC7Int, (void )&WrapGCC2MSC7Int_EndProc },
1606	{ (void )&WrapGCC2MSC8Int, (void )&WrapGCC2MSC8Int_EndProc },
1607	{ (void )&WrapGCC2MSC9Int, (void )&WrapGCC2MSC9Int_EndProc },
1608	{ (void )&WrapGCC2MSC10Int, (void )&WrapGCC2MSC10Int_EndProc },
1609	{ (void )&WrapGCC2MSC11Int, (void )&WrapGCC2MSC11Int_EndProc },
1610	{ (void )&WrapGCC2MSC12Int, (void )&WrapGCC2MSC12Int_EndProc }
1611	};
1612	const unsigned i = pDesc->cParams;
1613	AssertReleaseMsg(i < ELEMENTS(s_aTemplates), ("%d (%s)\n", i, pDesc->pszName));
1614
1615	/* duplicate the patch. */
1616	const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
1617	pDesc->pvWrapper = remAllocGlue(cb);
1618	AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
1619	memcpy(pDesc->pvWrapper, s_aTemplates[i].pvStart, cb);
1620
1621	/* fix it up. */
1622	remGenerateImportGlueFixup((uint8_t *)pDesc->pvWrapper, cb, pDesc);
1623	}
1624	else if ( remHasFunctionEllipsis(pDesc)
1625	&& !remIsFunctionUsingFP(pDesc))
1626	{
1627	/* duplicate the patch. */
1628	const size_t cb = (uintptr_t)&WrapGCC2MSCVariadictInt_EndProc - (uintptr_t)&WrapGCC2MSCVariadictInt;
1629	pDesc->pvWrapper = remAllocGlue(cb);
1630	AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
1631	memcpy(pDesc->pvWrapper, (void *)&WrapGCC2MSCVariadictInt, cb);
1632
1633	/* fix it up. */
1634	remGenerateImportGlueFixup((uint8_t *)pDesc->pvWrapper, cb, pDesc);
1635	}
1636	else
1637	{
1638	/* custom hacks - it's simpler to make assembly templates than writing a more generic code generator... */
1639	static const struct { const char *pszName; PFNRT pvStart, pvEnd; } s_aTemplates[] =
1640	{
1641	{ "SSMR3RegisterInternal", (PFNRT)&WrapGCC2MSC_SSMR3RegisterInternal, (PFNRT)&WrapGCC2MSC_SSMR3RegisterInternal_EndProc },
1642	};
1643	unsigned i;
1644	for (i = 0; i < RT_ELEMENTS(s_aTemplates); i++)
1645	if (!strcmp(pDesc->pszName, s_aTemplates[i].pszName))
1646	break;
1647	AssertReleaseMsgReturn(i < RT_ELEMENTS(s_aTemplates), ("Not implemented! %s\n", pDesc->pszName), VERR_NOT_IMPLEMENTED);
1648
1649	/* duplicate the patch. */
1650	const size_t cb = (uintptr_t)s_aTemplates[i].pvEnd - (uintptr_t)s_aTemplates[i].pvStart;
1651	pDesc->pvWrapper = remAllocGlue(cb);
1652	AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
1653	memcpy(pDesc->pvWrapper, s_aTemplates[i].pvStart, cb);
1654
1655	/* fix it up. */
1656	remGenerateImportGlueFixup((uint8_t *)pDesc->pvWrapper, cb, pDesc);
1657	}
1658	# else /* !USE_REM_CALLING_CONVENTION_GLUE */
1659
1660	/*
1661	* Generate a jump patch.
1662	*/
1663	uint8_t *pb;
1664	# ifdef RT_ARCH_AMD64
1665	pDesc->pvWrapper = pb = (uint8_t *)remAllocGlue(32);
1666	AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
1667	/*pb++ = 0xcc;/
1668	*pb++ = 0xff;
1669	*pb++ = 0x24;
1670	*pb++ = 0x25;
1671	(uint32_t )pb = (uintptr_t)pb + 5;
1672	pb += 5;
1673	(uint64_t )pb = (uint64_t)pDesc->pv;
1674	# else
1675	pDesc->pvWrapper = pb = (uint8_t *)remAllocGlue(8);
1676	AssertReturn(pDesc->pvWrapper, VERR_NO_MEMORY);
1677	*pb++ = 0xea;
1678	(uint32_t )pb = (uint32_t)pDesc->pv;
1679	# endif
1680	# endif /* !USE_REM_CALLING_CONVENTION_GLUE */
1681	}
1682	*pValue = (uintptr_t)pDesc->pvWrapper;
1683	# else /* !USE_REM_CALLING_CONVENTION_GLUE */
1684	*pValue = (uintptr_t)pDesc->pv;
1685	# endif /* !USE_REM_CALLING_CONVENTION_GLUE */
1686	return VINF_SUCCESS;
1687	}
1688
1689
1690	/**
1691	* Resolve an external symbol during RTLdrGetBits().
1692	*
1693	* @returns iprt status code.
1694	* @param hLdrMod The loader module handle.
1695	* @param pszModule Module name.
1696	* @param pszSymbol Symbol name, NULL if uSymbol should be used.
1697	* @param uSymbol Symbol ordinal, ~0 if pszSymbol should be used.
1698	* @param pValue Where to store the symbol value (address).
1699	* @param pvUser User argument.
1700	*/
1701	static DECLCALLBACK(int) remGetImport(RTLDRMOD hLdrMod, const char pszModule, const char pszSymbol, unsigned uSymbol, RTUINTPTR pValue, void pvUser)
1702	{
1703	unsigned i;
1704	for (i = 0; i < ELEMENTS(g_aVMMImports); i++)
1705	if (!strcmp(g_aVMMImports[i].pszName, pszSymbol))
1706	return remGenerateImportGlue(pValue, &g_aVMMImports[i]);
1707	for (i = 0; i < ELEMENTS(g_aRTImports); i++)
1708	if (!strcmp(g_aRTImports[i].pszName, pszSymbol))
1709	return remGenerateImportGlue(pValue, &g_aRTImports[i]);
1710	for (i = 0; i < ELEMENTS(g_aCRTImports); i++)
1711	if (!strcmp(g_aCRTImports[i].pszName, pszSymbol))
1712	return remGenerateImportGlue(pValue, &g_aCRTImports[i]);
1713	LogRel(("Missing REM Import: %s\n", pszSymbol));
1714	#if 1
1715	*pValue = 0;
1716	AssertMsgFailed(("%s.%s\n", pszModule, pszSymbol));
1717	return VERR_SYMBOL_NOT_FOUND;
1718	#else
1719	return remGenerateImportGlue(pValue, &g_aCRTImports[0]);
1720	#endif
1721	}
1722
1723	/**
1724	* Loads the linux object, resolves all imports and exports.
1725	*
1726	* @returns VBox status code.
1727	*/
1728	static int remLoadLinuxObj(void)
1729	{
1730	size_t offFilename;
1731	char szPath[RTPATH_MAX];
1732	int rc = RTPathAppPrivateArch(szPath, sizeof(szPath) - 32);
1733	AssertRCReturn(rc, rc);
1734	offFilename = strlen(szPath);
1735
1736	/*
1737	* Load the VBoxREM2.rel object/DLL.
1738	*/
1739	strcpy(&szPath[offFilename], "/VBoxREM2.rel");
1740	rc = RTLdrOpen(szPath, &g_ModREM2);
1741	if (VBOX_SUCCESS(rc))
1742	{
1743	g_pvREM2 = RTMemExecAlloc(RTLdrSize(g_ModREM2));
1744	if (g_pvREM2)
1745	{
1746	#ifdef DEBUG /* How to load the VBoxREM2.rel symbols into the GNU debugger. */
1747	RTPrintf("VBoxREMWrapper: (gdb) add-symbol-file %s 0x%p\n", szPath, g_pvREM2);
1748	#endif
1749	LogRel(("REM: Loading %s at 0x%p (%d bytes)\n"
1750	"REM: (gdb) add-symbol-file %s 0x%p\n",
1751	szPath, g_pvREM2, RTLdrSize(g_ModREM2), szPath, g_pvREM2));
1752	rc = RTLdrGetBits(g_ModREM2, g_pvREM2, (RTUINTPTR)g_pvREM2, remGetImport, NULL);
1753	if (VBOX_SUCCESS(rc))
1754	{
1755	/*
1756	* Resolve exports.
1757	*/
1758	unsigned i;
1759	for (i = 0; i < ELEMENTS(g_aExports); i++)
1760	{
1761	RTUINTPTR Value;
1762	rc = RTLdrGetSymbolEx(g_ModREM2, g_pvREM2, (RTUINTPTR)g_pvREM2, g_aExports[i].pszName, &Value);
1763	AssertMsgRC(rc, ("%s rc=%VRc\n", g_aExports[i].pszName, rc));
1764	if (VBOX_FAILURE(rc))
1765	break;
1766	rc = remGenerateExportGlue(&Value, &g_aExports[i]);
1767	if (VBOX_FAILURE(rc))
1768	break;
1769	(void )g_aExports[i].pv = (void )(uintptr_t)Value;
1770	}
1771	return rc;
1772	}
1773	RTMemExecFree(g_pvREM2);
1774	}
1775	RTLdrClose(g_ModREM2);
1776	g_ModREM2 = NIL_RTLDRMOD;
1777	}
1778	return rc;
1779	}
1780
1781
1782	/**
1783	* Unloads the linux object, freeing up all resources (dlls and
1784	* import glue) we allocated during remLoadLinuxObj().
1785	*/
1786	static void remUnloadLinuxObj(void)
1787	{
1788	unsigned i;
1789
1790	/* close modules. */
1791	RTLdrClose(g_ModREM2);
1792	g_ModREM2 = NIL_RTLDRMOD;
1793	RTMemExecFree(g_pvREM2);
1794	g_pvREM2 = NULL;
1795
1796	/* clear the pointers. */
1797	for (i = 0; i < ELEMENTS(g_aExports); i++)
1798	(void *)g_aExports[i].pv = NULL;
1799	# if defined(USE_REM_CALLING_CONVENTION_GLUE) \|\| defined(USE_REM_IMPORT_JUMP_GLUE)
1800	for (i = 0; i < ELEMENTS(g_aVMMImports); i++)
1801	g_aVMMImports[i].pvWrapper = NULL;
1802	for (i = 0; i < ELEMENTS(g_aRTImports); i++)
1803	g_aRTImports[i].pvWrapper = NULL;
1804	for (i = 0; i < ELEMENTS(g_aCRTImports); i++)
1805	g_aCRTImports[i].pvWrapper = NULL;
1806
1807	/* free wrapper memory. */
1808	while (g_pExecMemHead)
1809	{
1810	PREMEXECMEM pCur = g_pExecMemHead;
1811	g_pExecMemHead = pCur->pNext;
1812	memset(pCur, 0xcc, pCur->cb);
1813	RTMemExecFree(pCur);
1814	}
1815	# endif
1816	}
1817	#endif
1818
1819
1820	REMR3DECL(int) REMR3Init(PVM pVM)
1821	{
1822	#ifdef USE_REM_STUBS
1823	return VINF_SUCCESS;
1824	#else
1825	if (!pfnREMR3Init)
1826	{
1827	int rc = remLoadLinuxObj();
1828	if (VBOX_FAILURE(rc))
1829	return rc;
1830	}
1831	return pfnREMR3Init(pVM);
1832	#endif
1833	}
1834
1835	REMR3DECL(int) REMR3Term(PVM pVM)
1836	{
1837	#ifdef USE_REM_STUBS
1838	return VINF_SUCCESS;
1839	#else
1840	int rc;
1841	Assert(VALID_PTR(pfnREMR3Term));
1842	rc = pfnREMR3Term(pVM);
1843	remUnloadLinuxObj();
1844	return rc;
1845	#endif
1846	}
1847
1848	REMR3DECL(void) REMR3Reset(PVM pVM)
1849	{
1850	#ifndef USE_REM_STUBS
1851	Assert(VALID_PTR(pfnREMR3Reset));
1852	pfnREMR3Reset(pVM);
1853	#endif
1854	}
1855
1856	REMR3DECL(int) REMR3Step(PVM pVM)
1857	{
1858	#ifdef USE_REM_STUBS
1859	return VERR_NOT_IMPLEMENTED;
1860	#else
1861	Assert(VALID_PTR(pfnREMR3Step));
1862	return pfnREMR3Step(pVM);
1863	#endif
1864	}
1865
1866	REMR3DECL(int) REMR3BreakpointSet(PVM pVM, RTGCUINTPTR Address)
1867	{
1868	#ifdef USE_REM_STUBS
1869	return VERR_REM_NO_MORE_BP_SLOTS;
1870	#else
1871	Assert(VALID_PTR(pfnREMR3BreakpointSet));
1872	return pfnREMR3BreakpointSet(pVM, Address);
1873	#endif
1874	}
1875
1876	REMR3DECL(int) REMR3BreakpointClear(PVM pVM, RTGCUINTPTR Address)
1877	{
1878	#ifdef USE_REM_STUBS
1879	return VERR_NOT_IMPLEMENTED;
1880	#else
1881	Assert(VALID_PTR(pfnREMR3BreakpointClear));
1882	return pfnREMR3BreakpointClear(pVM, Address);
1883	#endif
1884	}
1885
1886	REMR3DECL(int) REMR3EmulateInstruction(PVM pVM)
1887	{
1888	#ifdef USE_REM_STUBS
1889	return VERR_NOT_IMPLEMENTED;
1890	#else
1891	Assert(VALID_PTR(pfnREMR3EmulateInstruction));
1892	return pfnREMR3EmulateInstruction(pVM);
1893	#endif
1894	}
1895
1896	REMR3DECL(int) REMR3Run(PVM pVM)
1897	{
1898	#ifdef USE_REM_STUBS
1899	return VERR_NOT_IMPLEMENTED;
1900	#else
1901	Assert(VALID_PTR(pfnREMR3Run));
1902	return pfnREMR3Run(pVM);
1903	#endif
1904	}
1905
1906	REMR3DECL(int) REMR3State(PVM pVM)
1907	{
1908	#ifdef USE_REM_STUBS
1909	return VERR_NOT_IMPLEMENTED;
1910	#else
1911	Assert(VALID_PTR(pfnREMR3State));
1912	return pfnREMR3State(pVM);
1913	#endif
1914	}
1915
1916	REMR3DECL(int) REMR3StateBack(PVM pVM)
1917	{
1918	#ifdef USE_REM_STUBS
1919	return VERR_NOT_IMPLEMENTED;
1920	#else
1921	Assert(VALID_PTR(pfnREMR3StateBack));
1922	return pfnREMR3StateBack(pVM);
1923	#endif
1924	}
1925
1926	REMR3DECL(void) REMR3StateUpdate(PVM pVM)
1927	{
1928	#ifndef USE_REM_STUBS
1929	Assert(VALID_PTR(pfnREMR3StateUpdate));
1930	pfnREMR3StateUpdate(pVM);
1931	#endif
1932	}
1933
1934	REMR3DECL(void) REMR3A20Set(PVM pVM, bool fEnable)
1935	{
1936	#ifndef USE_REM_STUBS
1937	Assert(VALID_PTR(pfnREMR3A20Set));
1938	pfnREMR3A20Set(pVM, fEnable);
1939	#endif
1940	}
1941
1942	REMR3DECL(void) REMR3ReplayInvalidatedPages(PVM pVM)
1943	{
1944	#ifndef USE_REM_STUBS
1945	Assert(VALID_PTR(pfnREMR3ReplayInvalidatedPages));
1946	pfnREMR3ReplayInvalidatedPages(pVM);
1947	#endif
1948	}
1949
1950	REMR3DECL(void) REMR3ReplayHandlerNotifications(PVM pVM)
1951	{
1952	#ifndef USE_REM_STUBS
1953	Assert(VALID_PTR(pfnREMR3ReplayHandlerNotifications));
1954	pfnREMR3ReplayHandlerNotifications(pVM);
1955	#endif
1956	}
1957
1958	REMR3DECL(int) REMR3NotifyCodePageChanged(PVM pVM, RTGCPTR pvCodePage)
1959	{
1960	#ifdef USE_REM_STUBS
1961	return VINF_SUCCESS;
1962	#else
1963	Assert(VALID_PTR(pfnREMR3NotifyCodePageChanged));
1964	return pfnREMR3NotifyCodePageChanged(pVM, pvCodePage);
1965	#endif
1966	}
1967
1968	REMR3DECL(void) REMR3NotifyPhysRamRegister(PVM pVM, RTGCPHYS GCPhys, RTUINT cb, void *pvRam, unsigned fFlags)
1969	{
1970	#ifndef USE_REM_STUBS
1971	Assert(VALID_PTR(pfnREMR3NotifyPhysRamRegister));
1972	pfnREMR3NotifyPhysRamRegister(pVM, GCPhys, cb, pvRam, fFlags);
1973	#endif
1974	}
1975
1976	REMR3DECL(void) REMR3NotifyPhysRamChunkRegister(PVM pVM, RTGCPHYS GCPhys, RTUINT cb, RTHCUINTPTR pvRam, unsigned fFlags)
1977	{
1978	#ifndef USE_REM_STUBS
1979	Assert(VALID_PTR(pfnREMR3NotifyPhysRamChunkRegister));
1980	pfnREMR3NotifyPhysRamChunkRegister(pVM, GCPhys, cb, pvRam, fFlags);
1981	#endif
1982	}
1983
1984	REMR3DECL(void) REMR3NotifyPhysRomRegister(PVM pVM, RTGCPHYS GCPhys, RTUINT cb, void *pvCopy)
1985	{
1986	#ifndef USE_REM_STUBS
1987	Assert(VALID_PTR(pfnREMR3NotifyPhysRomRegister));
1988	pfnREMR3NotifyPhysRomRegister(pVM, GCPhys, cb, pvCopy);
1989	#endif
1990	}
1991
1992	REMR3DECL(void) REMR3NotifyPhysReserve(PVM pVM, RTGCPHYS GCPhys, RTUINT cb)
1993	{
1994	#ifndef USE_REM_STUBS
1995	Assert(VALID_PTR(pfnREMR3NotifyPhysReserve));
1996	pfnREMR3NotifyPhysReserve(pVM, GCPhys, cb);
1997	#endif
1998	}
1999
2000	REMR3DECL(void) REMR3NotifyHandlerPhysicalRegister(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler)
2001	{
2002	#ifndef USE_REM_STUBS
2003	Assert(VALID_PTR(pfnREMR3NotifyHandlerPhysicalRegister));
2004	pfnREMR3NotifyHandlerPhysicalRegister(pVM, enmType, GCPhys, cb, fHasHCHandler);
2005	#endif
2006	}
2007
2008	REMR3DECL(void) REMR3NotifyHandlerPhysicalDeregister(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhys, RTGCPHYS cb, bool fHasHCHandler, void *pvHCPtr)
2009	{
2010	#ifndef USE_REM_STUBS
2011	Assert(VALID_PTR(pfnREMR3NotifyHandlerPhysicalDeregister));
2012	pfnREMR3NotifyHandlerPhysicalDeregister(pVM, enmType, GCPhys, cb, fHasHCHandler, pvHCPtr);
2013	#endif
2014	}
2015
2016	REMR3DECL(void) REMR3NotifyHandlerPhysicalModify(PVM pVM, PGMPHYSHANDLERTYPE enmType, RTGCPHYS GCPhysOld, RTGCPHYS GCPhysNew, RTGCPHYS cb, bool fHasHCHandler, void *pvHCPtr)
2017	{
2018	#ifndef USE_REM_STUBS
2019	Assert(VALID_PTR(pfnREMR3NotifyHandlerPhysicalModify));
2020	pfnREMR3NotifyHandlerPhysicalModify(pVM, enmType, GCPhysOld, GCPhysNew, cb, fHasHCHandler, pvHCPtr);
2021	#endif
2022	}
2023
2024	REMDECL(bool) REMR3IsPageAccessHandled(PVM pVM, RTGCPHYS GCPhys)
2025	{
2026	#ifdef USE_REM_STUBS
2027	return false;
2028	#else
2029	Assert(VALID_PTR(pfnREMR3IsPageAccessHandled));
2030	return pfnREMR3IsPageAccessHandled(pVM, GCPhys);
2031	#endif
2032	}
2033
2034	REMR3DECL(int) REMR3DisasEnableStepping(PVM pVM, bool fEnable)
2035	{
2036	#ifdef USE_REM_STUBS
2037	return VERR_NOT_IMPLEMENTED;
2038	#else
2039	Assert(VALID_PTR(pfnREMR3DisasEnableStepping));
2040	return pfnREMR3DisasEnableStepping(pVM, fEnable);
2041	#endif
2042	}
2043
2044	REMR3DECL(void) REMR3NotifyPendingInterrupt(PVM pVM, uint8_t u8Interrupt)
2045	{
2046	#ifndef USE_REM_STUBS
2047	Assert(VALID_PTR(pfnREMR3NotifyPendingInterrupt));
2048	pfnREMR3NotifyPendingInterrupt(pVM, u8Interrupt);
2049	#endif
2050	}
2051
2052	REMR3DECL(uint32_t) REMR3QueryPendingInterrupt(PVM pVM)
2053	{
2054	#ifdef USE_REM_STUBS
2055	return REM_NO_PENDING_IRQ;
2056	#else
2057	Assert(VALID_PTR(pfnREMR3QueryPendingInterrupt));
2058	return pfnREMR3QueryPendingInterrupt(pVM);
2059	#endif
2060	}
2061
2062	REMR3DECL(void) REMR3NotifyInterruptSet(PVM pVM)
2063	{
2064	#ifndef USE_REM_STUBS
2065	Assert(VALID_PTR(pfnREMR3NotifyInterruptSet));
2066	pfnREMR3NotifyInterruptSet(pVM);
2067	#endif
2068	}
2069
2070	REMR3DECL(void) REMR3NotifyInterruptClear(PVM pVM)
2071	{
2072	#ifndef USE_REM_STUBS
2073	Assert(VALID_PTR(pfnREMR3NotifyInterruptClear));
2074	pfnREMR3NotifyInterruptClear(pVM);
2075	#endif
2076	}
2077
2078	REMR3DECL(void) REMR3NotifyTimerPending(PVM pVM)
2079	{
2080	#ifndef USE_REM_STUBS
2081	Assert(VALID_PTR(pfnREMR3NotifyTimerPending));
2082	pfnREMR3NotifyTimerPending(pVM);
2083	#endif
2084	}
2085
2086	REMR3DECL(void) REMR3NotifyDmaPending(PVM pVM)
2087	{
2088	#ifndef USE_REM_STUBS
2089	Assert(VALID_PTR(pfnREMR3NotifyDmaPending));
2090	pfnREMR3NotifyDmaPending(pVM);
2091	#endif
2092	}
2093
2094	REMR3DECL(void) REMR3NotifyQueuePending(PVM pVM)
2095	{
2096	#ifndef USE_REM_STUBS
2097	Assert(VALID_PTR(pfnREMR3NotifyQueuePending));
2098	pfnREMR3NotifyQueuePending(pVM);
2099	#endif
2100	}
2101
2102	REMR3DECL(void) REMR3NotifyFF(PVM pVM)
2103	{
2104	#ifndef USE_REM_STUBS
2105	/* the timer can call this early on, so don't be picky. */
2106	if (pfnREMR3NotifyFF)
2107	pfnREMR3NotifyFF(pVM);
2108	#endif
2109	}
2110

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

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

Download in other formats: