VirtualBox

Changeset 91775 in vbox for trunk


Ignore:
Timestamp:
Oct 17, 2021 10:53:28 AM (3 years ago)
Author:
vboxsync
Message:

SUPDrv/darwin,++: Switch back to the kernel stack before calling into SUPDrv to prevent panicing macOS 12. This is just a temporary measure on trunk, as the whole custom stack + call-ring-3 holdover from raw-mode will be eliminated soon. bugref:10124

Location:
trunk
Files:
1 added
8 edited
2 copied

Legend:

Unmodified
Added
Removed
  • trunk/Config.kmk

    r91768 r91775  
    19971997 VBOX_LIB_XPCOM_X86     = $(PATH_STAGE_BIN)/VBoxXPCOM-x86.dylib
    19981998 LIB_DDU         = $(PATH_STAGE_BIN)/VBoxDDU.dylib
    1999  VBOX_LIB_SUPR0 :=
     1999 VBOX_LIB_SUPR0  = $(PATH_STAGE_LIB)/SUPR0$(VBOX_SUFF_LIB)
    20002000endif
    20012001if1of ($(KBUILD_TARGET), freebsd haiku linux netbsd openbsd solaris)
  • trunk/src/VBox/HostDrivers/Support/Makefile.kmk

    r91677 r91775  
    4141endif
    4242if   !defined(VBOX_ONLY_DOCS)
    43  if1of ($(VBOX_LDR_FMT), pe lx)
     43 if1of ($(VBOX_LDR_FMT), pe lx macho)
    4444  LIBRARIES += SUPR0
    4545 endif
     
    534534  endif
    535535 endif
     536
     537else ifeq ($(VBOX_LDR_FMT),macho)
     538 SUPR0_VBOX_KMK_FILE = $(PATH_OUT)/SUPR0/files.kmk
     539 include $(SUPR0_VBOX_KMK_FILE)
     540 SUPR0_SOURCES       = $(SUPR0_VBOX_FILES)
     541 SUPR0_CLEAN         = $(SUPR0_VBOX_FILES) $$(SUPR0_0_OUTDIR)/SUPR0.asm $(SUPR0_VBOX_KMK_FILE) $(SUPR0_VBOX_KMK_FILE).ts
     542
     543 # Generate a make include file which lists the wrapper source files.
     544# $ (call KB_FN_AUTO_CMD_DEPS,$(SUPR0_VBOX_KMK_FILE).ts)
     545 $(SUPR0_VBOX_KMK_FILE).ts \
     546 +| $(SUPR0_VBOX_KMK_FILE): \
     547                $(PATH_SUB_CURRENT)/SUPDrv.cpp \
     548                $(PATH_SUB_CURRENT)/SUPR0-asm-files.sed
     549#       $(call KB_FN_AUTO_CMD_DEPS_COMMANDS)
     550        $(call MSG_GENERATE,,$(SUPR0_VBOX_KMK_FILE))
     551        $(QUIET)$(RM) -f -- "$@"
     552        $(QUIET)$(MKDIR) -p -- "$(@D)"
     553        $(QUIET)$(SED) --output "$@" -f "$(PATH_SUB_CURRENT)/SUPR0-asm-files.sed" "$(PATH_SUB_CURRENT)/SUPDrv.cpp"
     554        $(QUIET)$(CP) --changed -fv "$@" $(SUPR0_VBOX_KMK_FILE)
     555
     556 $$(SUPR0_0_OUTDIR)/SUPR0.asm +| $(SUPR0_VBOX_FILES): \
     557                $(PATH_SUB_CURRENT)/SUPDrv.cpp \
     558                $(PATH_SUB_CURRENT)/SUPR0-asm.sed \
     559               | $$(dir $$@)
     560#       $(call KB_FN_AUTO_CMD_DEPS_COMMANDS)
     561        $(call MSG_GENERATE,,$(SUPR0_VBOX_KMK_FILE))
     562        $(QUIET)$(RM) -f -- "$@"
     563        $(QUIET)$(SED) --output "$@" -f "$(PATH_SUB_CURRENT)/SUPR0-asm.sed" "$(PATH_SUB_CURRENT)/SUPDrv.cpp"
     564        $(VBOX_FILESPLIT) "$@" "$(dir $@)"
     565
    536566endif
    537567
  • trunk/src/VBox/HostDrivers/Support/SUPDrv.cpp

    r91674 r91775  
    154154*   Global Variables                                                                                                             *
    155155*********************************************************************************************************************************/
     156/** @def STKBACK
     157 * Indicates that the symbol needs to switch back to the kernel stack on darwin.
     158 * See @bugref{10124} for details. */
     159#if 1
     160# define STKBACK(a) "StkBack_" a
     161#else
     162# define STKBACK(a) a
     163#endif
     164/** @def STKOKAY
     165 * The oposite of STKBACK, just for make the table nicly aligned. */
     166#define STKOKAY(a) a
     167
    156168/**
    157169 * Array of the R0 SUP API.
     
    170182        /* Entries with absolute addresses determined at runtime, fixup
    171183           code makes ugly ASSUMPTIONS about the order here: */
    172     { "SUPR0AbsIs64bit",                        (void *)0 },
    173     { "SUPR0Abs64bitKernelCS",                  (void *)0 },
    174     { "SUPR0Abs64bitKernelSS",                  (void *)0 },
    175     { "SUPR0Abs64bitKernelDS",                  (void *)0 },
    176     { "SUPR0AbsKernelCS",                       (void *)0 },
    177     { "SUPR0AbsKernelSS",                       (void *)0 },
    178     { "SUPR0AbsKernelDS",                       (void *)0 },
    179     { "SUPR0AbsKernelES",                       (void *)0 },
    180     { "SUPR0AbsKernelFS",                       (void *)0 },
    181     { "SUPR0AbsKernelGS",                       (void *)0 },
     184    { STKOKAY("SUPR0AbsIs64bit"),                        (void *)0 },
     185    { STKOKAY("SUPR0Abs64bitKernelCS"),                  (void *)0 },
     186    { STKOKAY("SUPR0Abs64bitKernelSS"),                  (void *)0 },
     187    { STKOKAY("SUPR0Abs64bitKernelDS"),                  (void *)0 },
     188    { STKOKAY("SUPR0AbsKernelCS"),                       (void *)0 },
     189    { STKOKAY("SUPR0AbsKernelSS"),                       (void *)0 },
     190    { STKOKAY("SUPR0AbsKernelDS"),                       (void *)0 },
     191    { STKOKAY("SUPR0AbsKernelES"),                       (void *)0 },
     192    { STKOKAY("SUPR0AbsKernelFS"),                       (void *)0 },
     193    { STKOKAY("SUPR0AbsKernelGS"),                       (void *)0 },
    182194        /* Normal function pointers: */
    183     { "g_pSUPGlobalInfoPage",                   (void *)&g_pSUPGlobalInfoPage },            /* SED: DATA */
    184     { "SUPGetGIP",                              (void *)(uintptr_t)SUPGetGIP },
    185     { "SUPReadTscWithDelta",                    (void *)(uintptr_t)SUPReadTscWithDelta },
    186     { "SUPGetTscDeltaSlow",                     (void *)(uintptr_t)SUPGetTscDeltaSlow },
    187     { "SUPGetCpuHzFromGipForAsyncMode",         (void *)(uintptr_t)SUPGetCpuHzFromGipForAsyncMode },
    188     { "SUPIsTscFreqCompatible",                 (void *)(uintptr_t)SUPIsTscFreqCompatible },
    189     { "SUPIsTscFreqCompatibleEx",               (void *)(uintptr_t)SUPIsTscFreqCompatibleEx },
    190     { "SUPR0BadContext",                        (void *)(uintptr_t)SUPR0BadContext },
    191     { "SUPR0ComponentDeregisterFactory",        (void *)(uintptr_t)SUPR0ComponentDeregisterFactory },
    192     { "SUPR0ComponentQueryFactory",             (void *)(uintptr_t)SUPR0ComponentQueryFactory },
    193     { "SUPR0ComponentRegisterFactory",          (void *)(uintptr_t)SUPR0ComponentRegisterFactory },
    194     { "SUPR0ContAlloc",                         (void *)(uintptr_t)SUPR0ContAlloc },
    195     { "SUPR0ContFree",                          (void *)(uintptr_t)SUPR0ContFree },
    196     { "SUPR0ChangeCR4",                         (void *)(uintptr_t)SUPR0ChangeCR4 },
    197     { "SUPR0EnableVTx",                         (void *)(uintptr_t)SUPR0EnableVTx },
    198     { "SUPR0SuspendVTxOnCpu",                   (void *)(uintptr_t)SUPR0SuspendVTxOnCpu },
    199     { "SUPR0ResumeVTxOnCpu",                    (void *)(uintptr_t)SUPR0ResumeVTxOnCpu },
    200     { "SUPR0GetCurrentGdtRw",                   (void *)(uintptr_t)SUPR0GetCurrentGdtRw },
    201     { "SUPR0GetKernelFeatures",                 (void *)(uintptr_t)SUPR0GetKernelFeatures },
    202     { "SUPR0GetHwvirtMsrs",                     (void *)(uintptr_t)SUPR0GetHwvirtMsrs },
    203     { "SUPR0GetPagingMode",                     (void *)(uintptr_t)SUPR0GetPagingMode },
    204     { "SUPR0GetSvmUsability",                   (void *)(uintptr_t)SUPR0GetSvmUsability },
    205     { "SUPR0GetVTSupport",                      (void *)(uintptr_t)SUPR0GetVTSupport },
    206     { "SUPR0GetVmxUsability",                   (void *)(uintptr_t)SUPR0GetVmxUsability },
    207     { "SUPR0LdrIsLockOwnerByMod",               (void *)(uintptr_t)SUPR0LdrIsLockOwnerByMod },
    208     { "SUPR0LdrLock",                           (void *)(uintptr_t)SUPR0LdrLock },
    209     { "SUPR0LdrUnlock",                         (void *)(uintptr_t)SUPR0LdrUnlock },
    210     { "SUPR0LdrModByName",                      (void *)(uintptr_t)SUPR0LdrModByName },
    211     { "SUPR0LdrModRelease",                     (void *)(uintptr_t)SUPR0LdrModRelease },
    212     { "SUPR0LdrModRetain",                      (void *)(uintptr_t)SUPR0LdrModRetain },
    213     { "SUPR0LockMem",                           (void *)(uintptr_t)SUPR0LockMem },
    214     { "SUPR0LowAlloc",                          (void *)(uintptr_t)SUPR0LowAlloc },
    215     { "SUPR0LowFree",                           (void *)(uintptr_t)SUPR0LowFree },
    216     { "SUPR0MemAlloc",                          (void *)(uintptr_t)SUPR0MemAlloc },
    217     { "SUPR0MemFree",                           (void *)(uintptr_t)SUPR0MemFree },
    218     { "SUPR0MemGetPhys",                        (void *)(uintptr_t)SUPR0MemGetPhys },
    219     { "SUPR0ObjAddRef",                         (void *)(uintptr_t)SUPR0ObjAddRef },
    220     { "SUPR0ObjAddRefEx",                       (void *)(uintptr_t)SUPR0ObjAddRefEx },
    221     { "SUPR0ObjRegister",                       (void *)(uintptr_t)SUPR0ObjRegister },
    222     { "SUPR0ObjRelease",                        (void *)(uintptr_t)SUPR0ObjRelease },
    223     { "SUPR0ObjVerifyAccess",                   (void *)(uintptr_t)SUPR0ObjVerifyAccess },
    224     { "SUPR0PageAllocEx",                       (void *)(uintptr_t)SUPR0PageAllocEx },
    225     { "SUPR0PageFree",                          (void *)(uintptr_t)SUPR0PageFree },
    226     { "SUPR0PageMapKernel",                     (void *)(uintptr_t)SUPR0PageMapKernel },
    227     { "SUPR0PageProtect",                       (void *)(uintptr_t)SUPR0PageProtect },
     195    { STKOKAY("g_pSUPGlobalInfoPage"),                   (void *)&g_pSUPGlobalInfoPage },            /* SED: DATA */
     196    { STKOKAY("SUPGetGIP"),                              (void *)(uintptr_t)SUPGetGIP },
     197    { STKBACK("SUPReadTscWithDelta"),                    (void *)(uintptr_t)SUPReadTscWithDelta },
     198    { STKBACK("SUPGetTscDeltaSlow"),                     (void *)(uintptr_t)SUPGetTscDeltaSlow },
     199    { STKBACK("SUPGetCpuHzFromGipForAsyncMode"),         (void *)(uintptr_t)SUPGetCpuHzFromGipForAsyncMode },
     200    { STKOKAY("SUPIsTscFreqCompatible"),                 (void *)(uintptr_t)SUPIsTscFreqCompatible },
     201    { STKOKAY("SUPIsTscFreqCompatibleEx"),               (void *)(uintptr_t)SUPIsTscFreqCompatibleEx },
     202    { STKBACK("SUPR0BadContext"),                        (void *)(uintptr_t)SUPR0BadContext },
     203    { STKBACK("SUPR0ComponentDeregisterFactory"),        (void *)(uintptr_t)SUPR0ComponentDeregisterFactory },
     204    { STKBACK("SUPR0ComponentQueryFactory"),             (void *)(uintptr_t)SUPR0ComponentQueryFactory },
     205    { STKBACK("SUPR0ComponentRegisterFactory"),          (void *)(uintptr_t)SUPR0ComponentRegisterFactory },
     206    { STKBACK("SUPR0ContAlloc"),                         (void *)(uintptr_t)SUPR0ContAlloc },
     207    { STKBACK("SUPR0ContFree"),                          (void *)(uintptr_t)SUPR0ContFree },
     208    { STKBACK("SUPR0ChangeCR4"),                         (void *)(uintptr_t)SUPR0ChangeCR4 },
     209    { STKBACK("SUPR0EnableVTx"),                         (void *)(uintptr_t)SUPR0EnableVTx },
     210    { STKBACK("SUPR0SuspendVTxOnCpu"),                   (void *)(uintptr_t)SUPR0SuspendVTxOnCpu },
     211    { STKBACK("SUPR0ResumeVTxOnCpu"),                    (void *)(uintptr_t)SUPR0ResumeVTxOnCpu },
     212    { STKOKAY("SUPR0GetCurrentGdtRw"),                   (void *)(uintptr_t)SUPR0GetCurrentGdtRw },
     213    { STKOKAY("SUPR0GetKernelFeatures"),                 (void *)(uintptr_t)SUPR0GetKernelFeatures },
     214    { STKBACK("SUPR0GetHwvirtMsrs"),                     (void *)(uintptr_t)SUPR0GetHwvirtMsrs },
     215    { STKBACK("SUPR0GetPagingMode"),                     (void *)(uintptr_t)SUPR0GetPagingMode },
     216    { STKBACK("SUPR0GetSvmUsability"),                   (void *)(uintptr_t)SUPR0GetSvmUsability },
     217    { STKBACK("SUPR0GetVTSupport"),                      (void *)(uintptr_t)SUPR0GetVTSupport },
     218    { STKBACK("SUPR0GetVmxUsability"),                   (void *)(uintptr_t)SUPR0GetVmxUsability },
     219    { STKBACK("SUPR0LdrIsLockOwnerByMod"),               (void *)(uintptr_t)SUPR0LdrIsLockOwnerByMod },
     220    { STKBACK("SUPR0LdrLock"),                           (void *)(uintptr_t)SUPR0LdrLock },
     221    { STKBACK("SUPR0LdrUnlock"),                         (void *)(uintptr_t)SUPR0LdrUnlock },
     222    { STKBACK("SUPR0LdrModByName"),                      (void *)(uintptr_t)SUPR0LdrModByName },
     223    { STKBACK("SUPR0LdrModRelease"),                     (void *)(uintptr_t)SUPR0LdrModRelease },
     224    { STKBACK("SUPR0LdrModRetain"),                      (void *)(uintptr_t)SUPR0LdrModRetain },
     225    { STKBACK("SUPR0LockMem"),                           (void *)(uintptr_t)SUPR0LockMem },
     226    { STKBACK("SUPR0LowAlloc"),                          (void *)(uintptr_t)SUPR0LowAlloc },
     227    { STKBACK("SUPR0LowFree"),                           (void *)(uintptr_t)SUPR0LowFree },
     228    { STKBACK("SUPR0MemAlloc"),                          (void *)(uintptr_t)SUPR0MemAlloc },
     229    { STKBACK("SUPR0MemFree"),                           (void *)(uintptr_t)SUPR0MemFree },
     230    { STKBACK("SUPR0MemGetPhys"),                        (void *)(uintptr_t)SUPR0MemGetPhys },
     231    { STKBACK("SUPR0ObjAddRef"),                         (void *)(uintptr_t)SUPR0ObjAddRef },
     232    { STKBACK("SUPR0ObjAddRefEx"),                       (void *)(uintptr_t)SUPR0ObjAddRefEx },
     233    { STKBACK("SUPR0ObjRegister"),                       (void *)(uintptr_t)SUPR0ObjRegister },
     234    { STKBACK("SUPR0ObjRelease"),                        (void *)(uintptr_t)SUPR0ObjRelease },
     235    { STKBACK("SUPR0ObjVerifyAccess"),                   (void *)(uintptr_t)SUPR0ObjVerifyAccess },
     236    { STKBACK("SUPR0PageAllocEx"),                       (void *)(uintptr_t)SUPR0PageAllocEx },
     237    { STKBACK("SUPR0PageFree"),                          (void *)(uintptr_t)SUPR0PageFree },
     238    { STKBACK("SUPR0PageMapKernel"),                     (void *)(uintptr_t)SUPR0PageMapKernel },
     239    { STKBACK("SUPR0PageProtect"),                       (void *)(uintptr_t)SUPR0PageProtect },
    228240#if defined(RT_OS_LINUX) || defined(RT_OS_SOLARIS)
    229     { "SUPR0HCPhysToVirt",                      (void *)(uintptr_t)SUPR0HCPhysToVirt },         /* only-linux, only solaris */
     241    { STKBACK("SUPR0HCPhysToVirt"),                      (void *)(uintptr_t)SUPR0HCPhysToVirt },         /* only-linux, only solaris */
    230242#endif
    231     { "SUPR0Printf",                            (void *)(uintptr_t)SUPR0Printf },
    232     { "SUPR0GetSessionGVM",                     (void *)(uintptr_t)SUPR0GetSessionGVM },
    233     { "SUPR0GetSessionVM",                      (void *)(uintptr_t)SUPR0GetSessionVM },
    234     { "SUPR0SetSessionVM",                      (void *)(uintptr_t)SUPR0SetSessionVM },
    235     { "SUPR0TscDeltaMeasureBySetIndex",         (void *)(uintptr_t)SUPR0TscDeltaMeasureBySetIndex },
    236     { "SUPR0TracerDeregisterDrv",               (void *)(uintptr_t)SUPR0TracerDeregisterDrv },
    237     { "SUPR0TracerDeregisterImpl",              (void *)(uintptr_t)SUPR0TracerDeregisterImpl },
    238     { "SUPR0TracerFireProbe",                   (void *)(uintptr_t)SUPR0TracerFireProbe },
    239     { "SUPR0TracerRegisterDrv",                 (void *)(uintptr_t)SUPR0TracerRegisterDrv },
    240     { "SUPR0TracerRegisterImpl",                (void *)(uintptr_t)SUPR0TracerRegisterImpl },
    241     { "SUPR0TracerRegisterModule",              (void *)(uintptr_t)SUPR0TracerRegisterModule },
    242     { "SUPR0TracerUmodProbeFire",               (void *)(uintptr_t)SUPR0TracerUmodProbeFire },
    243     { "SUPR0UnlockMem",                         (void *)(uintptr_t)SUPR0UnlockMem },
     243    { STKBACK("SUPR0Printf"),                            (void *)(uintptr_t)SUPR0Printf },
     244    { STKBACK("SUPR0GetSessionGVM"),                     (void *)(uintptr_t)SUPR0GetSessionGVM },
     245    { STKBACK("SUPR0GetSessionVM"),                      (void *)(uintptr_t)SUPR0GetSessionVM },
     246    { STKBACK("SUPR0SetSessionVM"),                      (void *)(uintptr_t)SUPR0SetSessionVM },
     247    { STKBACK("SUPR0TscDeltaMeasureBySetIndex"),         (void *)(uintptr_t)SUPR0TscDeltaMeasureBySetIndex },
     248    { STKBACK("SUPR0TracerDeregisterDrv"),               (void *)(uintptr_t)SUPR0TracerDeregisterDrv },
     249    { STKBACK("SUPR0TracerDeregisterImpl"),              (void *)(uintptr_t)SUPR0TracerDeregisterImpl },
     250    { STKBACK("SUPR0TracerFireProbe"),                   (void *)(uintptr_t)SUPR0TracerFireProbe },
     251    { STKBACK("SUPR0TracerRegisterDrv"),                 (void *)(uintptr_t)SUPR0TracerRegisterDrv },
     252    { STKBACK("SUPR0TracerRegisterImpl"),                (void *)(uintptr_t)SUPR0TracerRegisterImpl },
     253    { STKBACK("SUPR0TracerRegisterModule"),              (void *)(uintptr_t)SUPR0TracerRegisterModule },
     254    { STKBACK("SUPR0TracerUmodProbeFire"),               (void *)(uintptr_t)SUPR0TracerUmodProbeFire },
     255    { STKBACK("SUPR0UnlockMem"),                         (void *)(uintptr_t)SUPR0UnlockMem },
    244256#ifdef RT_OS_WINDOWS
    245     { "SUPR0IoCtlSetupForHandle",               (void *)(uintptr_t)SUPR0IoCtlSetupForHandle },  /* only-windows */
    246     { "SUPR0IoCtlPerform",                      (void *)(uintptr_t)SUPR0IoCtlPerform },         /* only-windows */
    247     { "SUPR0IoCtlCleanup",                      (void *)(uintptr_t)SUPR0IoCtlCleanup },         /* only-windows */
     257    { STKBACK("SUPR0IoCtlSetupForHandle"),               (void *)(uintptr_t)SUPR0IoCtlSetupForHandle },  /* only-windows */
     258    { STKBACK("SUPR0IoCtlPerform"),                      (void *)(uintptr_t)SUPR0IoCtlPerform },         /* only-windows */
     259    { STKBACK("SUPR0IoCtlCleanup"),                      (void *)(uintptr_t)SUPR0IoCtlCleanup },         /* only-windows */
    248260#endif
    249     { "SUPSemEventClose",                       (void *)(uintptr_t)SUPSemEventClose },
    250     { "SUPSemEventCreate",                      (void *)(uintptr_t)SUPSemEventCreate },
    251     { "SUPSemEventGetResolution",               (void *)(uintptr_t)SUPSemEventGetResolution },
    252     { "SUPSemEventMultiClose",                  (void *)(uintptr_t)SUPSemEventMultiClose },
    253     { "SUPSemEventMultiCreate",                 (void *)(uintptr_t)SUPSemEventMultiCreate },
    254     { "SUPSemEventMultiGetResolution",          (void *)(uintptr_t)SUPSemEventMultiGetResolution },
    255     { "SUPSemEventMultiReset",                  (void *)(uintptr_t)SUPSemEventMultiReset },
    256     { "SUPSemEventMultiSignal",                 (void *)(uintptr_t)SUPSemEventMultiSignal },
    257     { "SUPSemEventMultiWait",                   (void *)(uintptr_t)SUPSemEventMultiWait },
    258     { "SUPSemEventMultiWaitNoResume",           (void *)(uintptr_t)SUPSemEventMultiWaitNoResume },
    259     { "SUPSemEventMultiWaitNsAbsIntr",          (void *)(uintptr_t)SUPSemEventMultiWaitNsAbsIntr },
    260     { "SUPSemEventMultiWaitNsRelIntr",          (void *)(uintptr_t)SUPSemEventMultiWaitNsRelIntr },
    261     { "SUPSemEventSignal",                      (void *)(uintptr_t)SUPSemEventSignal },
    262     { "SUPSemEventWait",                        (void *)(uintptr_t)SUPSemEventWait },
    263     { "SUPSemEventWaitNoResume",                (void *)(uintptr_t)SUPSemEventWaitNoResume },
    264     { "SUPSemEventWaitNsAbsIntr",               (void *)(uintptr_t)SUPSemEventWaitNsAbsIntr },
    265     { "SUPSemEventWaitNsRelIntr",               (void *)(uintptr_t)SUPSemEventWaitNsRelIntr },
    266 
    267     { "RTAssertAreQuiet",                       (void *)(uintptr_t)RTAssertAreQuiet },
    268     { "RTAssertMayPanic",                       (void *)(uintptr_t)RTAssertMayPanic },
    269     { "RTAssertMsg1",                           (void *)(uintptr_t)RTAssertMsg1 },
    270     { "RTAssertMsg2AddV",                       (void *)(uintptr_t)RTAssertMsg2AddV },
    271     { "RTAssertMsg2V",                          (void *)(uintptr_t)RTAssertMsg2V },
    272     { "RTAssertSetMayPanic",                    (void *)(uintptr_t)RTAssertSetMayPanic },
    273     { "RTAssertSetQuiet",                       (void *)(uintptr_t)RTAssertSetQuiet },
    274     { "RTCrc32",                                (void *)(uintptr_t)RTCrc32 },
    275     { "RTCrc32Finish",                          (void *)(uintptr_t)RTCrc32Finish },
    276     { "RTCrc32Process",                         (void *)(uintptr_t)RTCrc32Process },
    277     { "RTCrc32Start",                           (void *)(uintptr_t)RTCrc32Start },
    278     { "RTErrConvertFromErrno",                  (void *)(uintptr_t)RTErrConvertFromErrno },
    279     { "RTErrConvertToErrno",                    (void *)(uintptr_t)RTErrConvertToErrno },
    280     { "RTHandleTableAllocWithCtx",              (void *)(uintptr_t)RTHandleTableAllocWithCtx },
    281     { "RTHandleTableCreate",                    (void *)(uintptr_t)RTHandleTableCreate },
    282     { "RTHandleTableCreateEx",                  (void *)(uintptr_t)RTHandleTableCreateEx },
    283     { "RTHandleTableDestroy",                   (void *)(uintptr_t)RTHandleTableDestroy },
    284     { "RTHandleTableFreeWithCtx",               (void *)(uintptr_t)RTHandleTableFreeWithCtx },
    285     { "RTHandleTableLookupWithCtx",             (void *)(uintptr_t)RTHandleTableLookupWithCtx },
    286     { "RTLogBulkUpdate",                        (void *)(uintptr_t)RTLogBulkUpdate},
    287     { "RTLogCheckGroupFlags",                   (void *)(uintptr_t)RTLogCheckGroupFlags },
    288     { "RTLogCreateEx",                          (void *)(uintptr_t)RTLogCreateEx },
    289     { "RTLogDestroy",                           (void *)(uintptr_t)RTLogDestroy },
    290     { "RTLogDefaultInstance",                   (void *)(uintptr_t)RTLogDefaultInstance },
    291     { "RTLogDefaultInstanceEx",                 (void *)(uintptr_t)RTLogDefaultInstanceEx },
    292     { "SUPR0DefaultLogInstanceEx",              (void *)(uintptr_t)SUPR0DefaultLogInstanceEx },
    293     { "RTLogGetDefaultInstance",                (void *)(uintptr_t)RTLogGetDefaultInstance },
    294     { "RTLogGetDefaultInstanceEx",              (void *)(uintptr_t)RTLogGetDefaultInstanceEx },
    295     { "SUPR0GetDefaultLogInstanceEx",           (void *)(uintptr_t)SUPR0GetDefaultLogInstanceEx },
    296     { "RTLogLoggerExV",                         (void *)(uintptr_t)RTLogLoggerExV },
    297     { "RTLogPrintfV",                           (void *)(uintptr_t)RTLogPrintfV },
    298     { "RTLogRelGetDefaultInstance",             (void *)(uintptr_t)RTLogRelGetDefaultInstance },
    299     { "RTLogRelGetDefaultInstanceEx",           (void *)(uintptr_t)RTLogRelGetDefaultInstanceEx },
    300     { "SUPR0GetDefaultLogRelInstanceEx",        (void *)(uintptr_t)SUPR0GetDefaultLogRelInstanceEx },
    301     { "RTLogSetDefaultInstanceThread",          (void *)(uintptr_t)RTLogSetDefaultInstanceThread },
    302     { "RTLogSetFlushCallback",                  (void *)(uintptr_t)RTLogSetFlushCallback },
    303     { "RTLogSetR0ProgramStart",                 (void *)(uintptr_t)RTLogSetR0ProgramStart },
    304     { "RTLogSetR0ThreadNameF",                  (void *)(uintptr_t)RTLogSetR0ThreadNameF },
    305     { "RTMemAllocExTag",                        (void *)(uintptr_t)RTMemAllocExTag },
    306     { "RTMemAllocTag",                          (void *)(uintptr_t)RTMemAllocTag },
    307     { "RTMemAllocVarTag",                       (void *)(uintptr_t)RTMemAllocVarTag },
    308     { "RTMemAllocZTag",                         (void *)(uintptr_t)RTMemAllocZTag },
    309     { "RTMemAllocZVarTag",                      (void *)(uintptr_t)RTMemAllocZVarTag },
    310     { "RTMemDupExTag",                          (void *)(uintptr_t)RTMemDupExTag },
    311     { "RTMemDupTag",                            (void *)(uintptr_t)RTMemDupTag },
    312     { "RTMemFree",                              (void *)(uintptr_t)RTMemFree },
    313     { "RTMemFreeEx",                            (void *)(uintptr_t)RTMemFreeEx },
    314     { "RTMemReallocTag",                        (void *)(uintptr_t)RTMemReallocTag },
    315     { "RTMpCpuId",                              (void *)(uintptr_t)RTMpCpuId },
    316     { "RTMpCpuIdFromSetIndex",                  (void *)(uintptr_t)RTMpCpuIdFromSetIndex },
    317     { "RTMpCpuIdToSetIndex",                    (void *)(uintptr_t)RTMpCpuIdToSetIndex },
    318     { "RTMpCurSetIndex",                        (void *)(uintptr_t)RTMpCurSetIndex },
    319     { "RTMpCurSetIndexAndId",                   (void *)(uintptr_t)RTMpCurSetIndexAndId },
    320     { "RTMpGetArraySize",                       (void *)(uintptr_t)RTMpGetArraySize },
    321     { "RTMpGetCount",                           (void *)(uintptr_t)RTMpGetCount },
    322     { "RTMpGetMaxCpuId",                        (void *)(uintptr_t)RTMpGetMaxCpuId },
    323     { "RTMpGetOnlineCount",                     (void *)(uintptr_t)RTMpGetOnlineCount },
    324     { "RTMpGetOnlineSet",                       (void *)(uintptr_t)RTMpGetOnlineSet },
    325     { "RTMpGetSet",                             (void *)(uintptr_t)RTMpGetSet },
    326     { "RTMpIsCpuOnline",                        (void *)(uintptr_t)RTMpIsCpuOnline },
    327     { "RTMpIsCpuPossible",                      (void *)(uintptr_t)RTMpIsCpuPossible },
    328     { "RTMpIsCpuWorkPending",                   (void *)(uintptr_t)RTMpIsCpuWorkPending },
    329     { "RTMpNotificationDeregister",             (void *)(uintptr_t)RTMpNotificationDeregister },
    330     { "RTMpNotificationRegister",               (void *)(uintptr_t)RTMpNotificationRegister },
    331     { "RTMpOnAll",                              (void *)(uintptr_t)RTMpOnAll },
    332     { "RTMpOnOthers",                           (void *)(uintptr_t)RTMpOnOthers },
    333     { "RTMpOnSpecific",                         (void *)(uintptr_t)RTMpOnSpecific },
    334     { "RTMpPokeCpu",                            (void *)(uintptr_t)RTMpPokeCpu },
    335     { "RTNetIPv4AddDataChecksum",               (void *)(uintptr_t)RTNetIPv4AddDataChecksum },
    336     { "RTNetIPv4AddTCPChecksum",                (void *)(uintptr_t)RTNetIPv4AddTCPChecksum },
    337     { "RTNetIPv4AddUDPChecksum",                (void *)(uintptr_t)RTNetIPv4AddUDPChecksum },
    338     { "RTNetIPv4FinalizeChecksum",              (void *)(uintptr_t)RTNetIPv4FinalizeChecksum },
    339     { "RTNetIPv4HdrChecksum",                   (void *)(uintptr_t)RTNetIPv4HdrChecksum },
    340     { "RTNetIPv4IsDHCPValid",                   (void *)(uintptr_t)RTNetIPv4IsDHCPValid },
    341     { "RTNetIPv4IsHdrValid",                    (void *)(uintptr_t)RTNetIPv4IsHdrValid },
    342     { "RTNetIPv4IsTCPSizeValid",                (void *)(uintptr_t)RTNetIPv4IsTCPSizeValid },
    343     { "RTNetIPv4IsTCPValid",                    (void *)(uintptr_t)RTNetIPv4IsTCPValid },
    344     { "RTNetIPv4IsUDPSizeValid",                (void *)(uintptr_t)RTNetIPv4IsUDPSizeValid },
    345     { "RTNetIPv4IsUDPValid",                    (void *)(uintptr_t)RTNetIPv4IsUDPValid },
    346     { "RTNetIPv4PseudoChecksum",                (void *)(uintptr_t)RTNetIPv4PseudoChecksum },
    347     { "RTNetIPv4PseudoChecksumBits",            (void *)(uintptr_t)RTNetIPv4PseudoChecksumBits },
    348     { "RTNetIPv4TCPChecksum",                   (void *)(uintptr_t)RTNetIPv4TCPChecksum },
    349     { "RTNetIPv4UDPChecksum",                   (void *)(uintptr_t)RTNetIPv4UDPChecksum },
    350     { "RTNetIPv6PseudoChecksum",                (void *)(uintptr_t)RTNetIPv6PseudoChecksum },
    351     { "RTNetIPv6PseudoChecksumBits",            (void *)(uintptr_t)RTNetIPv6PseudoChecksumBits },
    352     { "RTNetIPv6PseudoChecksumEx",              (void *)(uintptr_t)RTNetIPv6PseudoChecksumEx },
    353     { "RTNetTCPChecksum",                       (void *)(uintptr_t)RTNetTCPChecksum },
    354     { "RTNetUDPChecksum",                       (void *)(uintptr_t)RTNetUDPChecksum },
    355     { "RTPowerNotificationDeregister",          (void *)(uintptr_t)RTPowerNotificationDeregister },
    356     { "RTPowerNotificationRegister",            (void *)(uintptr_t)RTPowerNotificationRegister },
    357     { "RTProcSelf",                             (void *)(uintptr_t)RTProcSelf },
    358     { "RTR0AssertPanicSystem",                  (void *)(uintptr_t)RTR0AssertPanicSystem },
     261    { STKBACK("SUPSemEventClose"),                       (void *)(uintptr_t)SUPSemEventClose },
     262    { STKBACK("SUPSemEventCreate"),                      (void *)(uintptr_t)SUPSemEventCreate },
     263    { STKBACK("SUPSemEventGetResolution"),               (void *)(uintptr_t)SUPSemEventGetResolution },
     264    { STKBACK("SUPSemEventMultiClose"),                  (void *)(uintptr_t)SUPSemEventMultiClose },
     265    { STKBACK("SUPSemEventMultiCreate"),                 (void *)(uintptr_t)SUPSemEventMultiCreate },
     266    { STKBACK("SUPSemEventMultiGetResolution"),          (void *)(uintptr_t)SUPSemEventMultiGetResolution },
     267    { STKBACK("SUPSemEventMultiReset"),                  (void *)(uintptr_t)SUPSemEventMultiReset },
     268    { STKBACK("SUPSemEventMultiSignal"),                 (void *)(uintptr_t)SUPSemEventMultiSignal },
     269    { STKBACK("SUPSemEventMultiWait"),                   (void *)(uintptr_t)SUPSemEventMultiWait },
     270    { STKBACK("SUPSemEventMultiWaitNoResume"),           (void *)(uintptr_t)SUPSemEventMultiWaitNoResume },
     271    { STKBACK("SUPSemEventMultiWaitNsAbsIntr"),          (void *)(uintptr_t)SUPSemEventMultiWaitNsAbsIntr },
     272    { STKBACK("SUPSemEventMultiWaitNsRelIntr"),          (void *)(uintptr_t)SUPSemEventMultiWaitNsRelIntr },
     273    { STKBACK("SUPSemEventSignal"),                      (void *)(uintptr_t)SUPSemEventSignal },
     274    { STKBACK("SUPSemEventWait"),                        (void *)(uintptr_t)SUPSemEventWait },
     275    { STKBACK("SUPSemEventWaitNoResume"),                (void *)(uintptr_t)SUPSemEventWaitNoResume },
     276    { STKBACK("SUPSemEventWaitNsAbsIntr"),               (void *)(uintptr_t)SUPSemEventWaitNsAbsIntr },
     277    { STKBACK("SUPSemEventWaitNsRelIntr"),               (void *)(uintptr_t)SUPSemEventWaitNsRelIntr },
     278
     279    { STKBACK("RTAssertAreQuiet"),                       (void *)(uintptr_t)RTAssertAreQuiet },
     280    { STKBACK("RTAssertMayPanic"),                       (void *)(uintptr_t)RTAssertMayPanic },
     281    { STKBACK("RTAssertMsg1"),                           (void *)(uintptr_t)RTAssertMsg1 },
     282    { STKBACK("RTAssertMsg2AddV"),                       (void *)(uintptr_t)RTAssertMsg2AddV },
     283    { STKBACK("RTAssertMsg2V"),                          (void *)(uintptr_t)RTAssertMsg2V },
     284    { STKBACK("RTAssertSetMayPanic"),                    (void *)(uintptr_t)RTAssertSetMayPanic },
     285    { STKBACK("RTAssertSetQuiet"),                       (void *)(uintptr_t)RTAssertSetQuiet },
     286    { STKOKAY("RTCrc32"),                                (void *)(uintptr_t)RTCrc32 },
     287    { STKOKAY("RTCrc32Finish"),                          (void *)(uintptr_t)RTCrc32Finish },
     288    { STKOKAY("RTCrc32Process"),                         (void *)(uintptr_t)RTCrc32Process },
     289    { STKOKAY("RTCrc32Start"),                           (void *)(uintptr_t)RTCrc32Start },
     290    { STKOKAY("RTErrConvertFromErrno"),                  (void *)(uintptr_t)RTErrConvertFromErrno },
     291    { STKOKAY("RTErrConvertToErrno"),                    (void *)(uintptr_t)RTErrConvertToErrno },
     292    { STKBACK("RTHandleTableAllocWithCtx"),              (void *)(uintptr_t)RTHandleTableAllocWithCtx },
     293    { STKBACK("RTHandleTableCreate"),                    (void *)(uintptr_t)RTHandleTableCreate },
     294    { STKBACK("RTHandleTableCreateEx"),                  (void *)(uintptr_t)RTHandleTableCreateEx },
     295    { STKBACK("RTHandleTableDestroy"),                   (void *)(uintptr_t)RTHandleTableDestroy },
     296    { STKBACK("RTHandleTableFreeWithCtx"),               (void *)(uintptr_t)RTHandleTableFreeWithCtx },
     297    { STKBACK("RTHandleTableLookupWithCtx"),             (void *)(uintptr_t)RTHandleTableLookupWithCtx },
     298    { STKBACK("RTLogBulkUpdate"),                        (void *)(uintptr_t)RTLogBulkUpdate},
     299    { STKBACK("RTLogCheckGroupFlags"),                   (void *)(uintptr_t)RTLogCheckGroupFlags },
     300    { STKBACK("RTLogCreateEx"),                          (void *)(uintptr_t)RTLogCreateEx },
     301    { STKBACK("RTLogDestroy"),                           (void *)(uintptr_t)RTLogDestroy },
     302    { STKBACK("RTLogDefaultInstance"),                   (void *)(uintptr_t)RTLogDefaultInstance },
     303    { STKBACK("RTLogDefaultInstanceEx"),                 (void *)(uintptr_t)RTLogDefaultInstanceEx },
     304    { STKBACK("SUPR0DefaultLogInstanceEx"),              (void *)(uintptr_t)SUPR0DefaultLogInstanceEx },
     305    { STKBACK("RTLogGetDefaultInstance"),                (void *)(uintptr_t)RTLogGetDefaultInstance },
     306    { STKBACK("RTLogGetDefaultInstanceEx"),              (void *)(uintptr_t)RTLogGetDefaultInstanceEx },
     307    { STKBACK("SUPR0GetDefaultLogInstanceEx"),           (void *)(uintptr_t)SUPR0GetDefaultLogInstanceEx },
     308    { STKBACK("RTLogLoggerExV"),                         (void *)(uintptr_t)RTLogLoggerExV },
     309    { STKBACK("RTLogPrintfV"),                           (void *)(uintptr_t)RTLogPrintfV },
     310    { STKBACK("RTLogRelGetDefaultInstance"),             (void *)(uintptr_t)RTLogRelGetDefaultInstance },
     311    { STKBACK("RTLogRelGetDefaultInstanceEx"),           (void *)(uintptr_t)RTLogRelGetDefaultInstanceEx },
     312    { STKBACK("SUPR0GetDefaultLogRelInstanceEx"),        (void *)(uintptr_t)SUPR0GetDefaultLogRelInstanceEx },
     313    { STKBACK("RTLogSetDefaultInstanceThread"),          (void *)(uintptr_t)RTLogSetDefaultInstanceThread },
     314    { STKBACK("RTLogSetFlushCallback"),                  (void *)(uintptr_t)RTLogSetFlushCallback },
     315    { STKBACK("RTLogSetR0ProgramStart"),                 (void *)(uintptr_t)RTLogSetR0ProgramStart },
     316    { STKBACK("RTLogSetR0ThreadNameF"),                  (void *)(uintptr_t)RTLogSetR0ThreadNameF },
     317    { STKBACK("RTMemAllocExTag"),                        (void *)(uintptr_t)RTMemAllocExTag },
     318    { STKBACK("RTMemAllocTag"),                          (void *)(uintptr_t)RTMemAllocTag },
     319    { STKBACK("RTMemAllocVarTag"),                       (void *)(uintptr_t)RTMemAllocVarTag },
     320    { STKBACK("RTMemAllocZTag"),                         (void *)(uintptr_t)RTMemAllocZTag },
     321    { STKBACK("RTMemAllocZVarTag"),                      (void *)(uintptr_t)RTMemAllocZVarTag },
     322    { STKBACK("RTMemDupExTag"),                          (void *)(uintptr_t)RTMemDupExTag },
     323    { STKBACK("RTMemDupTag"),                            (void *)(uintptr_t)RTMemDupTag },
     324    { STKBACK("RTMemFree"),                              (void *)(uintptr_t)RTMemFree },
     325    { STKBACK("RTMemFreeEx"),                            (void *)(uintptr_t)RTMemFreeEx },
     326    { STKBACK("RTMemReallocTag"),                        (void *)(uintptr_t)RTMemReallocTag },
     327    { STKBACK("RTMpCpuId"),                              (void *)(uintptr_t)RTMpCpuId },
     328    { STKBACK("RTMpCpuIdFromSetIndex"),                  (void *)(uintptr_t)RTMpCpuIdFromSetIndex },
     329    { STKBACK("RTMpCpuIdToSetIndex"),                    (void *)(uintptr_t)RTMpCpuIdToSetIndex },
     330    { STKBACK("RTMpCurSetIndex"),                        (void *)(uintptr_t)RTMpCurSetIndex },
     331    { STKBACK("RTMpCurSetIndexAndId"),                   (void *)(uintptr_t)RTMpCurSetIndexAndId },
     332    { STKBACK("RTMpGetArraySize"),                       (void *)(uintptr_t)RTMpGetArraySize },
     333    { STKBACK("RTMpGetCount"),                           (void *)(uintptr_t)RTMpGetCount },
     334    { STKBACK("RTMpGetMaxCpuId"),                        (void *)(uintptr_t)RTMpGetMaxCpuId },
     335    { STKBACK("RTMpGetOnlineCount"),                     (void *)(uintptr_t)RTMpGetOnlineCount },
     336    { STKBACK("RTMpGetOnlineSet"),                       (void *)(uintptr_t)RTMpGetOnlineSet },
     337    { STKBACK("RTMpGetSet"),                             (void *)(uintptr_t)RTMpGetSet },
     338    { STKBACK("RTMpIsCpuOnline"),                        (void *)(uintptr_t)RTMpIsCpuOnline },
     339    { STKBACK("RTMpIsCpuPossible"),                      (void *)(uintptr_t)RTMpIsCpuPossible },
     340    { STKBACK("RTMpIsCpuWorkPending"),                   (void *)(uintptr_t)RTMpIsCpuWorkPending },
     341    { STKBACK("RTMpNotificationDeregister"),             (void *)(uintptr_t)RTMpNotificationDeregister },
     342    { STKBACK("RTMpNotificationRegister"),               (void *)(uintptr_t)RTMpNotificationRegister },
     343    { STKBACK("RTMpOnAll"),                              (void *)(uintptr_t)RTMpOnAll },
     344    { STKBACK("RTMpOnOthers"),                           (void *)(uintptr_t)RTMpOnOthers },
     345    { STKBACK("RTMpOnSpecific"),                         (void *)(uintptr_t)RTMpOnSpecific },
     346    { STKBACK("RTMpPokeCpu"),                            (void *)(uintptr_t)RTMpPokeCpu },
     347    { STKBACK("RTNetIPv4AddDataChecksum"),               (void *)(uintptr_t)RTNetIPv4AddDataChecksum },
     348    { STKBACK("RTNetIPv4AddTCPChecksum"),                (void *)(uintptr_t)RTNetIPv4AddTCPChecksum },
     349    { STKBACK("RTNetIPv4AddUDPChecksum"),                (void *)(uintptr_t)RTNetIPv4AddUDPChecksum },
     350    { STKBACK("RTNetIPv4FinalizeChecksum"),              (void *)(uintptr_t)RTNetIPv4FinalizeChecksum },
     351    { STKOKAY("RTNetIPv4HdrChecksum"),                   (void *)(uintptr_t)RTNetIPv4HdrChecksum },
     352    { STKOKAY("RTNetIPv4IsDHCPValid"),                   (void *)(uintptr_t)RTNetIPv4IsDHCPValid },
     353    { STKOKAY("RTNetIPv4IsHdrValid"),                    (void *)(uintptr_t)RTNetIPv4IsHdrValid },
     354    { STKOKAY("RTNetIPv4IsTCPSizeValid"),                (void *)(uintptr_t)RTNetIPv4IsTCPSizeValid },
     355    { STKOKAY("RTNetIPv4IsTCPValid"),                    (void *)(uintptr_t)RTNetIPv4IsTCPValid },
     356    { STKOKAY("RTNetIPv4IsUDPSizeValid"),                (void *)(uintptr_t)RTNetIPv4IsUDPSizeValid },
     357    { STKOKAY("RTNetIPv4IsUDPValid"),                    (void *)(uintptr_t)RTNetIPv4IsUDPValid },
     358    { STKOKAY("RTNetIPv4PseudoChecksum"),                (void *)(uintptr_t)RTNetIPv4PseudoChecksum },
     359    { STKOKAY("RTNetIPv4PseudoChecksumBits"),            (void *)(uintptr_t)RTNetIPv4PseudoChecksumBits },
     360    { STKOKAY("RTNetIPv4TCPChecksum"),                   (void *)(uintptr_t)RTNetIPv4TCPChecksum },
     361    { STKOKAY("RTNetIPv4UDPChecksum"),                   (void *)(uintptr_t)RTNetIPv4UDPChecksum },
     362    { STKOKAY("RTNetIPv6PseudoChecksum"),                (void *)(uintptr_t)RTNetIPv6PseudoChecksum },
     363    { STKOKAY("RTNetIPv6PseudoChecksumBits"),            (void *)(uintptr_t)RTNetIPv6PseudoChecksumBits },
     364    { STKOKAY("RTNetIPv6PseudoChecksumEx"),              (void *)(uintptr_t)RTNetIPv6PseudoChecksumEx },
     365    { STKOKAY("RTNetTCPChecksum"),                       (void *)(uintptr_t)RTNetTCPChecksum },
     366    { STKOKAY("RTNetUDPChecksum"),                       (void *)(uintptr_t)RTNetUDPChecksum },
     367    { STKBACK("RTPowerNotificationDeregister"),          (void *)(uintptr_t)RTPowerNotificationDeregister },
     368    { STKBACK("RTPowerNotificationRegister"),            (void *)(uintptr_t)RTPowerNotificationRegister },
     369    { STKBACK("RTProcSelf"),                             (void *)(uintptr_t)RTProcSelf },
     370    { STKBACK("RTR0AssertPanicSystem"),                  (void *)(uintptr_t)RTR0AssertPanicSystem },
    359371#if defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS) || defined(RT_OS_WINDOWS)
    360     { "RTR0DbgKrnlInfoOpen",                    (void *)(uintptr_t)RTR0DbgKrnlInfoOpen },          /* only-darwin, only-solaris, only-windows */
    361     { "RTR0DbgKrnlInfoQueryMember",             (void *)(uintptr_t)RTR0DbgKrnlInfoQueryMember },   /* only-darwin, only-solaris, only-windows */
     372    { STKBACK("RTR0DbgKrnlInfoOpen"),                    (void *)(uintptr_t)RTR0DbgKrnlInfoOpen },          /* only-darwin, only-solaris, only-windows */
     373    { STKBACK("RTR0DbgKrnlInfoQueryMember"),             (void *)(uintptr_t)RTR0DbgKrnlInfoQueryMember },   /* only-darwin, only-solaris, only-windows */
    362374# if defined(RT_OS_SOLARIS)
    363     { "RTR0DbgKrnlInfoQuerySize",               (void *)(uintptr_t)RTR0DbgKrnlInfoQuerySize },     /* only-solaris */
     375    { STKBACK("RTR0DbgKrnlInfoQuerySize"),               (void *)(uintptr_t)RTR0DbgKrnlInfoQuerySize },     /* only-solaris */
    364376# endif
    365     { "RTR0DbgKrnlInfoQuerySymbol",             (void *)(uintptr_t)RTR0DbgKrnlInfoQuerySymbol },   /* only-darwin, only-solaris, only-windows */
    366     { "RTR0DbgKrnlInfoRelease",                 (void *)(uintptr_t)RTR0DbgKrnlInfoRelease },       /* only-darwin, only-solaris, only-windows */
    367     { "RTR0DbgKrnlInfoRetain",                  (void *)(uintptr_t)RTR0DbgKrnlInfoRetain },        /* only-darwin, only-solaris, only-windows */
     377    { STKBACK("RTR0DbgKrnlInfoQuerySymbol"),             (void *)(uintptr_t)RTR0DbgKrnlInfoQuerySymbol },   /* only-darwin, only-solaris, only-windows */
     378    { STKBACK("RTR0DbgKrnlInfoRelease"),                 (void *)(uintptr_t)RTR0DbgKrnlInfoRelease },       /* only-darwin, only-solaris, only-windows */
     379    { STKBACK("RTR0DbgKrnlInfoRetain"),                  (void *)(uintptr_t)RTR0DbgKrnlInfoRetain },        /* only-darwin, only-solaris, only-windows */
    368380#endif
    369     { "RTR0MemAreKrnlAndUsrDifferent",          (void *)(uintptr_t)RTR0MemAreKrnlAndUsrDifferent },
    370     { "RTR0MemKernelIsValidAddr",               (void *)(uintptr_t)RTR0MemKernelIsValidAddr },
    371     { "RTR0MemKernelCopyFrom",                  (void *)(uintptr_t)RTR0MemKernelCopyFrom },
    372     { "RTR0MemKernelCopyTo",                    (void *)(uintptr_t)RTR0MemKernelCopyTo },
    373     { "RTR0MemObjAddress",                      (void *)(uintptr_t)RTR0MemObjAddress },
    374     { "RTR0MemObjAddressR3",                    (void *)(uintptr_t)RTR0MemObjAddressR3 },
    375     { "RTR0MemObjAllocContTag",                 (void *)(uintptr_t)RTR0MemObjAllocContTag },
    376     { "RTR0MemObjAllocLargeTag",                (void *)(uintptr_t)RTR0MemObjAllocLargeTag },
    377     { "RTR0MemObjAllocLowTag",                  (void *)(uintptr_t)RTR0MemObjAllocLowTag },
    378     { "RTR0MemObjAllocPageTag",                 (void *)(uintptr_t)RTR0MemObjAllocPageTag },
    379     { "RTR0MemObjAllocPhysExTag",               (void *)(uintptr_t)RTR0MemObjAllocPhysExTag },
    380     { "RTR0MemObjAllocPhysNCTag",               (void *)(uintptr_t)RTR0MemObjAllocPhysNCTag },
    381     { "RTR0MemObjAllocPhysTag",                 (void *)(uintptr_t)RTR0MemObjAllocPhysTag },
    382     { "RTR0MemObjEnterPhysTag",                 (void *)(uintptr_t)RTR0MemObjEnterPhysTag },
    383     { "RTR0MemObjFree",                         (void *)(uintptr_t)RTR0MemObjFree },
    384     { "RTR0MemObjGetPagePhysAddr",              (void *)(uintptr_t)RTR0MemObjGetPagePhysAddr },
    385     { "RTR0MemObjIsMapping",                    (void *)(uintptr_t)RTR0MemObjIsMapping },
    386     { "RTR0MemObjLockUserTag",                  (void *)(uintptr_t)RTR0MemObjLockUserTag },
    387     { "RTR0MemObjLockKernelTag",                (void *)(uintptr_t)RTR0MemObjLockKernelTag },
    388     { "RTR0MemObjMapKernelExTag",               (void *)(uintptr_t)RTR0MemObjMapKernelExTag },
    389     { "RTR0MemObjMapKernelTag",                 (void *)(uintptr_t)RTR0MemObjMapKernelTag },
    390     { "RTR0MemObjMapUserTag",                   (void *)(uintptr_t)RTR0MemObjMapUserTag },
    391     { "RTR0MemObjMapUserExTag",                 (void *)(uintptr_t)RTR0MemObjMapUserExTag },
    392     { "RTR0MemObjProtect",                      (void *)(uintptr_t)RTR0MemObjProtect },
    393     { "RTR0MemObjSize",                         (void *)(uintptr_t)RTR0MemObjSize },
    394     { "RTR0MemUserCopyFrom",                    (void *)(uintptr_t)RTR0MemUserCopyFrom },
    395     { "RTR0MemUserCopyTo",                      (void *)(uintptr_t)RTR0MemUserCopyTo },
    396     { "RTR0MemUserIsValidAddr",                 (void *)(uintptr_t)RTR0MemUserIsValidAddr },
    397     { "RTR0ProcHandleSelf",                     (void *)(uintptr_t)RTR0ProcHandleSelf },
    398     { "RTSemEventCreate",                       (void *)(uintptr_t)RTSemEventCreate },
    399     { "RTSemEventDestroy",                      (void *)(uintptr_t)RTSemEventDestroy },
    400     { "RTSemEventGetResolution",                (void *)(uintptr_t)RTSemEventGetResolution },
    401     { "RTSemEventIsSignalSafe",                 (void *)(uintptr_t)RTSemEventIsSignalSafe },
    402     { "RTSemEventMultiCreate",                  (void *)(uintptr_t)RTSemEventMultiCreate },
    403     { "RTSemEventMultiDestroy",                 (void *)(uintptr_t)RTSemEventMultiDestroy },
    404     { "RTSemEventMultiGetResolution",           (void *)(uintptr_t)RTSemEventMultiGetResolution },
    405     { "RTSemEventMultiIsSignalSafe",            (void *)(uintptr_t)RTSemEventMultiIsSignalSafe },
    406     { "RTSemEventMultiReset",                   (void *)(uintptr_t)RTSemEventMultiReset },
    407     { "RTSemEventMultiSignal",                  (void *)(uintptr_t)RTSemEventMultiSignal },
    408     { "RTSemEventMultiWait",                    (void *)(uintptr_t)RTSemEventMultiWait },
    409     { "RTSemEventMultiWaitEx",                  (void *)(uintptr_t)RTSemEventMultiWaitEx },
    410     { "RTSemEventMultiWaitExDebug",             (void *)(uintptr_t)RTSemEventMultiWaitExDebug },
    411     { "RTSemEventMultiWaitNoResume",            (void *)(uintptr_t)RTSemEventMultiWaitNoResume },
    412     { "RTSemEventSignal",                       (void *)(uintptr_t)RTSemEventSignal },
    413     { "RTSemEventWait",                         (void *)(uintptr_t)RTSemEventWait },
    414     { "RTSemEventWaitEx",                       (void *)(uintptr_t)RTSemEventWaitEx },
    415     { "RTSemEventWaitExDebug",                  (void *)(uintptr_t)RTSemEventWaitExDebug },
    416     { "RTSemEventWaitNoResume",                 (void *)(uintptr_t)RTSemEventWaitNoResume },
    417     { "RTSemFastMutexCreate",                   (void *)(uintptr_t)RTSemFastMutexCreate },
    418     { "RTSemFastMutexDestroy",                  (void *)(uintptr_t)RTSemFastMutexDestroy },
    419     { "RTSemFastMutexRelease",                  (void *)(uintptr_t)RTSemFastMutexRelease },
    420     { "RTSemFastMutexRequest",                  (void *)(uintptr_t)RTSemFastMutexRequest },
    421     { "RTSemMutexCreate",                       (void *)(uintptr_t)RTSemMutexCreate },
    422     { "RTSemMutexDestroy",                      (void *)(uintptr_t)RTSemMutexDestroy },
    423     { "RTSemMutexRelease",                      (void *)(uintptr_t)RTSemMutexRelease },
    424     { "RTSemMutexRequest",                      (void *)(uintptr_t)RTSemMutexRequest },
    425     { "RTSemMutexRequestDebug",                 (void *)(uintptr_t)RTSemMutexRequestDebug },
    426     { "RTSemMutexRequestNoResume",              (void *)(uintptr_t)RTSemMutexRequestNoResume },
    427     { "RTSemMutexRequestNoResumeDebug",         (void *)(uintptr_t)RTSemMutexRequestNoResumeDebug },
    428     { "RTSpinlockAcquire",                      (void *)(uintptr_t)RTSpinlockAcquire },
    429     { "RTSpinlockCreate",                       (void *)(uintptr_t)RTSpinlockCreate },
    430     { "RTSpinlockDestroy",                      (void *)(uintptr_t)RTSpinlockDestroy },
    431     { "RTSpinlockRelease",                      (void *)(uintptr_t)RTSpinlockRelease },
    432     { "RTStrCopy",                              (void *)(uintptr_t)RTStrCopy },
    433     { "RTStrDupTag",                            (void *)(uintptr_t)RTStrDupTag },
    434     { "RTStrFormat",                            (void *)(uintptr_t)RTStrFormat },
    435     { "RTStrFormatNumber",                      (void *)(uintptr_t)RTStrFormatNumber },
    436     { "RTStrFormatTypeDeregister",              (void *)(uintptr_t)RTStrFormatTypeDeregister },
    437     { "RTStrFormatTypeRegister",                (void *)(uintptr_t)RTStrFormatTypeRegister },
    438     { "RTStrFormatTypeSetUser",                 (void *)(uintptr_t)RTStrFormatTypeSetUser },
    439     { "RTStrFormatV",                           (void *)(uintptr_t)RTStrFormatV },
    440     { "RTStrFree",                              (void *)(uintptr_t)RTStrFree },
    441     { "RTStrNCmp",                              (void *)(uintptr_t)RTStrNCmp },
    442     { "RTStrPrintf",                            (void *)(uintptr_t)RTStrPrintf },
    443     { "RTStrPrintfEx",                          (void *)(uintptr_t)RTStrPrintfEx },
    444     { "RTStrPrintfExV",                         (void *)(uintptr_t)RTStrPrintfExV },
    445     { "RTStrPrintfV",                           (void *)(uintptr_t)RTStrPrintfV },
    446     { "RTThreadCreate",                         (void *)(uintptr_t)RTThreadCreate },
    447     { "RTThreadCtxHookIsEnabled",               (void *)(uintptr_t)RTThreadCtxHookIsEnabled },
    448     { "RTThreadCtxHookCreate",                  (void *)(uintptr_t)RTThreadCtxHookCreate },
    449     { "RTThreadCtxHookDestroy",                 (void *)(uintptr_t)RTThreadCtxHookDestroy },
    450     { "RTThreadCtxHookDisable",                 (void *)(uintptr_t)RTThreadCtxHookDisable },
    451     { "RTThreadCtxHookEnable",                  (void *)(uintptr_t)RTThreadCtxHookEnable },
    452     { "RTThreadGetName",                        (void *)(uintptr_t)RTThreadGetName },
    453     { "RTThreadGetNative",                      (void *)(uintptr_t)RTThreadGetNative },
    454     { "RTThreadGetType",                        (void *)(uintptr_t)RTThreadGetType },
    455     { "RTThreadIsInInterrupt",                  (void *)(uintptr_t)RTThreadIsInInterrupt },
    456     { "RTThreadNativeSelf",                     (void *)(uintptr_t)RTThreadNativeSelf },
    457     { "RTThreadPreemptDisable",                 (void *)(uintptr_t)RTThreadPreemptDisable },
    458     { "RTThreadPreemptIsEnabled",               (void *)(uintptr_t)RTThreadPreemptIsEnabled },
    459     { "RTThreadPreemptIsPending",               (void *)(uintptr_t)RTThreadPreemptIsPending },
    460     { "RTThreadPreemptIsPendingTrusty",         (void *)(uintptr_t)RTThreadPreemptIsPendingTrusty },
    461     { "RTThreadPreemptIsPossible",              (void *)(uintptr_t)RTThreadPreemptIsPossible },
    462     { "RTThreadPreemptRestore",                 (void *)(uintptr_t)RTThreadPreemptRestore },
    463     { "RTThreadQueryTerminationStatus",         (void *)(uintptr_t)RTThreadQueryTerminationStatus },
    464     { "RTThreadSelf",                           (void *)(uintptr_t)RTThreadSelf },
    465     { "RTThreadSelfName",                       (void *)(uintptr_t)RTThreadSelfName },
    466     { "RTThreadSleep",                          (void *)(uintptr_t)RTThreadSleep },
    467     { "RTThreadUserReset",                      (void *)(uintptr_t)RTThreadUserReset },
    468     { "RTThreadUserSignal",                     (void *)(uintptr_t)RTThreadUserSignal },
    469     { "RTThreadUserWait",                       (void *)(uintptr_t)RTThreadUserWait },
    470     { "RTThreadUserWaitNoResume",               (void *)(uintptr_t)RTThreadUserWaitNoResume },
    471     { "RTThreadWait",                           (void *)(uintptr_t)RTThreadWait },
    472     { "RTThreadWaitNoResume",                   (void *)(uintptr_t)RTThreadWaitNoResume },
    473     { "RTThreadYield",                          (void *)(uintptr_t)RTThreadYield },
    474     { "RTTimeNow",                              (void *)(uintptr_t)RTTimeNow },
    475     { "RTTimerCanDoHighResolution",             (void *)(uintptr_t)RTTimerCanDoHighResolution },
    476     { "RTTimerChangeInterval",                  (void *)(uintptr_t)RTTimerChangeInterval },
    477     { "RTTimerCreate",                          (void *)(uintptr_t)RTTimerCreate },
    478     { "RTTimerCreateEx",                        (void *)(uintptr_t)RTTimerCreateEx },
    479     { "RTTimerDestroy",                         (void *)(uintptr_t)RTTimerDestroy },
    480     { "RTTimerGetSystemGranularity",            (void *)(uintptr_t)RTTimerGetSystemGranularity },
    481     { "RTTimerReleaseSystemGranularity",        (void *)(uintptr_t)RTTimerReleaseSystemGranularity },
    482     { "RTTimerRequestSystemGranularity",        (void *)(uintptr_t)RTTimerRequestSystemGranularity },
    483     { "RTTimerStart",                           (void *)(uintptr_t)RTTimerStart },
    484     { "RTTimerStop",                            (void *)(uintptr_t)RTTimerStop },
    485     { "RTTimeSystemMilliTS",                    (void *)(uintptr_t)RTTimeSystemMilliTS },
    486     { "RTTimeSystemNanoTS",                     (void *)(uintptr_t)RTTimeSystemNanoTS },
    487     { "RTUuidCompare",                          (void *)(uintptr_t)RTUuidCompare },
    488     { "RTUuidCompareStr",                       (void *)(uintptr_t)RTUuidCompareStr },
    489     { "RTUuidFromStr",                          (void *)(uintptr_t)RTUuidFromStr },
     381    { STKBACK("RTR0MemAreKrnlAndUsrDifferent"),          (void *)(uintptr_t)RTR0MemAreKrnlAndUsrDifferent },
     382    { STKBACK("RTR0MemKernelIsValidAddr"),               (void *)(uintptr_t)RTR0MemKernelIsValidAddr },
     383    { STKBACK("RTR0MemKernelCopyFrom"),                  (void *)(uintptr_t)RTR0MemKernelCopyFrom },
     384    { STKBACK("RTR0MemKernelCopyTo"),                    (void *)(uintptr_t)RTR0MemKernelCopyTo },
     385    { STKOKAY("RTR0MemObjAddress"),                      (void *)(uintptr_t)RTR0MemObjAddress },
     386    { STKOKAY("RTR0MemObjAddressR3"),                    (void *)(uintptr_t)RTR0MemObjAddressR3 },
     387    { STKBACK("RTR0MemObjAllocContTag"),                 (void *)(uintptr_t)RTR0MemObjAllocContTag },
     388    { STKBACK("RTR0MemObjAllocLargeTag"),                (void *)(uintptr_t)RTR0MemObjAllocLargeTag },
     389    { STKBACK("RTR0MemObjAllocLowTag"),                  (void *)(uintptr_t)RTR0MemObjAllocLowTag },
     390    { STKBACK("RTR0MemObjAllocPageTag"),                 (void *)(uintptr_t)RTR0MemObjAllocPageTag },
     391    { STKBACK("RTR0MemObjAllocPhysExTag"),               (void *)(uintptr_t)RTR0MemObjAllocPhysExTag },
     392    { STKBACK("RTR0MemObjAllocPhysNCTag"),               (void *)(uintptr_t)RTR0MemObjAllocPhysNCTag },
     393    { STKBACK("RTR0MemObjAllocPhysTag"),                 (void *)(uintptr_t)RTR0MemObjAllocPhysTag },
     394    { STKBACK("RTR0MemObjEnterPhysTag"),                 (void *)(uintptr_t)RTR0MemObjEnterPhysTag },
     395    { STKBACK("RTR0MemObjFree"),                         (void *)(uintptr_t)RTR0MemObjFree },
     396    { STKBACK("RTR0MemObjGetPagePhysAddr"),              (void *)(uintptr_t)RTR0MemObjGetPagePhysAddr },
     397    { STKOKAY("RTR0MemObjIsMapping"),                    (void *)(uintptr_t)RTR0MemObjIsMapping },
     398    { STKBACK("RTR0MemObjLockUserTag"),                  (void *)(uintptr_t)RTR0MemObjLockUserTag },
     399    { STKBACK("RTR0MemObjLockKernelTag"),                (void *)(uintptr_t)RTR0MemObjLockKernelTag },
     400    { STKBACK("RTR0MemObjMapKernelExTag"),               (void *)(uintptr_t)RTR0MemObjMapKernelExTag },
     401    { STKBACK("RTR0MemObjMapKernelTag"),                 (void *)(uintptr_t)RTR0MemObjMapKernelTag },
     402    { STKBACK("RTR0MemObjMapUserTag"),                   (void *)(uintptr_t)RTR0MemObjMapUserTag },
     403    { STKBACK("RTR0MemObjMapUserExTag"),                 (void *)(uintptr_t)RTR0MemObjMapUserExTag },
     404    { STKBACK("RTR0MemObjProtect"),                      (void *)(uintptr_t)RTR0MemObjProtect },
     405    { STKOKAY("RTR0MemObjSize"),                         (void *)(uintptr_t)RTR0MemObjSize },
     406    { STKBACK("RTR0MemUserCopyFrom"),                    (void *)(uintptr_t)RTR0MemUserCopyFrom },
     407    { STKBACK("RTR0MemUserCopyTo"),                      (void *)(uintptr_t)RTR0MemUserCopyTo },
     408    { STKBACK("RTR0MemUserIsValidAddr"),                 (void *)(uintptr_t)RTR0MemUserIsValidAddr },
     409    { STKBACK("RTR0ProcHandleSelf"),                     (void *)(uintptr_t)RTR0ProcHandleSelf },
     410    { STKBACK("RTSemEventCreate"),                       (void *)(uintptr_t)RTSemEventCreate },
     411    { STKBACK("RTSemEventDestroy"),                      (void *)(uintptr_t)RTSemEventDestroy },
     412    { STKBACK("RTSemEventGetResolution"),                (void *)(uintptr_t)RTSemEventGetResolution },
     413    { STKBACK("RTSemEventIsSignalSafe"),                 (void *)(uintptr_t)RTSemEventIsSignalSafe },
     414    { STKBACK("RTSemEventMultiCreate"),                  (void *)(uintptr_t)RTSemEventMultiCreate },
     415    { STKBACK("RTSemEventMultiDestroy"),                 (void *)(uintptr_t)RTSemEventMultiDestroy },
     416    { STKBACK("RTSemEventMultiGetResolution"),           (void *)(uintptr_t)RTSemEventMultiGetResolution },
     417    { STKBACK("RTSemEventMultiIsSignalSafe"),            (void *)(uintptr_t)RTSemEventMultiIsSignalSafe },
     418    { STKBACK("RTSemEventMultiReset"),                   (void *)(uintptr_t)RTSemEventMultiReset },
     419    { STKBACK("RTSemEventMultiSignal"),                  (void *)(uintptr_t)RTSemEventMultiSignal },
     420    { STKBACK("RTSemEventMultiWait"),                    (void *)(uintptr_t)RTSemEventMultiWait },
     421    { STKBACK("RTSemEventMultiWaitEx"),                  (void *)(uintptr_t)RTSemEventMultiWaitEx },
     422    { STKBACK("RTSemEventMultiWaitExDebug"),             (void *)(uintptr_t)RTSemEventMultiWaitExDebug },
     423    { STKBACK("RTSemEventMultiWaitNoResume"),            (void *)(uintptr_t)RTSemEventMultiWaitNoResume },
     424    { STKBACK("RTSemEventSignal"),                       (void *)(uintptr_t)RTSemEventSignal },
     425    { STKBACK("RTSemEventWait"),                         (void *)(uintptr_t)RTSemEventWait },
     426    { STKBACK("RTSemEventWaitEx"),                       (void *)(uintptr_t)RTSemEventWaitEx },
     427    { STKBACK("RTSemEventWaitExDebug"),                  (void *)(uintptr_t)RTSemEventWaitExDebug },
     428    { STKBACK("RTSemEventWaitNoResume"),                 (void *)(uintptr_t)RTSemEventWaitNoResume },
     429    { STKBACK("RTSemFastMutexCreate"),                   (void *)(uintptr_t)RTSemFastMutexCreate },
     430    { STKBACK("RTSemFastMutexDestroy"),                  (void *)(uintptr_t)RTSemFastMutexDestroy },
     431    { STKBACK("RTSemFastMutexRelease"),                  (void *)(uintptr_t)RTSemFastMutexRelease },
     432    { STKBACK("RTSemFastMutexRequest"),                  (void *)(uintptr_t)RTSemFastMutexRequest },
     433    { STKBACK("RTSemMutexCreate"),                       (void *)(uintptr_t)RTSemMutexCreate },
     434    { STKBACK("RTSemMutexDestroy"),                      (void *)(uintptr_t)RTSemMutexDestroy },
     435    { STKBACK("RTSemMutexRelease"),                      (void *)(uintptr_t)RTSemMutexRelease },
     436    { STKBACK("RTSemMutexRequest"),                      (void *)(uintptr_t)RTSemMutexRequest },
     437    { STKBACK("RTSemMutexRequestDebug"),                 (void *)(uintptr_t)RTSemMutexRequestDebug },
     438    { STKBACK("RTSemMutexRequestNoResume"),              (void *)(uintptr_t)RTSemMutexRequestNoResume },
     439    { STKBACK("RTSemMutexRequestNoResumeDebug"),         (void *)(uintptr_t)RTSemMutexRequestNoResumeDebug },
     440    { STKBACK("RTSpinlockAcquire"),                      (void *)(uintptr_t)RTSpinlockAcquire },
     441    { STKBACK("RTSpinlockCreate"),                       (void *)(uintptr_t)RTSpinlockCreate },
     442    { STKBACK("RTSpinlockDestroy"),                      (void *)(uintptr_t)RTSpinlockDestroy },
     443    { STKBACK("RTSpinlockRelease"),                      (void *)(uintptr_t)RTSpinlockRelease },
     444    { STKOKAY("RTStrCopy"),                              (void *)(uintptr_t)RTStrCopy },
     445    { STKBACK("RTStrDupTag"),                            (void *)(uintptr_t)RTStrDupTag },
     446    { STKBACK("RTStrFormat"),                            (void *)(uintptr_t)RTStrFormat },
     447    { STKBACK("RTStrFormatNumber"),                      (void *)(uintptr_t)RTStrFormatNumber },
     448    { STKBACK("RTStrFormatTypeDeregister"),              (void *)(uintptr_t)RTStrFormatTypeDeregister },
     449    { STKBACK("RTStrFormatTypeRegister"),                (void *)(uintptr_t)RTStrFormatTypeRegister },
     450    { STKBACK("RTStrFormatTypeSetUser"),                 (void *)(uintptr_t)RTStrFormatTypeSetUser },
     451    { STKBACK("RTStrFormatV"),                           (void *)(uintptr_t)RTStrFormatV },
     452    { STKBACK("RTStrFree"),                              (void *)(uintptr_t)RTStrFree },
     453    { STKOKAY("RTStrNCmp"),                              (void *)(uintptr_t)RTStrNCmp },
     454    { STKBACK("RTStrPrintf"),                            (void *)(uintptr_t)RTStrPrintf },
     455    { STKBACK("RTStrPrintfEx"),                          (void *)(uintptr_t)RTStrPrintfEx },
     456    { STKBACK("RTStrPrintfExV"),                         (void *)(uintptr_t)RTStrPrintfExV },
     457    { STKBACK("RTStrPrintfV"),                           (void *)(uintptr_t)RTStrPrintfV },
     458    { STKBACK("RTThreadCreate"),                         (void *)(uintptr_t)RTThreadCreate },
     459    { STKBACK("RTThreadCtxHookIsEnabled"),               (void *)(uintptr_t)RTThreadCtxHookIsEnabled },
     460    { STKBACK("RTThreadCtxHookCreate"),                  (void *)(uintptr_t)RTThreadCtxHookCreate },
     461    { STKBACK("RTThreadCtxHookDestroy"),                 (void *)(uintptr_t)RTThreadCtxHookDestroy },
     462    { STKBACK("RTThreadCtxHookDisable"),                 (void *)(uintptr_t)RTThreadCtxHookDisable },
     463    { STKBACK("RTThreadCtxHookEnable"),                  (void *)(uintptr_t)RTThreadCtxHookEnable },
     464    { STKBACK("RTThreadGetName"),                        (void *)(uintptr_t)RTThreadGetName },
     465    { STKBACK("RTThreadGetNative"),                      (void *)(uintptr_t)RTThreadGetNative },
     466    { STKBACK("RTThreadGetType"),                        (void *)(uintptr_t)RTThreadGetType },
     467    { STKBACK("RTThreadIsInInterrupt"),                  (void *)(uintptr_t)RTThreadIsInInterrupt },
     468    { STKBACK("RTThreadNativeSelf"),                     (void *)(uintptr_t)RTThreadNativeSelf },
     469    { STKBACK("RTThreadPreemptDisable"),                 (void *)(uintptr_t)RTThreadPreemptDisable },
     470    { STKBACK("RTThreadPreemptIsEnabled"),               (void *)(uintptr_t)RTThreadPreemptIsEnabled },
     471    { STKBACK("RTThreadPreemptIsPending"),               (void *)(uintptr_t)RTThreadPreemptIsPending },
     472    { STKBACK("RTThreadPreemptIsPendingTrusty"),         (void *)(uintptr_t)RTThreadPreemptIsPendingTrusty },
     473    { STKBACK("RTThreadPreemptIsPossible"),              (void *)(uintptr_t)RTThreadPreemptIsPossible },
     474    { STKBACK("RTThreadPreemptRestore"),                 (void *)(uintptr_t)RTThreadPreemptRestore },
     475    { STKBACK("RTThreadQueryTerminationStatus"),         (void *)(uintptr_t)RTThreadQueryTerminationStatus },
     476    { STKBACK("RTThreadSelf"),                           (void *)(uintptr_t)RTThreadSelf },
     477    { STKBACK("RTThreadSelfName"),                       (void *)(uintptr_t)RTThreadSelfName },
     478    { STKBACK("RTThreadSleep"),                          (void *)(uintptr_t)RTThreadSleep },
     479    { STKBACK("RTThreadUserReset"),                      (void *)(uintptr_t)RTThreadUserReset },
     480    { STKBACK("RTThreadUserSignal"),                     (void *)(uintptr_t)RTThreadUserSignal },
     481    { STKBACK("RTThreadUserWait"),                       (void *)(uintptr_t)RTThreadUserWait },
     482    { STKBACK("RTThreadUserWaitNoResume"),               (void *)(uintptr_t)RTThreadUserWaitNoResume },
     483    { STKBACK("RTThreadWait"),                           (void *)(uintptr_t)RTThreadWait },
     484    { STKBACK("RTThreadWaitNoResume"),                   (void *)(uintptr_t)RTThreadWaitNoResume },
     485    { STKBACK("RTThreadYield"),                          (void *)(uintptr_t)RTThreadYield },
     486    { STKBACK("RTTimeNow"),                              (void *)(uintptr_t)RTTimeNow },
     487    { STKBACK("RTTimerCanDoHighResolution"),             (void *)(uintptr_t)RTTimerCanDoHighResolution },
     488    { STKBACK("RTTimerChangeInterval"),                  (void *)(uintptr_t)RTTimerChangeInterval },
     489    { STKBACK("RTTimerCreate"),                          (void *)(uintptr_t)RTTimerCreate },
     490    { STKBACK("RTTimerCreateEx"),                        (void *)(uintptr_t)RTTimerCreateEx },
     491    { STKBACK("RTTimerDestroy"),                         (void *)(uintptr_t)RTTimerDestroy },
     492    { STKBACK("RTTimerGetSystemGranularity"),            (void *)(uintptr_t)RTTimerGetSystemGranularity },
     493    { STKBACK("RTTimerReleaseSystemGranularity"),        (void *)(uintptr_t)RTTimerReleaseSystemGranularity },
     494    { STKBACK("RTTimerRequestSystemGranularity"),        (void *)(uintptr_t)RTTimerRequestSystemGranularity },
     495    { STKBACK("RTTimerStart"),                           (void *)(uintptr_t)RTTimerStart },
     496    { STKBACK("RTTimerStop"),                            (void *)(uintptr_t)RTTimerStop },
     497    { STKBACK("RTTimeSystemMilliTS"),                    (void *)(uintptr_t)RTTimeSystemMilliTS },
     498    { STKBACK("RTTimeSystemNanoTS"),                     (void *)(uintptr_t)RTTimeSystemNanoTS },
     499    { STKOKAY("RTUuidCompare"),                          (void *)(uintptr_t)RTUuidCompare },
     500    { STKOKAY("RTUuidCompareStr"),                       (void *)(uintptr_t)RTUuidCompareStr },
     501    { STKOKAY("RTUuidFromStr"),                          (void *)(uintptr_t)RTUuidFromStr },
    490502/* SED: END */
    491503};
  • trunk/src/VBox/HostDrivers/Support/SUPDrvIOC.h

    r91674 r91775  
    223223 *          - nothing
    224224 */
    225 #define SUPDRV_IOC_VERSION                              0x00310004
     225#define SUPDRV_IOC_VERSION                              0x00330000
    226226
    227227/** SUP_IOCTL_COOKIE. */
     
    276276{
    277277    /** Name - mangled. */
    278     char            szName[32];
     278    char            szName[48];
    279279    /** Address. */
    280280    RTR0PTR         pfn;
  • trunk/src/VBox/HostDrivers/Support/SUPR0-asm-files.sed

    r91773 r91775  
    11# $Id$
    22## @file
    3 # IPRT - SED script for generating SUPR0.def
     3# IPRT - SED script for generating a list of assembly files for make inclusion.
    44#
    55
    66#
    7 # Copyright (C) 2012-2020 Oracle Corporation
     7# Copyright (C) 2012-2021 Oracle Corporation
    88#
    99# This file is part of VirtualBox Open Source Edition (OSE), as
     
    3535/SED: END/,$d
    3636
    37 # Drop all lines not specifying an export.
    38 /^    { "/!d
    39 
    40 # Handle trailing selection comment (/* solaris-only, windows-only */).
    41 /\*\/ *$/!b transform
    42 /only-windows/b transform
    43 /only-/!b transform
    44 d
    45 
    46 :transform
    47 # Transform the export line, the format is like this:
    48 #    { "g_pSUPGlobalInfoPage",                   (void *)&g_pSUPGlobalInfoPage },            /* SED: DATA */
    49 
    50 s/^    { "\([^"]*\)",[^}]*}[,]/    \1/
    51 
    52 s,/\* SED: \([A-Z]*\) \*/, \1,
    53 s, */\*.*\*/ *$,,
     37# We are only interested in the STKBACK lines.
     38/^    { STKBACK(/!d
     39s/^    { STKBACK("\([^"][^"]*\)"),.*$/    \$(SUPR0_0_OUTDIR)\/StkBack_\1.asm \\/
    5440b end
    5541
    5642:header
    57 i\;
    58 i\; Autogenerated. DO NOT EDIT!
    59 i\;
    60 i
    61 i\LIBRARY VBoxDrv.sys
    62 i
    63 i\EXPORTS
     43i\#
     44i\# Autogenerated. DO NOT EDIT!
     45i\#
     46i\SUPR0_VBOX_FILES = \\
    6447d
    6548
     
    6750:footer
    6851i
    69 i\; The end.
     52i\# The end.
    7053i
    7154d
  • trunk/src/VBox/HostDrivers/Support/SUPR0-asm.sed

    r91773 r91775  
    11# $Id$
    22## @file
    3 # IPRT - SED script for generating SUPR0.def
     3# IPRT - SED script for generating a list of assembly files for make inclusion.
    44#
    55
    66#
    7 # Copyright (C) 2012-2020 Oracle Corporation
     7# Copyright (C) 2012-2021 Oracle Corporation
    88#
    99# This file is part of VirtualBox Open Source Edition (OSE), as
     
    3535/SED: END/,$d
    3636
    37 # Drop all lines not specifying an export.
    38 /^    { "/!d
    39 
    40 # Handle trailing selection comment (/* solaris-only, windows-only */).
    41 /\*\/ *$/!b transform
    42 /only-windows/b transform
    43 /only-/!b transform
    44 d
    45 
    46 :transform
    47 # Transform the export line, the format is like this:
    48 #    { "g_pSUPGlobalInfoPage",                   (void *)&g_pSUPGlobalInfoPage },            /* SED: DATA */
    49 
    50 s/^    { "\([^"]*\)",[^}]*}[,]/    \1/
    51 
    52 s,/\* SED: \([A-Z]*\) \*/, \1,
    53 s, */\*.*\*/ *$,,
     37# We are only interested in the STKBACK lines.
     38/^    { STKBACK(/!d
     39s/^    { STKBACK("\([^"][^"]*\)"),.*$/\/\/ ##### BEGINFILE \"StkBack_\1.asm\"\n%include "VBox\/SUPR0StackWrapper.mac"\nSUPR0StackWrapperGeneric \1\n\/\/ ##### ENDFILE/
    5440b end
    5541
    5642:header
    57 i\;
    58 i\; Autogenerated. DO NOT EDIT!
    59 i\;
    60 i
    61 i\LIBRARY VBoxDrv.sys
    62 i
    63 i\EXPORTS
     43i\#
     44i\# Autogenerated. DO NOT EDIT!
     45i\#
    6446d
    6547
    6648
    6749:footer
    68 i
    69 i\; The end.
    70 i
    7150d
    7251
  • trunk/src/VBox/HostDrivers/Support/SUPR0-def-pe.sed

    r82968 r91775  
    3636
    3737# Drop all lines not specifying an export.
    38 /^    { "/!d
     38/^    { STK[BO][AK][CA][KY]/!d
     39
     40# Remove the darwin stack switch-back indicator.
     41s/STKBACK(\([^)][^)]*\))/\1/
     42s/STKOKAY(\([^)][^)]*\))/\1/
    3943
    4044# Handle trailing selection comment (/* solaris-only, windows-only */).
  • trunk/src/VBox/VMM/VMMR0/VMMR0JmpA-amd64.asm

    r90829 r91775  
    2424%include "VBox/err.mac"
    2525%include "VBox/param.mac"
     26%ifdef VMM_R0_SWITCH_STACK
     27 %include "VBox/SUPR0StackWrapper.mac"
     28%endif
    2629
    2730
     
    146149    mov     [rdi - 10h], rbx
    147150  %endif
    148     lea     r15, [r15 + VMM_STACK_SIZE - 40h]
    149     mov     rsp, r15                    ; Switch stack!
     151
     152    ; New RSP
     153  %ifdef WITHOUT_SUPR0STACKINFO
     154    lea     r15, [r15 + VMM_STACK_SIZE]
     155  %else
     156    lea     r15, [r15 + VMM_STACK_SIZE - SUPR0STACKINFO_size]
     157
     158    ; Plant SUPR0 stack info.
     159    mov     [r15 + SUPR0STACKINFO.pResumeKernelStack], rsp
     160    mov     [r15 + SUPR0STACKINFO.pSelf], r15
     161    mov     dword [r15 + SUPR0STACKINFO.magic0], SUPR0STACKINFO_MAGIC0
     162    mov     dword [r15 + SUPR0STACKINFO.magic1], SUPR0STACKINFO_MAGIC1
     163    mov     dword [r15 + SUPR0STACKINFO.magic2], SUPR0STACKINFO_MAGIC2
     164    mov     dword [r15 + SUPR0STACKINFO.magic3], SUPR0STACKINFO_MAGIC3
     165
     166  %endif
     167
     168    ; Switch stack!
     169  %ifndef WITHOUT_SUPR0STACKINFO
     170    lea     rsp, [r15 - 16*8 + SUPR0STACKINFO_size] ; Make sure the generic wrapper doesn't crash when moving 16 args.
     171  %else
     172   %ifdef ASM_CALL64_MSC
     173    lea     rsp, [r15 - 20h]
     174   %else
     175    mov     rsp, r15
     176   %endif
     177  %endif
    150178 %endif ; VMM_R0_SWITCH_STACK
    151179
     
    162190
    163191 %ifdef VMM_R0_SWITCH_STACK
     192    ; Reset the debug mark and the stack info header.
     193    mov     r15, [xDX + VMMR0JMPBUF.pvSavedStack]
     194  %ifndef WITHOUT_SUPR0STACKINFO
     195    mov     qword [r15 + VMM_STACK_SIZE - SUPR0STACKINFO_size + SUPR0STACKINFO.magic0], 0h
     196  %endif
    164197  %ifdef VBOX_STRICT
    165     mov     r15, [xDX + VMMR0JMPBUF.pvSavedStack]
    166198    mov     dword [r15], 0h             ; Reset the marker
    167199  %endif
     
    273305
    274306%ifdef VMM_R0_SWITCH_STACK
     307    ; Update the signature in case the kernel stack moved.
     308    mov     r15, [xDX + VMMR0JMPBUF.pvSavedStack]
     309    test    r15, r15
     310    jz      .entry_error
     311 %ifndef WITHOUT_SUPR0STACKINFO
     312    lea     r15, [r15 + VMM_STACK_SIZE - SUPR0STACKINFO_size]
     313
     314    mov     [r15 + SUPR0STACKINFO.pResumeKernelStack], rsp
     315    mov     [r15 + SUPR0STACKINFO.pSelf], r15
     316    mov     dword [r15 + SUPR0STACKINFO.magic0], SUPR0STACKINFO_MAGIC0
     317    mov     dword [r15 + SUPR0STACKINFO.magic1], SUPR0STACKINFO_MAGIC1
     318    mov     dword [r15 + SUPR0STACKINFO.magic2], SUPR0STACKINFO_MAGIC2
     319    mov     dword [r15 + SUPR0STACKINFO.magic3], SUPR0STACKINFO_MAGIC3
     320 %endif
     321
    275322    ; Switch stack.
    276323    mov     rsp, [xDX + VMMR0JMPBUF.SpResume]
  • trunk/src/VBox/VMM/testcase/Makefile.kmk

    r87466 r91775  
    314314tstVMMR0CallHost-2_EXTENDS = tstVMMR0CallHost-1
    315315tstVMMR0CallHost-2_DEFS = VMM_R0_SWITCH_STACK
     316tstVMMR0CallHost-2_SOURCES.amd64 = \
     317        $(tstVMMR0CallHost-1_SOURCES.amd64) \
     318        tstVMMR0CallHost-2A.asm
    316319
    317320#
  • trunk/src/VBox/VMM/testcase/tstVMMR0CallHost-1.cpp

    r91773 r91775  
    172172
    173173
     174#if defined(VMM_R0_SWITCH_STACK) && defined(RT_ARCH_AMD64)
     175/*
     176 * Stack switch back tests.
     177 */
     178RT_C_DECLS_BEGIN
     179DECLCALLBACK(int) tstWrapped1(        PVMMR0JMPBUF pJmp, uintptr_t u1, uintptr_t u2,  uintptr_t u3, uintptr_t u4, uintptr_t u5,
     180                                      uintptr_t u6, uintptr_t u7, uintptr_t u8, uintptr_t u9);
     181DECLCALLBACK(int) StkBack_tstWrapped1(PVMMR0JMPBUF pJmp, uintptr_t u1, uintptr_t u2,  uintptr_t u3, uintptr_t u4, uintptr_t u5,
     182                                      uintptr_t u6, uintptr_t u7, uintptr_t u8, uintptr_t u9);
     183DECLCALLBACK(int) tstWrappedThin(PVMMR0JMPBUF pJmp);
     184DECLCALLBACK(int) StkBack_tstWrappedThin(PVMMR0JMPBUF pJmp);
     185RT_C_DECLS_END
     186
     187
     188DECLCALLBACK(int) StkBack_tstWrapped1(PVMMR0JMPBUF pJmp, uintptr_t u1, uintptr_t u2,  uintptr_t u3, uintptr_t u4, uintptr_t u5,
     189                                      uintptr_t u6, uintptr_t u7, uintptr_t u8, uintptr_t u9)
     190{
     191    RTTESTI_CHECK_RET(pJmp == &g_Jmp, -1);
     192    RTTESTI_CHECK_RET(u1 == ~(uintptr_t)1U, -2);
     193    RTTESTI_CHECK_RET(u2 == ~(uintptr_t)2U, -3);
     194    RTTESTI_CHECK_RET(u3 == ~(uintptr_t)3U, -4);
     195    RTTESTI_CHECK_RET(u4 == ~(uintptr_t)4U, -5);
     196    RTTESTI_CHECK_RET(u5 == ~(uintptr_t)5U, -6);
     197    RTTESTI_CHECK_RET(u6 == ~(uintptr_t)6U, -7);
     198    RTTESTI_CHECK_RET(u7 == ~(uintptr_t)7U, -8);
     199    RTTESTI_CHECK_RET(u8 == ~(uintptr_t)8U, -9);
     200    RTTESTI_CHECK_RET(u9 == ~(uintptr_t)9U, -10);
     201
     202    void *pv = alloca(32);
     203    memset(pv, 'a', 32);
     204    RTTESTI_CHECK_RET((uintptr_t)pv - (uintptr_t)g_Jmp.pvSavedStack > VMM_STACK_SIZE, -11);
     205
     206    return 42;
     207}
     208
     209
     210DECLCALLBACK(int) tstSwitchBackInner(intptr_t i1, intptr_t i2)
     211{
     212    RTTESTI_CHECK_RET(i1 == -42, -20);
     213    RTTESTI_CHECK_RET(i2 == (intptr_t)&g_Jmp, -21);
     214
     215    void *pv = alloca(32);
     216    memset(pv, 'b', 32);
     217    RTTESTI_CHECK_RET((uintptr_t)pv - (uintptr_t)g_Jmp.pvSavedStack < VMM_STACK_SIZE, -22);
     218
     219    int rc = tstWrapped1(&g_Jmp,
     220                         ~(uintptr_t)1U,
     221                         ~(uintptr_t)2U,
     222                         ~(uintptr_t)3U,
     223                         ~(uintptr_t)4U,
     224                         ~(uintptr_t)5U,
     225                         ~(uintptr_t)6U,
     226                         ~(uintptr_t)7U,
     227                         ~(uintptr_t)8U,
     228                         ~(uintptr_t)9U);
     229    RTTESTI_CHECK_RET(rc == 42, -23);
     230    return rc;
     231}
     232
     233
     234DECLCALLBACK(int) StkBack_tstWrappedThin(PVMMR0JMPBUF pJmp)
     235{
     236    RTTESTI_CHECK_RET(pJmp == &g_Jmp, -31);
     237
     238    void *pv = alloca(32);
     239    memset(pv, 'c', 32);
     240    RTTESTI_CHECK_RET((uintptr_t)pv - (uintptr_t)g_Jmp.pvSavedStack > VMM_STACK_SIZE, -32);
     241
     242    return 42;
     243}
     244
     245DECLCALLBACK(int) tstSwitchBackInnerThin(intptr_t i1, intptr_t i2)
     246{
     247    RT_NOREF(i1);
     248    return tstWrappedThin((PVMMR0JMPBUF)i2);
     249}
     250
     251
     252void tstSwitchBack(void)
     253{
     254    RTR0PTR R0PtrSaved = g_Jmp.pvSavedStack;
     255    RT_ZERO(g_Jmp);
     256    g_Jmp.pvSavedStack = R0PtrSaved;
     257    memset((void *)g_Jmp.pvSavedStack, '\0', VMM_STACK_SIZE);
     258    g_cbFoo = 0;
     259    g_cJmps = 0;
     260    g_cbFooUsed = 0;
     261    g_fInLongJmp = false;
     262
     263    //for (int i = iFrom, iItr = 0; i != iTo; i += iInc, iItr++)
     264    {
     265        int rc = stackRandom(&g_Jmp, (PFNVMMR0SETJMP)(uintptr_t)tstSwitchBackInner, (PVM)(intptr_t)-42, (PVMCPU)&g_Jmp);
     266        RTTESTI_CHECK_MSG_RETV(rc == 42,
     267                               ("i=%d iOrg=%d rc=%d setjmp; cbFoo=%#x cbFooUsed=%#x fInLongJmp=%d\n",
     268                                0, 0 /*i, iOrg*/, rc, g_cbFoo, g_cbFooUsed, g_fInLongJmp));
     269
     270        rc = stackRandom(&g_Jmp, (PFNVMMR0SETJMP)(uintptr_t)tstSwitchBackInnerThin, NULL, (PVMCPU)&g_Jmp);
     271        RTTESTI_CHECK_MSG_RETV(rc == 42,
     272                               ("i=%d iOrg=%d rc=%d setjmp; cbFoo=%#x cbFooUsed=%#x fInLongJmp=%d\n",
     273                                0, 0 /*i, iOrg*/, rc, g_cbFoo, g_cbFooUsed, g_fInLongJmp));
     274
     275    }
     276    //RTTESTI_CHECK_MSG_RETV(g_cJmps, ("No jumps!"));
     277}
     278
     279#endif
     280
     281
    174282int main()
    175283{
     
    196304    RTTestSub(hTest, "Decreasing stack usage");
    197305    tst(7599, 0, -1);
     306#if defined(VMM_R0_SWITCH_STACK) && defined(RT_ARCH_AMD64)
     307    RTTestSub(hTest, "Switch back");
     308    tstSwitchBack();
     309#endif
    198310
    199311    return RTTestSummaryAndDestroy(hTest);
Note: See TracChangeset for help on using the changeset viewer.

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