VirtualBox

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

Last change on this file since 7692 was 7649, checked in by vboxsync, 17 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette