Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

16 files changed, 14878 insertions, 0 deletions

diff --git a/src/VBox/Devices/testcase/Makefile.kmk b/src/VBox/Devices/testcase/Makefile.kmk
new file mode 100644
index 00000000..a65768b8
--- /dev/null
+++ b/src/VBox/Devices/testcase/Makefile.kmk
@@ -0,0 +1,157 @@
+# $Id: Makefile.kmk $
+## @file
+# Sub-Makefile for the device testcases.
+#
+
+#
+# Copyright (C) 2006-2023 Oracle and/or its affiliates.
+#
+# This file is part of VirtualBox base platform packages, as
+# available from https://www.virtualbox.org.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation, in version 3 of the
+# License.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <https://www.gnu.org/licenses>.
+#
+# SPDX-License-Identifier: GPL-3.0-only
+#
+
+SUB_DEPTH = ../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+#
+# Globals
+#
+VBOX_PATH_DEVICES_SRC ?= $(PATH_ROOT)/src/VBox/Devices
+VBOX_PATH_VMM_DEVICES_SRC ?= $(PATH_ROOT)/src/VBox/VMM/include
+VBOX_DEVICES_TEST_OUT_DIR := $(PATH_TARGET)/Devices/testcase
+BLDDIRS += $(VBOX_DEVICES_TEST_OUT_DIR)
+
+VBOX_DEVICES_TESTS_FEATURES = \
+	$(if $(VBOX_WITH_AHCI),VBOX_WITH_AHCI,) \
+	$(if $(VBOX_WITH_BUSLOGIC),VBOX_WITH_BUSLOGIC,) \
+	$(if $(VBOX_WITH_E1000),VBOX_WITH_E1000,) \
+	$(if $(VBOX_WITH_EHCI_IMPL),VBOX_WITH_EHCI_IMPL,) \
+	$(if $(VBOX_WITH_HGSMI),VBOX_WITH_HGSMI,) \
+	$(if $(VBOX_WITH_HP_HDA),VBOX_WITH_HP_HDA,) \
+	$(if $(VBOX_WITH_INTEL_HDA),VBOX_WITH_INTEL_HDA,) \
+	$(if $(VBOX_WITH_NVIDIA_HDA),VBOX_WITH_NVIDIA_HDA,) \
+	$(if $(VBOX_WITH_LSILOGIC),VBOX_WITH_LSILOGIC,) \
+	$(if $(VBOX_WITH_NVME_IMPL),VBOX_WITH_NVME_IMPL,) \
+	$(if $(VBOX_WITH_PCI_PASSTHROUGH_IMPL),VBOX_WITH_PCI_PASSTHROUGH_IMPL,) \
+	$(if $(VBOX_WITH_RAW_MODE),VBOX_WITH_RAW_MODE,) \
+	$(if $(VBOX_WITH_SCSI),VBOX_WITH_SCSI,) \
+	$(if $(VBOX_WITH_USB),VBOX_WITH_USB,) \
+	$(if $(VBOX_WITH_VDMA),VBOX_WITH_VDMA,) \
+	$(if $(VBOX_WITH_VIDEOHWACCEL),VBOX_WITH_VIDEOHWACCEL,) \
+	$(if $(VBOX_WITH_VIRTIO),VBOX_WITH_VIRTIO,) \
+	$(if $(VBOX_WITH_VMSVGA),VBOX_WITH_VMSVGA,) \
+	$(if $(VBOX_WITH_WDDM),VBOX_WITH_WDDM,) \
+	$(if $(VBOX_WITH_XHCI_IMPL),VBOX_WITH_XHCI_IMPL,) \
+	$(if $(VBOX_WITH_IOMMU_AMD),VBOX_WITH_IOMMU_AMD,) \
+	$(if $(VBOX_WITH_IOMMU_INTEL),VBOX_WITH_IOMMU_INTEL,) \
+	$(VBOX_AUDIO_DEFS) \
+	$(VMM_COMMON_DEFS)
+
+#
+# We setup one 'other' target for executing the structure & alignment
+# validation testcases. Perhaps a bit hackish, but extremely useful.
+#
+ifeq ($(KBUILD_TARGET),$(KBUILD_HOST))
+ ifeq ($(filter-out x86.x86 amd64.amd64 x86.amd64, $(KBUILD_TARGET_ARCH).$(KBUILD_HOST_ARCH)),)
+  OTHERS += \
+  	$(VBOX_DEVICES_TEST_OUT_DIR)/tstDeviceStructSize.run
+ endif
+endif
+
+# The normal testing pass.
+TESTING += \
+	$(VBOX_DEVICES_TEST_OUT_DIR)/tstDeviceStructSize.run
+
+ifdef VBOX_WITH_RAW_MODE
+ #
+ # The testcase generator.
+ #
+ PROGRAMS += tstDeviceStructSizeRC
+ tstDeviceStructSizeRC_TEMPLATE  = VBoxRcExe
+ tstDeviceStructSizeRC_DEFS      = $(VBOX_DEVICES_TESTS_FEATURES)
+ tstDeviceStructSizeRC_SOURCES   = tstDeviceStructSizeRC.cpp
+ tstDeviceStructSizeRC_INCS      = \
+ 	$(VBOX_PATH_DEVICES_SRC)/build \
+ 	$(VBOX_PATH_DEVICES_SRC)/Bus \
+ 	$(VBOX_DEVICES_TEST_OUT_DIR) \
+ 	$(VBOX_GRAPHICS_INCS)
+ tstDeviceStructSizeRC_INCS     += $(VBOX_PATH_VMM_DEVICES_SRC)
+endif # VBOX_WITH_RAW_MODE
+
+#
+# The testcase it self.
+#
+PROGRAMS += tstDeviceStructSize
+if "$(KBUILD_TARGET)" != "win" && $(VBOX_GCC_VERSION_CXX) < 40600
+ #
+ # Disable "ISO C++ prohibits anonymous structs [-Werror=pedantic]" caused by Mesa VMSVGA driver headers
+ # For GCC >= 4.6.0 the warning is disabled in DevVGA_SVGA.h
+ #
+ # Template used for gcc older than 4.6.  (Strips away compiler options.)
+ #
+ TEMPLATE_tstDeviceStructSizeOldGCC         := tstDeviceStructSizeOldGCC
+ TEMPLATE_tstDeviceStructSizeOldGCC_EXTENDS := VBoxR3AutoTest
+ TEMPLATE_tstDeviceStructSizeOldGCC_CXXFLAGS = $(filter-out -pedantic,$(TEMPLATE_$(TEMPLATE_tstDeviceStructSizeOldGCC_EXTENDS)_CXXFLAGS))
+
+ tstDeviceStructSize_TEMPLATE = tstDeviceStructSizeOldGCC
+else
+ tstDeviceStructSize_TEMPLATE = VBoxR3AutoTest
+endif
+tstDeviceStructSize_DEFS     = $(VBOX_DEVICES_TESTS_FEATURES)
+tstDeviceStructSize_INCS     = \
+	$(VBOX_PATH_DEVICES_SRC)/build \
+	$(VBOX_PATH_DEVICES_SRC)/Bus \
+	$(VBOX_DEVICES_TEST_OUT_DIR) \
+	$(VBOX_GRAPHICS_INCS) \
+	$(VBOX_PATH_VMSVGA_DEVICE_INC)
+tstDeviceStructSize_SOURCES  = tstDeviceStructSize.cpp
+tstDeviceStructSize_CLEAN    = \
+	$(VBOX_DEVICES_TEST_OUT_DIR)/tstDeviceStructSizeRC.h \
+	$(VBOX_DEVICES_TEST_OUT_DIR)/tstDeviceStructSize.run
+ifdef VBOX_WITH_RAW_MODE
+ tstDeviceStructSize.cpp_DEPS = $(VBOX_DEVICES_TEST_OUT_DIR)/tstDeviceStructSizeRC.h
+endif
+tstDeviceStructSize_INCS      += $(VBOX_PATH_VMM_DEVICES_SRC)
+
+#
+# Run rule for tstDeviceStructSize.
+#
+
+# 1. Dump selected structure in the VMMRC.rc debug info.
+# 2. Generate a testcase from the dump
+## future
+
+ifdef VBOX_WITH_RAW_MODE
+ # 1&2. Manually dump selected structures and members.
+ $(VBOX_DEVICES_TEST_OUT_DIR)/tstDeviceStructSizeRC.h: $$(tstDeviceStructSizeRC_1_STAGE_TARGET) | $$(dir $$@)
+	$(call MSG_GENERATE,,$@)
+	$(QUIET)$(REDIRECT) -wo $@ -- $^
+endif
+
+# 3. run it.
+$(VBOX_DEVICES_TEST_OUT_DIR)/tstDeviceStructSize.run: $$(tstDeviceStructSize_1_STAGE_TARGET) | $$(dir $$@)
+	$(QUIET)$(RM) -f $@
+	$^
+	$(QUIET)$(APPEND) "$@" "done"
+
+# alias for the struct test.
+run-struct-tests: $(VBOX_DEVICES_TEST_OUT_DIR)/tstDeviceStructSize.run
+
+
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/Devices/testcase/tstDevice.cpp b/src/VBox/Devices/testcase/tstDevice.cpp
new file mode 100644
index 00000000..a4d93002
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDevice.cpp
@@ -0,0 +1,1043 @@
+/* $Id: tstDevice.cpp $ */
+/** @file
+ * tstDevice - Test framework for PDM devices/drivers
+ */
+
+/*
+ * Copyright (C) 2017-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
+#include <VBox/types.h>
+#include <VBox/sup.h>
+#include <VBox/version.h>
+#include <iprt/assert.h>
+#include <iprt/ctype.h>
+#include <iprt/getopt.h>
+#include <iprt/initterm.h>
+#include <iprt/ldr.h>
+#include <iprt/log.h>
+#include <iprt/list.h>
+#include <iprt/mem.h>
+#include <iprt/once.h>
+#include <iprt/path.h>
+#include <iprt/string.h>
+#include <iprt/stream.h>
+#include <iprt/trace.h>
+
+#include "tstDeviceInternal.h"
+#include "tstDeviceCfg.h"
+#include "tstDeviceBuiltin.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+
+#define PDM_MAX_DEVICE_INSTANCE_SIZE      _4M
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+
+/**
+ * Testcase plugin descriptor.
+ */
+typedef struct TSTDEVPLUGIN
+{
+    /** Node for the plugin list. */
+    RTLISTNODE                      NdPlugins;
+    /** Copy of the filename. */
+    char                            *pszFilename;
+    /** Loader handle. */
+    RTLDRMOD                        hMod;
+    /** Number of references to this plugin. */
+    volatile uint32_t               cRefs;
+} TSTDEVPLUGIN;
+/** Pointer to a device plugin descriptor. */
+typedef TSTDEVPLUGIN *PTSTDEVPLUGIN;
+/** Pointer to a const plugin descriptor. */
+typedef const TSTDEVPLUGIN *PCTSTDEVPLUGIN;
+
+
+/**
+ * Testcase descriptor.
+ */
+typedef struct TSTDEVTESTCASE
+{
+    /** Node for the list of registered testcases. */
+    RTLISTNODE                      NdTestcases;
+    /** Pointer to the plugin the testcase belongs to. */
+    PCTSTDEVPLUGIN                  pPlugin;
+    /** Pointer to the testcase descriptor. */
+    PCTSTDEVTESTCASEREG             pTestcaseReg;
+} TSTDEVTESTCASE;
+/** Pointer to a testcase descriptor. */
+typedef TSTDEVTESTCASE *PTSTDEVTESTCASE;
+/** Pointer to a constant testcase descriptor. */
+typedef const TSTDEVTESTCASE *PCTSTDEVTESTCASE;
+
+
+/**
+ * PDM R0/RC module trampoline descriptor.
+ */
+#pragma pack(1)
+typedef struct TSTDEVPDMMODTRAMPOLINE
+{
+    /** Jump instruction. */
+    uint8_t                         abJmp[6];
+    /** Address to jump to. */
+    uintptr_t                       AddrTarget;
+    /** Padding to get a 16byte aligned structure. */
+    uint8_t                         abPadding[HC_ARCH_BITS == 64 ? 2 : 5];
+} TSTDEVPDMMODTRAMPOLINE;
+#pragma pack()
+AssertCompileSize(TSTDEVPDMMODTRAMPOLINE, 16);
+/** Pointer to a trampoline descriptor. */
+typedef TSTDEVPDMMODTRAMPOLINE *PTSTDEVPDMMODTRAMPOLINE;
+
+/**
+ * PDM module descriptor.
+ */
+typedef struct TSTDEVPDMMOD
+{
+    /** Node for the module list. */
+    RTLISTNODE                      NdPdmMods;
+    /** Type of module (R3/R0/RC). */
+    TSTDEVPDMMODTYPE                enmType;
+    /** Copy of the filename. */
+    char                            *pszFilename;
+    /** Loader handle. */
+    RTLDRMOD                        hLdrMod;
+    /** Number of references to this plugin. */
+    volatile uint32_t               cRefs;
+    /** R0/RC Module type dependent data. */
+    struct
+    {
+        /** The exectuable image bits. */
+        void                        *pvBits;
+        /** Size of the memory buffer. */
+        size_t                      cbBits;
+        /** Pointer to the executable memory containing the trampoline code. */
+        uint8_t                     *pbTrampoline;
+        /** Number of trampoline entries supported. */
+        uint32_t                    cTrampolinesMax;
+        /** Number of trampoline entries used. */
+        uint32_t                    cTrampolines;
+        /** Pointer to the next unused trampoline entry. */
+        PTSTDEVPDMMODTRAMPOLINE     pTrampolineNext;
+    } R0Rc;
+} TSTDEVPDMMOD;
+/** Pointer to a PDM module descriptor. */
+typedef TSTDEVPDMMOD *PTSTDEVPDMMOD;
+
+
+/**
+ * Internal callback structure pointer.
+ * The main purpose is to define the extra data we associate
+ * with PDMDEVREGCB so we can find the plugin the device is associated with etc.
+ */
+typedef struct TSTDEVPDMDEVREGCBINT
+{
+    /** The callback structure. */
+    PDMDEVREGCB       Core;
+    /** A bit of padding. */
+    uint32_t          u32[4];
+    /** Pointer to plugin. */
+    PTSTDEVPDMMOD     pMod;
+} TSTDEVPDMDEVREGCBINT;
+/** Pointer to a PDMDEVREGCBINT structure. */
+typedef TSTDEVPDMDEVREGCBINT *PTSTDEVPDMDEVREGCBINT;
+/** Pointer to a const PDMDEVREGCBINT structure. */
+typedef const TSTDEVPDMDEVREGCBINT *PCTSTDEVPDMDEVREGCBINT;
+
+
+typedef struct TSTDEVPDMR0IMPORTS
+{
+    /** The symbol name. */
+    const char                      *pszSymbol;
+    /** The pointer. */
+    PFNRT                           pfn;
+} TSTDEVPDMR0IMPORTS;
+typedef const TSTDEVPDMR0IMPORTS *PCTSTDEVPDMR0IMPORTS;
+
+typedef DECLCALLBACKTYPE(int, FNR0MODULEINIT,(void *hMod));
+typedef FNR0MODULEINIT *PFNR0MODULEINIT;
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** List of registered testcase plugins. */
+RTLISTANCHOR g_LstPlugins;
+/** List of registered testcases. */
+RTLISTANCHOR g_LstTestcases;
+/** List of registered PDM modules. */
+RTLISTANCHOR g_LstPdmMods;
+/** List of registered PDM R0 modules. */
+RTLISTANCHOR g_LstPdmR0Mods;
+/** List of registered PDM devices. */
+RTLISTANCHOR g_LstPdmDevs;
+
+static int tstDevPdmR0RegisterModule(void *hMod, PPDMDEVMODREGR0 pModReg);
+
+/**
+ * PDM R0 imports we implement.
+ */
+static const TSTDEVPDMR0IMPORTS g_aPdmR0Imports[] =
+{
+    {"SUPR0TracerFireProbe",           (PFNRT)NULL},
+    {"SUPSemEventSignal",              (PFNRT)NULL},
+    {"PDMR0DeviceRegisterModule",      (PFNRT)tstDevPdmR0RegisterModule},
+    {"PDMR0DeviceDeregisterModule",    (PFNRT)NULL},
+    {"PGMShwMakePageWritable",         (PFNRT)NULL},
+    {"IntNetR0IfSend",                 (PFNRT)/*IntNetR0IfSend*/NULL},
+    {"IntNetR0IfSetPromiscuousMode",   (PFNRT)/*IntNetR0IfSetPromiscuousMode*/NULL},
+    {"RTAssertMsg1Weak",               (PFNRT)RTAssertMsg1Weak},
+    {"RTAssertMsg2Weak",               (PFNRT)RTAssertMsg2Weak},
+    {"RTAssertShouldPanic",            (PFNRT)RTAssertShouldPanic},
+    {"RTLogDefaultInstanceEx",         (PFNRT)RTLogDefaultInstanceEx},
+    {"RTLogLoggerEx",                  (PFNRT)RTLogLoggerEx},
+    {"RTLogRelGetDefaultInstanceEx",   (PFNRT)RTLogRelGetDefaultInstanceEx},
+    {"RTOnceSlow",                     (PFNRT)RTOnceSlow},
+    {"RTR0AssertPanicSystem",          (PFNRT)0x10101010},
+    {"RTThreadSleep",                  (PFNRT)RTThreadSleep},
+    {"RTTimeMilliTS",                  (PFNRT)RTTimeMilliTS},
+    {"RTTimeNanoTS",                   (PFNRT)RTTimeNanoTS},
+    {"RTTraceBufAddMsgF",              (PFNRT)RTTraceBufAddMsgF},
+    {"RTMemAllocZTag",                 (PFNRT)RTMemAllocZTag},
+    {"RTMemFree",                      (PFNRT)RTMemFree},
+    {"RTStrPrintf",                    (PFNRT)RTStrPrintf},
+    {"nocrt_memcmp",                   (PFNRT)memcmp},
+    {"nocrt_memcpy",                   (PFNRT)memcpy},
+    {"nocrt_memmove",                  (PFNRT)memmove},
+    {"nocrt_memset",                   (PFNRT)memset},
+    {"nocrt_strlen",                   (PFNRT)strlen},
+};
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+
+#if 0
+/**
+ * Parses the options given to the testcase.
+ *
+ * @returns Process status code.
+ * @param   cArgs       Number of arguments given.
+ * @param   paszArgs    Pointer to the argument vector.
+ */
+static RTEXITCODE tstDevParseOptions(int cArgs, char *paszArgs[])
+{
+    static RTGETOPTDEF const s_aOptions[] =
+    {
+    };
+
+
+    int ch;
+    RTGETOPTUNION Value;
+    RTGETOPTSTATE GetState;
+    RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0 /* fFlags */);
+    while ((ch = RTGetOpt(&GetState, &Value)))
+    {
+        switch (ch)
+        {
+            default:
+                return RTGetOptPrintError(ch, &Value);
+        }
+    }
+}
+#endif
+
+
+/**
+ * Checks whether the given testcase name is already existing.
+ *
+ * @returns Pointer to existing testcase, NULL if not found.
+ * @param   pszFilename    The filename to check.
+ */
+static PCTSTDEVTESTCASE tstDevTestcaseFind(const char *pszName)
+{
+    PCTSTDEVTESTCASE pIt;
+    RTListForEach(&g_LstTestcases, pIt, TSTDEVTESTCASE, NdTestcases)
+    {
+        if (!RTStrCmp(pIt->pTestcaseReg->szName, pszName))
+            return pIt;
+    }
+
+    return NULL;
+}
+
+
+/**
+ * @interface_method_impl{TSTDEVPLUGINREGISTER,pfnRegisterTestcase}
+ */
+static DECLCALLBACK(int) tstDevRegisterTestcase(void *pvUser, PCTSTDEVTESTCASEREG pTestcaseReg)
+{
+    int rc = VINF_SUCCESS;
+    PTSTDEVPLUGIN pPlugin = (PTSTDEVPLUGIN)pvUser;
+
+    /* Try to find a testcase with the name first. */
+    if (!tstDevTestcaseFind(pTestcaseReg->szName))
+    {
+        PTSTDEVTESTCASE pTestcase = (PTSTDEVTESTCASE)RTMemAllocZ(sizeof(TSTDEVPLUGIN));
+        if (RT_LIKELY(pTestcase))
+        {
+            pTestcase->pPlugin = pPlugin;
+            if (pPlugin)
+                pPlugin->cRefs++;
+            pTestcase->pTestcaseReg = pTestcaseReg;
+            RTListAppend(&g_LstTestcases, &pTestcase->NdTestcases);
+            return VINF_SUCCESS;
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+    else
+        rc = VERR_ALREADY_EXISTS;
+
+    return rc;
+}
+
+
+/**
+ * Checks whether the given plugin filename was already loaded.
+ *
+ * @returns Pointer to already loaded plugin, NULL if not found.
+ * @param   pszFilename    The filename to check.
+ */
+static PCTSTDEVPLUGIN tstDevPluginFind(const char *pszFilename)
+{
+    PCTSTDEVPLUGIN pIt;
+    RTListForEach(&g_LstPlugins, pIt, TSTDEVPLUGIN, NdPlugins)
+    {
+        if (!RTStrCmp(pIt->pszFilename, pszFilename))
+            return pIt;
+    }
+
+    return NULL;
+}
+
+
+/**
+ * Tries to loads the given plugin.
+ *
+ * @returns VBox status code.
+ * @param   pszFilename    The filename to load.
+ */
+static int tstDevLoadPlugin(const char *pszFilename)
+{
+    int rc = VINF_SUCCESS;
+
+    /* Check whether the plugin is loaded first. */
+    if (!tstDevPluginFind(pszFilename))
+    {
+        PTSTDEVPLUGIN pPlugin = (PTSTDEVPLUGIN)RTMemAllocZ(sizeof(TSTDEVPLUGIN));
+        if (RT_LIKELY(pPlugin))
+        {
+            pPlugin->pszFilename = RTStrDup(pszFilename);
+            pPlugin->cRefs       = 1;
+            rc = RTLdrLoad(pszFilename, &pPlugin->hMod);
+            if (RT_SUCCESS(rc))
+            {
+                TSTDEVPLUGINREGISTER TestcaseRegister;
+                PFNTSTDEVPLUGINLOAD pfnPluginLoad = NULL;
+
+                TestcaseRegister.pfnRegisterTestcase = tstDevRegisterTestcase;
+
+                rc = RTLdrGetSymbol(pPlugin->hMod, TSTDEV_PLUGIN_LOAD_NAME, (void**)&pfnPluginLoad);
+                if (RT_FAILURE(rc) || !pfnPluginLoad)
+                {
+                    LogFunc(("error resolving the entry point %s in plugin %s, rc=%Rrc, pfnPluginLoad=%#p\n",
+                             TSTDEV_PLUGIN_LOAD_NAME, pszFilename, rc, pfnPluginLoad));
+                    if (RT_SUCCESS(rc))
+                        rc = VERR_SYMBOL_NOT_FOUND;
+                }
+
+                if (RT_SUCCESS(rc))
+                {
+                    /* Get the function table. */
+                    rc = pfnPluginLoad(pPlugin, &TestcaseRegister);
+                }
+                else
+                    LogFunc(("ignored plugin '%s': rc=%Rrc\n", pszFilename, rc));
+
+                /* Create a plugin entry on success. */
+                if (RT_SUCCESS(rc))
+                {
+                    RTListAppend(&g_LstPlugins, &pPlugin->NdPlugins);
+                    return VINF_SUCCESS;
+                }
+                else
+                    RTLdrClose(pPlugin->hMod);
+            }
+
+            RTMemFree(pPlugin);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Checks whether the given testcase name is already existing.
+ *
+ * @returns Pointer to already loaded plugin, NULL if not found.
+ * @param   pszFilename     The filename to check.
+ * @param   ppR0Reg         Where to store the pointer to the R0 registration record
+ *                          if existing, optional.
+ */
+DECLHIDDEN(PCTSTDEVPDMDEV) tstDevPdmDeviceFind(const char *pszName, PCPDMDEVREGR0 *ppR0Reg)
+{
+    PCTSTDEVPDMDEV pIt;
+    RTListForEach(&g_LstPdmDevs, pIt, TSTDEVPDMDEV, NdPdmDevs)
+    {
+        if (!RTStrCmp(pIt->pReg->szName, pszName))
+        {
+            if (ppR0Reg)
+            {
+                *ppR0Reg = NULL;
+
+                PPDMDEVMODREGR0 pItR0;
+                RTListForEach(&g_LstPdmR0Mods, pItR0, PDMDEVMODREGR0, ListEntry)
+                {
+                    for (uint32_t i = 0; i < pItR0->cDevRegs; i++)
+                    {
+                        PCPDMDEVREGR0 pReg = pItR0->papDevRegs[i];
+                        if (!RTStrCmp(pReg->szName, pszName))
+                        {
+                            *ppR0Reg = pReg;
+                            return pIt;
+                        }
+                    }
+                }
+            }
+
+            return pIt;
+        }
+    }
+
+    return NULL;
+}
+
+
+/**
+ * Checks that a PDMDRVREG::szName, PDMDEVREG::szName or PDMUSBREG::szName
+ * field contains only a limited set of ASCII characters.
+ *
+ * @returns true / false.
+ * @param   pszName             The name to validate.
+ */
+bool tstDevPdmR3IsValidName(const char *pszName)
+{
+    char ch;
+    while (   (ch = *pszName) != '\0'
+           && (   RT_C_IS_ALNUM(ch)
+               || ch == '-'
+               || ch == ' ' /** @todo disallow this! */
+               || ch == '_') )
+        pszName++;
+    return ch == '\0';
+}
+
+
+/**
+ * @interface_method_impl{PDMDEVREGCB,pfnRegister}
+ */
+static DECLCALLBACK(int) tstDevPdmR3DevReg_Register(PPDMDEVREGCB pCallbacks, PCPDMDEVREG pReg)
+{
+    /*
+     * Validate the registration structure (mostly copy and paste from PDMDevice.cpp).
+     */
+    Assert(pReg);
+    AssertMsgReturn(pReg->u32Version == PDM_DEVREG_VERSION,
+                    ("Unknown struct version %#x!\n", pReg->u32Version),
+                    VERR_PDM_UNKNOWN_DEVREG_VERSION);
+
+    AssertMsgReturn(    pReg->szName[0]
+                    &&  strlen(pReg->szName) < sizeof(pReg->szName)
+                    &&  tstDevPdmR3IsValidName(pReg->szName),
+                    ("Invalid name '%.*s'\n", sizeof(pReg->szName), pReg->szName),
+                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
+    AssertMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_HOST_BITS_MASK) == PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT,
+                    ("Invalid host bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szName),
+                    VERR_PDM_INVALID_DEVICE_HOST_BITS);
+    AssertMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK),
+                    ("Invalid guest bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szName),
+                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
+    AssertMsgReturn(pReg->fClass,
+                    ("No class! (Device %s)\n", pReg->szName),
+                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
+    AssertMsgReturn(pReg->cMaxInstances > 0,
+                    ("Max instances %u! (Device %s)\n", pReg->cMaxInstances, pReg->szName),
+                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
+    AssertMsgReturn(pReg->cbInstanceCC <= (uint32_t)(pReg->fFlags & (PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0)  ? 96 * _1K : _1M),
+                    ("Instance size %d bytes! (Device %s)\n", pReg->cbInstanceCC, pReg->szName),
+                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
+    AssertMsgReturn(pReg->pfnConstruct,
+                    ("No constructor! (Device %s)\n", pReg->szName),
+                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
+    AssertLogRelMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK) == PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT,
+                          ("PDM: Rejected device '%s' because it didn't match the guest bits.\n", pReg->szName),
+                          VERR_PDM_INVALID_DEVICE_GUEST_BITS);
+    AssertLogRelMsg(pReg->u32VersionEnd == PDM_DEVREG_VERSION,
+                    ("u32VersionEnd=%#x, expected %#x. (szName=%s)\n",
+                     pReg->u32VersionEnd, PDM_DEVREG_VERSION, pReg->szName));
+
+    /*
+     * Check for duplicates.
+     */
+    int rc = VINF_SUCCESS;
+    PCTSTDEVPDMDEVREGCBINT pRegCB = (PCTSTDEVPDMDEVREGCBINT)pCallbacks;
+    if (!tstDevPdmDeviceFind(pReg->szName, NULL /*ppR0Reg*/))
+    {
+        PTSTDEVPDMDEV pPdmDev = (PTSTDEVPDMDEV)RTMemAllocZ(sizeof(TSTDEVPDMDEV));
+        if (RT_LIKELY(pPdmDev))
+        {
+            pPdmDev->pPdmMod = pRegCB->pMod;
+            pRegCB->pMod->cRefs++;
+            pPdmDev->pReg = pReg;
+            RTListAppend(&g_LstPdmDevs, &pPdmDev->NdPdmDevs);
+            return VINF_SUCCESS;
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+    else
+        rc = VERR_PDM_DEVICE_NAME_CLASH;
+
+    return rc;
+}
+
+
+/**
+ * Checks whether the given PDM module filename was already loaded.
+ *
+ * @returns Pointer to already loaded plugin, NULL if not found.
+ * @param   pszFilename    The filename to check.
+ */
+static PCTSTDEVPDMMOD tstDevPdmModFind(const char *pszFilename)
+{
+    PCTSTDEVPDMMOD pIt;
+    RTListForEach(&g_LstPdmMods, pIt, TSTDEVPDMMOD, NdPdmMods)
+    {
+        if (!RTStrCmp(pIt->pszFilename, pszFilename))
+            return pIt;
+    }
+
+    return NULL;
+}
+
+
+/**
+ * Resolve an external symbol during RTLdrGetBits().
+ *
+ * @returns iprt status code.
+ * @param   hLdrMod         The loader module handle.
+ * @param   pszModule       Module name.
+ * @param   pszSymbol       Symbol name, NULL if uSymbol should be used.
+ * @param   uSymbol         Symbol ordinal, ~0 if pszSymbol should be used.
+ * @param   pValue          Where to store the symbol value (address).
+ * @param   pvUser          User argument.
+ */
+static DECLCALLBACK(int) tstDevPdmLoadR0RcModGetImport(RTLDRMOD hLdrMod, const char *pszModule, const char *pszSymbol,
+                                                       unsigned uSymbol, RTUINTPTR *pValue, void *pvUser)
+{
+    RT_NOREF(hLdrMod, uSymbol, pszModule);
+    PTSTDEVPDMMOD pMod = (PTSTDEVPDMMOD)pvUser;
+
+    RTPrintf("Looking for %s\n", pszSymbol);
+
+    /* Resolve the import. */
+    PCTSTDEVPDMR0IMPORTS pImpDesc = NULL;
+    bool fFound = false;
+    for (uint32_t i = 0; i < RT_ELEMENTS(g_aPdmR0Imports); i++)
+    {
+        pImpDesc = &g_aPdmR0Imports[i];
+        if (!strcmp(pszSymbol, pImpDesc->pszSymbol))
+        {
+            fFound = true;
+            break;
+        }
+    }
+
+    int rc = VERR_SYMBOL_NOT_FOUND;
+    if (fFound)
+    {
+        /* Check whether the symbol has a trampoline already. */
+        PTSTDEVPDMMODTRAMPOLINE pTrampoline = (PTSTDEVPDMMODTRAMPOLINE)pMod->R0Rc.pbTrampoline;
+        for (uint32_t i = 0; i < pMod->R0Rc.cTrampolines; i++)
+        {
+            if (pTrampoline->AddrTarget == (uintptr_t)pImpDesc->pfn)
+                break;
+            pTrampoline++;
+        }
+
+        /* Create new trampoline if not found. */
+        if (pTrampoline->AddrTarget != (uintptr_t)pImpDesc->pfn)
+        {
+            if (pMod->R0Rc.cTrampolines < pMod->R0Rc.cTrampolinesMax)
+            {
+                pTrampoline = pMod->R0Rc.pTrampolineNext;
+                pMod->R0Rc.pTrampolineNext++;
+                pMod->R0Rc.cTrampolines++;
+                pTrampoline->abJmp[0]   = 0xff; /* jmp */
+                pTrampoline->abJmp[1]   = 0x25; /* rip */
+                pTrampoline->abJmp[2]   = 0x00; /* offset */
+                pTrampoline->abJmp[3]   = 0x00;
+                pTrampoline->abJmp[4]   = 0x00;
+                pTrampoline->abJmp[5]   = 0x00;
+                pTrampoline->AddrTarget = (uintptr_t)pImpDesc->pfn;
+                rc = VINF_SUCCESS;
+            }
+            else
+            {
+                rc = VERR_SYMBOL_NOT_FOUND;
+                AssertFailed();
+            }
+        }
+        else
+            rc = VINF_SUCCESS;
+
+        if (RT_SUCCESS(rc))
+            *pValue = (RTUINTPTR)pTrampoline;
+    }
+    else
+        AssertFailed();
+
+    return rc;
+}
+
+
+/**
+ * The PDMR0RegisterModule() export called by loaded R0 modules.
+ *
+ * @returns VBox status code.
+ * @param   hMod                    The module handle.
+ * @param   pModReg                 The module registration structure.
+ */
+static int tstDevPdmR0RegisterModule(void *hMod, PPDMDEVMODREGR0 pModReg)
+{
+    RT_NOREF(hMod);
+    RTListAppend(&g_LstPdmR0Mods, &pModReg->ListEntry);
+    return VINF_SUCCESS;
+}
+
+
+
+/**
+ * Loads a new R0 modules given by the filename.
+ *
+ * @returns VBox status code.
+ * @param   pMod                    Pointer to module structure.
+ */
+static int tstDevPdmLoadR0RcMod(PTSTDEVPDMMOD pMod)
+{
+    int rc = VINF_SUCCESS;
+    const char *pszFile = RTPathFilename(pMod->pszFilename);
+
+    /* Check whether the plugin is loaded first. */
+    if (!tstDevPdmModFind(pszFile))
+    {
+        /*
+         * R0 modules need special treatment as these are relocatable images
+         * which are supposed to run in ring 0.
+         */
+        rc = RTLdrOpen(pMod->pszFilename, 0, RTLDRARCH_HOST, &pMod->hLdrMod);
+        if (RT_SUCCESS(rc))
+        {
+            size_t cb = RTLdrSize(pMod->hLdrMod) + 1024 * sizeof(TSTDEVPDMMODTRAMPOLINE);
+
+            /* Allocate bits. */
+            uint32_t fFlags = RTMEMALLOCEX_FLAGS_EXEC;
+#ifdef RT_OS_LINUX
+            /*
+             * amd64 ELF binaries support only a 2GB code segment everything must be in
+             * (X86_64_PC32 relocation) so we have to use a trampoline to the final destination
+             * which is kept close to the imported module.
+             */
+            fFlags |= RTMEMALLOCEX_FLAGS_32BIT_REACH;
+#endif
+            rc = RTMemAllocEx(cb, 0, fFlags, (void **)&pMod->R0Rc.pbTrampoline);
+            pMod->R0Rc.cbBits = cb;
+            if (RT_SUCCESS(rc))
+            {
+                pMod->R0Rc.pvBits          = pMod->R0Rc.pbTrampoline + 1024 * sizeof(TSTDEVPDMMODTRAMPOLINE);
+                pMod->R0Rc.cTrampolinesMax = 1024;
+                pMod->R0Rc.cTrampolines    = 0;
+                pMod->R0Rc.pTrampolineNext = (PTSTDEVPDMMODTRAMPOLINE)pMod->R0Rc.pbTrampoline;
+                /* Get the bits. */
+                rc = RTLdrGetBits(pMod->hLdrMod, pMod->R0Rc.pvBits, (uintptr_t)pMod->R0Rc.pvBits,
+                                  tstDevPdmLoadR0RcModGetImport, pMod);
+                if (RT_SUCCESS(rc))
+                {
+                    /* Resolve module init entry and call it. */
+                    PFNR0MODULEINIT pfnR0ModuleInit;
+                    rc = RTLdrGetSymbolEx(pMod->hLdrMod, pMod->R0Rc.pvBits, (uintptr_t)pMod->R0Rc.pvBits,
+                                          UINT32_MAX, "ModuleInit", (PRTLDRADDR)&pfnR0ModuleInit);
+                    if (RT_SUCCESS(rc))
+                        rc = pfnR0ModuleInit(pMod);
+                }
+                else
+                    RTMemFreeEx(pMod->R0Rc.pbTrampoline, pMod->R0Rc.cbBits);
+            }
+
+            if (RT_FAILURE(rc))
+                RTLdrClose(pMod->hLdrMod);
+        }
+    }
+
+    return rc;
+}
+
+
+/**
+ * Loads the given
+ */
+static int tstDevPdmLoadR3Mod(PTSTDEVPDMMOD pMod)
+{
+    int rc = RTLdrLoad(pMod->pszFilename, &pMod->hLdrMod);
+    if (RT_SUCCESS(rc))
+    {
+        FNPDMVBOXDEVICESREGISTER *pfnVBoxDevicesRegister;
+        rc = RTLdrGetSymbol(pMod->hLdrMod, "VBoxDevicesRegister", (void**)&pfnVBoxDevicesRegister);
+        if (RT_FAILURE(rc) || !pfnVBoxDevicesRegister)
+        {
+            LogFunc(("error resolving the entry point %s in plugin %s, rc=%Rrc, pfnPluginLoad=%#p\n",
+                     "VBoxDevicesRegister", pMod->pszFilename, rc, pfnVBoxDevicesRegister));
+            if (RT_SUCCESS(rc))
+                rc = VERR_SYMBOL_NOT_FOUND;
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            TSTDEVPDMDEVREGCBINT RegCB;
+            RegCB.Core.u32Version  = PDM_DEVREG_CB_VERSION;
+            RegCB.Core.pfnRegister = tstDevPdmR3DevReg_Register;
+            RegCB.pMod             = pMod;
+            rc = pfnVBoxDevicesRegister(&RegCB.Core, VBOX_VERSION);
+        }
+        else
+            LogFunc(("ignored plugin '%s': rc=%Rrc\n", pMod->pszFilename, rc));
+
+        if (RT_FAILURE(rc))
+            RTLdrClose(pMod->hLdrMod);
+    }
+
+    return rc;
+}
+
+
+/**
+ * Tries to loads the given PDM module.
+ *
+ * @returns VBox status code.
+ * @param   pszFilename    The filename to load.
+ * @param   enmModType     The module type.
+ */
+static int tstDevPdmLoadMod(const char *pszFilename, TSTDEVPDMMODTYPE enmModType)
+{
+    int rc = VINF_SUCCESS;
+
+    /* Check whether the plugin is loaded first. */
+    if (!tstDevPdmModFind(pszFilename))
+    {
+        PTSTDEVPDMMOD pMod = (PTSTDEVPDMMOD)RTMemAllocZ(sizeof(TSTDEVPDMMOD));
+        if (RT_LIKELY(pMod))
+        {
+            pMod->pszFilename = RTStrDup(pszFilename);
+            pMod->cRefs       = 1;
+            pMod->enmType     = enmModType;
+
+            if (enmModType == TSTDEVPDMMODTYPE_R3)
+                rc = tstDevPdmLoadR3Mod(pMod);
+            else if (enmModType == TSTDEVPDMMODTYPE_RC || enmModType == TSTDEVPDMMODTYPE_R0)
+                rc = tstDevPdmLoadR0RcMod(pMod);
+
+            if (RT_SUCCESS(rc))
+                RTListAppend(&g_LstPdmMods, &pMod->NdPdmMods);
+            else
+                RTMemFree(pMod);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Tries to resolve the given symbol from the module given.
+ *
+ * @returns VBox status code.
+ * @param   pThis                   The device under test instance.
+ * @param   pszMod                  The module name.
+ * @param   enmModType              The module type if the module needs to be loaded.
+ * @param   pszSymbol               The symbol to resolve.
+ * @param   ppfn                    Where to store the value on success.
+ */
+DECLHIDDEN(int) tstDevPdmLdrGetSymbol(PTSTDEVDUTINT pThis, const char *pszMod, TSTDEVPDMMODTYPE enmModType,
+                                      const char *pszSymbol, PFNRT *ppfn)
+{
+    RT_NOREF(pThis);
+
+    int rc = VINF_SUCCESS;
+    PCTSTDEVPDMMOD pMod = tstDevPdmModFind(pszMod);
+    if (!pMod)
+    {
+        /* Try to load the module. */
+        rc = tstDevPdmLoadMod(pszMod, enmModType);
+        if (RT_SUCCESS(rc))
+        {
+            pMod = tstDevPdmModFind(pszMod);
+            AssertPtr(pMod);
+        }
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        if (pMod->enmType == TSTDEVPDMMODTYPE_R0 || pMod->enmType == TSTDEVPDMMODTYPE_RC)
+            rc = RTLdrGetSymbolEx(pMod->hLdrMod, pMod->R0Rc.pvBits, (uintptr_t)pMod->R0Rc.pvBits,
+                                  UINT32_MAX, pszSymbol, (PRTLDRADDR)ppfn);
+        else
+            rc = RTLdrGetSymbol(pMod->hLdrMod, pszSymbol, (void **)ppfn);
+    }
+
+    return rc;
+}
+
+
+/**
+ * Create a new PDM device with default config.
+ *
+ * @returns VBox status code.
+ * @param   pszName                 Name of the device to create.
+ * @param   pDut                    The device under test structure the created PDM device instance is exercised under.
+ */
+static int tstDevPdmDevR3Create(const char *pszName, PTSTDEVDUTINT pDut)
+{
+    int rc = VINF_SUCCESS;
+    PCTSTDEVPDMDEV pPdmDev = tstDevPdmDeviceFind(pszName, NULL);
+    if (RT_LIKELY(pPdmDev))
+    {
+        PPDMCRITSECT pCritSect;
+        /* Figure out how much we need. */
+        uint32_t cb = RT_UOFFSETOF_DYN(PDMDEVINS, achInstanceData[pPdmDev->pReg->cbInstanceCC]);
+        cb  = RT_ALIGN_32(cb, 64);
+        uint32_t const offShared   = cb;
+        cb += RT_ALIGN_32(pPdmDev->pReg->cbInstanceShared, 64);
+        uint32_t const cbCritSect  = RT_ALIGN_32(sizeof(*pCritSect), 64);
+        cb += cbCritSect;
+        uint32_t const cbMsixState = RT_ALIGN_32(pPdmDev->pReg->cMaxMsixVectors * 16 + (pPdmDev->pReg->cMaxMsixVectors + 7) / 8, _4K);
+        uint32_t const cbPciDev    = RT_ALIGN_32(RT_UOFFSETOF_DYN(PDMPCIDEV, abMsixState[cbMsixState]), 64);
+        uint32_t const cPciDevs    = RT_MIN(pPdmDev->pReg->cMaxPciDevices, 1024);
+        uint32_t const cbPciDevs   = cbPciDev * cPciDevs;
+        cb += cbPciDevs;
+
+        PPDMDEVINS pDevIns = (PPDMDEVINS)RTMemAllocZ(cb);
+        pDevIns->u32Version               = PDM_DEVINS_VERSION;
+        pDevIns->iInstance                = 0;
+        pDevIns->pReg                     = pPdmDev->pReg;
+        pDevIns->pvInstanceDataR3         = &pDevIns->achInstanceData[0];
+        pDevIns->pHlpR3                   = &g_tstDevPdmDevHlpR3;
+        pDevIns->pCfg                     = &pDut->Cfg;
+        pDevIns->Internal.s.pDut          = pDut;
+        pDevIns->cbRing3                  = cb;
+        pDevIns->fR0Enabled               = false;
+        pDevIns->fRCEnabled               = false;
+        pDevIns->pvInstanceDataR3         = (uint8_t *)pDevIns + offShared;
+        pDevIns->pvInstanceDataForR3      = &pDevIns->achInstanceData[0];
+        pCritSect = (PPDMCRITSECT)((uint8_t *)pDevIns + offShared + RT_ALIGN_32(pPdmDev->pReg->cbInstanceShared, 64));
+        pDevIns->pCritSectRoR3            = pCritSect;
+        pDevIns->cbPciDev                 = cbPciDev;
+        pDevIns->cPciDevs                 = cPciDevs;
+        for (uint32_t iPciDev = 0; iPciDev < cPciDevs; iPciDev++)
+        {
+            PPDMPCIDEV pPciDev = (PPDMPCIDEV)((uint8_t *)pDevIns->pCritSectRoR3 + cbCritSect + cbPciDev * iPciDev);
+            if (iPciDev < RT_ELEMENTS(pDevIns->apPciDevs))
+                pDevIns->apPciDevs[iPciDev] = pPciDev;
+            pPciDev->cbConfig           = _4K;
+            pPciDev->cbMsixState        = cbMsixState;
+            pPciDev->idxSubDev          = (uint16_t)iPciDev;
+            pPciDev->u32Magic           = PDMPCIDEV_MAGIC;
+        }
+
+        RTCritSectInit(&pCritSect->s.CritSect);
+        rc = pPdmDev->pReg->pfnConstruct(pDevIns, 0, pDevIns->pCfg);
+        if (RT_SUCCESS(rc))
+            pDut->pDevIns = pDevIns;
+        else
+        {
+            rc = pPdmDev->pReg->pfnDestruct(pDevIns);
+            RTMemFree(pDevIns);
+        }
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    return rc;
+}
+
+
+DECLHIDDEN(int) tstDevPdmDeviceR3Construct(PTSTDEVDUTINT pDut)
+{
+    PPDMDEVINS pDevInsR3 = pDut->pDevIns;
+
+    pDevInsR3->pReg                     = pDut->pPdmDev->pReg;
+    pDevInsR3->pHlpR3                   = &g_tstDevPdmDevHlpR3;
+    pDevInsR3->pCfg                     = &pDut->Cfg;
+    pDevInsR3->Internal.s.pDut          = pDut;
+
+    return pDevInsR3->pReg->pfnConstruct(pDevInsR3, 0, &pDut->Cfg);
+}
+
+
+DECLCALLBACK(void *) tstDevTestsRun_QueryInterface(PPDMIBASE pInterface, const char *pszIID)
+{
+    RT_NOREF(pInterface, pszIID);
+#if 0
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMILEDCONNECTORS, &pThis->ILedConnectors);
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMEDIANOTIFY, &pThis->IMediaNotify);
+#endif
+    return NULL;
+}
+
+/**
+ * Run a given test config.
+ *
+ * @returns VBox status code.
+ * @param   pDevTstCfg          The test config to run.
+ */
+static int tstDevTestsRun(PCTSTDEVCFG pDevTstCfg)
+{
+    int rc = VINF_SUCCESS;
+
+    for (uint32_t i = 0; i < pDevTstCfg->cTests; i++)
+    {
+        PCTSTDEVTEST pTest = &pDevTstCfg->aTests[i];
+
+        TSTDEVDUTINT Dut;
+        Dut.pTest           = pTest;
+        Dut.enmCtx          = TSTDEVDUTCTX_R3;
+        Dut.pVm             = (PVM)0x1000;
+        Dut.SupSession.pDut = &Dut;
+        Dut.Cfg.pDut        = &Dut;
+        Dut.pPdmDev         = tstDevPdmDeviceFind(pDevTstCfg->pszDevName, NULL /*ppPdmDevR0*/);
+
+        Dut.IBaseSts.pfnQueryInterface = tstDevTestsRun_QueryInterface;
+
+        RTListInit(&Dut.LstIoPorts);
+        RTListInit(&Dut.LstMmio);
+        RTListInit(&Dut.LstTimers);
+        RTListInit(&Dut.LstMmHeap);
+        RTListInit(&Dut.LstPdmThreads);
+        RTListInit(&Dut.LstSsmHandlers);
+        RTListInit(&Dut.SupSession.LstSupSem);
+
+        rc = RTCritSectRwInit(&Dut.CritSectLists);
+        AssertRC(rc);
+
+        rc = RTCritSectInitEx(&Dut.CritSectNop.s.CritSect, RTCRITSECT_FLAGS_NOP, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, "DutNop");
+        AssertRC(rc);
+
+        if (!pTest->fR0Enabled)
+            rc = tstDevPdmDevR3Create(pDevTstCfg->pszDevName, &Dut);
+        else
+            rc = tstDevPdmDevR0R3Create(pDevTstCfg->pszDevName, pTest->fRCEnabled, &Dut);
+        if (RT_SUCCESS(rc))
+        {
+            PCTSTDEVTESTCASE pTestcase = tstDevTestcaseFind(pTest->papszTestcaseIds[i]);
+            if (pTestcase)
+                rc = pTestcase->pTestcaseReg->pfnTestEntry(&Dut, pTest->papTestcaseCfg[i], pTest->pacTestcaseCfgItems[i]);
+            else
+                rc = VERR_NOT_FOUND;
+        }
+    }
+
+    return rc;
+}
+
+
+int main(int argc, char *argv[])
+{
+    /*
+     * Init the runtime and parse the arguments.
+     */
+    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
+    int rc = RTR3InitExe(argc, &argv, 0);
+    if (RT_SUCCESS(rc))
+    {
+        RTListInit(&g_LstPlugins);
+        RTListInit(&g_LstTestcases);
+        RTListInit(&g_LstPdmMods);
+        RTListInit(&g_LstPdmR0Mods);
+        RTListInit(&g_LstPdmDevs);
+
+        /* Register builtin tests. */
+        tstDevRegisterTestcase(NULL, &g_TestcaseSsmFuzz);
+        tstDevRegisterTestcase(NULL, &g_TestcaseSsmLoadDbg);
+        tstDevRegisterTestcase(NULL, &g_TestcaseIoFuzz);
+
+        PCTSTDEVCFG pDevTstCfg = NULL;
+        rc = tstDevCfgLoad(argv[1], NULL, &pDevTstCfg);
+        if (RT_SUCCESS(rc))
+        {
+            if (pDevTstCfg->pszTstDevMod)
+                rc = tstDevLoadPlugin(pDevTstCfg->pszTstDevMod);
+            if (RT_SUCCESS(rc))
+            {
+                rc = tstDevPdmLoadMod(pDevTstCfg->pszPdmR3Mod, TSTDEVPDMMODTYPE_R3);
+                if (   RT_SUCCESS(rc)
+                    && pDevTstCfg->pszPdmR0Mod)
+                    rc = tstDevPdmLoadMod(pDevTstCfg->pszPdmR0Mod, TSTDEVPDMMODTYPE_R0);
+                if (   RT_SUCCESS(rc)
+                    && pDevTstCfg->pszPdmRCMod)
+                    rc = tstDevPdmLoadMod(pDevTstCfg->pszPdmRCMod, TSTDEVPDMMODTYPE_RC);
+
+                if (RT_SUCCESS(rc))
+                    rc = tstDevTestsRun(pDevTstCfg);
+                else
+                    rcExit = RTEXITCODE_FAILURE;
+            }
+            else
+                rcExit = RTEXITCODE_FAILURE;
+        }
+
+        tstDevCfgDestroy(pDevTstCfg);
+    }
+    else
+        rcExit = RTEXITCODE_FAILURE;
+
+    return rcExit;
+}
+
diff --git a/src/VBox/Devices/testcase/tstDeviceBuiltin.h b/src/VBox/Devices/testcase/tstDeviceBuiltin.h
new file mode 100644
index 00000000..c6d70d2f
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDeviceBuiltin.h
@@ -0,0 +1,47 @@
+/** @file
+ * tstDevice: Builtin tests.
+ */
+
+/*
+ * Copyright (C) 2020-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef VBOX_INCLUDED_SRC_testcase_tstDeviceBuiltin_h
+#define VBOX_INCLUDED_SRC_testcase_tstDeviceBuiltin_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/param.h>
+#include <VBox/types.h>
+#include <iprt/err.h>
+
+#include "tstDevicePlugin.h"
+
+RT_C_DECLS_BEGIN
+
+extern const TSTDEVTESTCASEREG g_TestcaseSsmFuzz;
+extern const TSTDEVTESTCASEREG g_TestcaseSsmLoadDbg;
+extern const TSTDEVTESTCASEREG g_TestcaseIoFuzz;
+
+RT_C_DECLS_END
+
+#endif /* !VBOX_INCLUDED_SRC_testcase_tstDeviceBuiltin_h */
diff --git a/src/VBox/Devices/testcase/tstDeviceCfg.cpp b/src/VBox/Devices/testcase/tstDeviceCfg.cpp
new file mode 100644
index 00000000..cb741b02
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDeviceCfg.cpp
@@ -0,0 +1,560 @@
+/* $Id: tstDeviceCfg.cpp $ */
+/** @file
+ * tstDevice - Configuration loader.
+ */
+
+/*
+ * Copyright (C) 2020-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
+#include <VBox/types.h>
+#include <iprt/errcore.h>
+#include <iprt/json.h>
+#include <iprt/mem.h>
+#include <iprt/message.h>
+#include <iprt/string.h>
+
+#include "tstDeviceCfg.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+
+/**
+ * Wrapper around RTErrInfoSetV / RTMsgErrorV.
+ *
+ * @returns @a rc
+ * @param   pErrInfo            Extended error info.
+ * @param   rc                  The return code.
+ * @param   pszFormat           The message format.
+ * @param   ...                 The message format arguments.
+ */
+static int tstDevCfgErrorRc(PRTERRINFO pErrInfo, int rc, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    if (pErrInfo)
+        RTErrInfoSetV(pErrInfo, rc, pszFormat, va);
+    else
+        RTMsgErrorV(pszFormat, va);
+    va_end(va);
+    return rc;
+}
+
+
+/**
+ * Destroys the given configuration item array freeing all allocated resources.
+ *
+ * @param   paCfg               The configuration item array to destroy.
+ * @param   cCfgItems           Number of items in the array.
+ */
+static void tstDevCfgItemsDestroy(PTSTDEVCFGITEM paCfg, uint32_t cCfgItems)
+{
+    RT_NOREF(paCfg, cCfgItems);
+}
+
+
+/**
+ * Loads the given string from the config, creating a duplicate.
+ *
+ * @returns VBox status code.
+ * @param   hJsonTop            The JSON top value handle containing the value to load.
+ * @param   pszValName          The value name.
+ * @param   ppszValCopy         Where to store the pointer to the value on success, must be freed with RTStrFree().
+ * @param   fMissingOk          Flag whether it is considered success if the value does not exist.
+ * @param   pErrInfo            Pointer to the error info to fill on error.
+ */
+static int tstDevCfgLoadString(RTJSONVAL hJsonTop, const char *pszValName, char **ppszValCopy, bool fMissingOk, PRTERRINFO pErrInfo)
+{
+    RTJSONVAL hJsonVal;
+    int rc = RTJsonValueQueryByName(hJsonTop, pszValName, &hJsonVal);
+    if (RT_SUCCESS(rc))
+    {
+        const char *pszVal = RTJsonValueGetString(hJsonVal);
+        if (RT_LIKELY(pszVal))
+        {
+            *ppszValCopy = RTStrDup(pszVal);
+            if (RT_UNLIKELY(!*ppszValCopy))
+                rc = tstDevCfgErrorRc(pErrInfo, VERR_NO_STR_MEMORY, "tstDevCfg/JSON: Out of memory allocating memory for value of \"%s\" ", pszValName);
+        }
+        else
+            rc = tstDevCfgErrorRc(pErrInfo, VERR_JSON_VALUE_INVALID_TYPE, "tstDevCfg/JSON: \"%s\" is not a string", pszValName);
+
+        RTJsonValueRelease(hJsonVal);
+    }
+    else if (   rc == VERR_NOT_FOUND
+             && fMissingOk)
+    {
+        *ppszValCopy = NULL;
+        rc = VINF_SUCCESS;
+    }
+    else
+        rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query \"%s\"", pszValName);
+
+    return rc;
+}
+
+
+/**
+ * Loads a bool value using the given value name from the config.
+ *
+ * @returns VBox status code.
+ * @param   hJsonTop            The JSON top value handle containing the value to load.
+ * @param   pszValName          The value name.
+ * @param   pf                  Where to store the value on success.
+ * @param   pErrInfo            Pointer to the error info to fill on error.
+ */
+static int tstDevCfgLoadBool(RTJSONVAL hJsonTop, const char *pszValName, bool *pf, PRTERRINFO pErrInfo)
+{
+    int rc = RTJsonValueQueryBooleanByName(hJsonTop, pszValName, pf);
+    if (RT_FAILURE(rc))
+        rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query boolean value of \"%s\"", pszValName);
+
+    return rc;
+}
+
+
+/**
+ * Determines the config item type from the given.value.
+ *
+ * @returns VBox status code.
+ * @param   hJsonTop            The JSON top value handle containing the value to load.
+ * @param   pszValName          The value name.
+ * @param   penmCfgItemType     Where to store the determined config item type on success.
+ * @param   pErrInfo            Pointer to the error info to fill on error.
+ */
+static int tstDevCfgLoadCfgItemType(RTJSONVAL hJsonTop, const char *pszValName, PTSTDEVCFGITEMTYPE penmCfgItemType, PRTERRINFO pErrInfo)
+{
+    RTJSONVAL hJsonVal;
+    int rc = RTJsonValueQueryByName(hJsonTop, pszValName, &hJsonVal);
+    if (RT_SUCCESS(rc))
+    {
+        const char *pszVal = RTJsonValueGetString(hJsonVal);
+        if (!RTStrCmp(pszVal, "Integer"))
+            *penmCfgItemType = TSTDEVCFGITEMTYPE_INTEGER;
+        else if (!RTStrCmp(pszVal, "String"))
+            *penmCfgItemType = TSTDEVCFGITEMTYPE_STRING;
+        else
+            rc = tstDevCfgErrorRc(pErrInfo, VERR_JSON_VALUE_INVALID_TYPE, "tstDevCfg/JSON: \"%s\" is not a valid config item type", pszVal);
+
+        RTJsonValueRelease(hJsonVal);
+    }
+    else
+        rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query \"%s\"", pszValName);
+
+    return rc;
+}
+
+
+/**
+ * Loads the config item value from the given config based on the earlier determined type.
+ *
+ * @returns VBox status code.
+ * @param   hJsonTop            The JSON top value handle containing the value to load.
+ * @param   pszValName          The value name.
+ * @param   pCfg                Where to store the retrieved config value.
+ * @param   enmCfgItemType      The earlier determined config item type.
+ * @param   pErrInfo            Pointer to the error info to fill on error.
+ */
+static int tstDevCfgLoadCfgItemValue(RTJSONVAL hJsonTop, const char *pszValName, PTSTDEVCFGITEM pCfg, TSTDEVCFGITEMTYPE enmCfgItemType, PRTERRINFO pErrInfo)
+{
+    RTJSONVAL hJsonVal;
+
+    int rc = RTJsonValueQueryByName(hJsonTop, pszValName, &hJsonVal);
+    if (RT_SUCCESS(rc))
+    {
+        RTJSONVALTYPE enmJsonType = RTJsonValueGetType(hJsonVal);
+
+        if (   (    enmJsonType == RTJSONVALTYPE_INTEGER
+                && enmCfgItemType == TSTDEVCFGITEMTYPE_INTEGER)
+            || (    enmJsonType == RTJSONVALTYPE_STRING
+                && enmCfgItemType == TSTDEVCFGITEMTYPE_STRING))
+        {
+            switch (enmCfgItemType)
+            {
+                case TSTDEVCFGITEMTYPE_INTEGER:
+                {
+                    rc = RTJsonValueQueryInteger(hJsonVal, &pCfg->u.i64);
+                    break;
+                }
+                case TSTDEVCFGITEMTYPE_STRING:
+                {
+                    const char *psz = RTJsonValueGetString(hJsonVal);
+                    AssertPtr(psz);
+
+                    pCfg->u.psz = RTStrDup(psz);
+                    if (RT_UNLIKELY(!pCfg->u.psz))
+                        rc = VERR_NO_STR_MEMORY;
+                    break;
+                }
+                default:
+                    AssertFailed(); /* Should never ever get here. */
+                    rc = tstDevCfgErrorRc(pErrInfo, VERR_INTERNAL_ERROR, "tstDevCfg/JSON: Invalid config item type %u", enmCfgItemType);
+            }
+
+            if (RT_SUCCESS(rc))
+                pCfg->enmType = enmCfgItemType;
+            else
+                rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query config item value");
+        }
+        else
+            rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: JSON value type doesn't match config item type (got %u, expected %u)", enmJsonType, enmCfgItemType);
+
+        RTJsonValueRelease(hJsonVal);
+    }
+    else
+        rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query \"%s\"", pszValName);
+
+    return rc;
+}
+
+
+/**
+ * Loads the test configuration from the given JSON value.
+ *
+ * @returns VBox status code.
+ * @param   paCfg               The configuration array to fill.
+ * @param   cCfgItems           Number of configuration items.
+ * @param   hJsonValCfg         The JSON value to gather the config items from.
+ * @param   pErrInfo            Pointer to error info.
+ */
+static int tstDevCfgLoadTestCfgWorker(PTSTDEVCFGITEM paCfg, uint32_t cCfgItems, RTJSONVAL hJsonValCfg, PRTERRINFO pErrInfo)
+{
+    int rc = VINF_SUCCESS;
+
+    for (uint32_t i = 0; i < cCfgItems && RT_SUCCESS(rc); i++)
+    {
+        PTSTDEVCFGITEM pCfg = &paCfg[i];
+        RTJSONVAL hJsonCfg;
+
+        rc = RTJsonValueQueryByIndex(hJsonValCfg, i, &hJsonCfg);
+        if (RT_SUCCESS(rc))
+        {
+            TSTDEVCFGITEMTYPE enmCfgItemType;
+
+            rc = tstDevCfgLoadString(hJsonCfg, "Key", (char **)&pCfg->pszKey, false /*fMissingOk*/, pErrInfo);
+            if (RT_SUCCESS(rc))
+                rc = tstDevCfgLoadCfgItemType(hJsonCfg, "Type", &enmCfgItemType, pErrInfo);
+            if (RT_SUCCESS(rc))
+                rc = tstDevCfgLoadCfgItemValue(hJsonCfg, "Value", pCfg, enmCfgItemType, pErrInfo);
+        }
+        else
+            rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query config item %u", i);
+    }
+
+    return rc;
+}
+
+
+/**
+ * Loads a single testcase from the given JSON config value.
+ *
+ * @returns VBox status code.
+ * @param   ppszTestcaseId      Where to store the testcase ID on success.
+ * @param   pcTestcaseCfgItems  Where to store the number of testcase config items on success.
+ * @param   ppTestcaseCfg       Where to store the testcase config on success.
+ * @param   pErrInfo            Pointer to error info.
+ */
+static int tstDevCfgLoadTestcase(RTJSONVAL hJsonTestcase, const char **ppszTestcaseId, uint32_t *pcTestcaseCfgItems, PCTSTDEVCFGITEM *ppTestcaseCfg, PRTERRINFO pErrInfo)
+{
+    char *pszTestcaseId = NULL;
+    int rc = tstDevCfgLoadString(hJsonTestcase, "Testcase", &pszTestcaseId, false /*fMissingOk*/, pErrInfo);
+    if (RT_SUCCESS(rc))
+    {
+        RTJSONVAL hJsonValCfg;
+        rc = RTJsonValueQueryByName(hJsonTestcase, "Config", &hJsonValCfg);
+        if (RT_SUCCESS(rc))
+        {
+            unsigned cCfgItems = 0;
+            rc = RTJsonValueQueryArraySize(hJsonValCfg, &cCfgItems);
+            if (RT_SUCCESS(rc))
+            {
+                if (cCfgItems > 0)
+                {
+                    size_t cbCfg = sizeof(TSTDEVCFGITEM) * cCfgItems;
+                    PTSTDEVCFGITEM paCfg = (PTSTDEVCFGITEM)RTMemAllocZ(cbCfg);
+                    if (paCfg)
+                    {
+                        rc = tstDevCfgLoadTestCfgWorker(paCfg, cCfgItems, hJsonValCfg, pErrInfo);
+                        if (RT_SUCCESS(rc))
+                        {
+                            *ppszTestcaseId     = pszTestcaseId;
+                            *pcTestcaseCfgItems = cCfgItems;
+                            *ppTestcaseCfg      = paCfg;
+                        }
+                        else /* Error already set, free test config structure. */
+                            tstDevCfgItemsDestroy(paCfg, cCfgItems);
+                    }
+                    else
+                        rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to allocate %zu bytes for the test config structure", cbCfg);
+                }
+                else
+                {
+                    *ppszTestcaseId     = pszTestcaseId;
+                    *pcTestcaseCfgItems = 0;
+                    *ppTestcaseCfg      = NULL;
+                }
+            }
+            else
+                rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: \"Config\" is not an array");
+
+            RTJsonValueRelease(hJsonValCfg);
+        }
+        else
+            tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query \"Config\" value");
+
+        if (RT_FAILURE(rc))
+            RTStrFree(pszTestcaseId);
+    }
+
+    return rc;
+}
+
+
+/**
+ * Loads the testcase descriptions from the config.
+ *
+ * @returns VBox status code.
+ * @param   pDevTest            Where to store the testcases config on success.
+ * @param   hJsonValTest        Where to load the testcases config from.
+ * @param   pErrInfo            Pointer to error info.
+ */
+static int tstDevCfgLoadTestcases(PTSTDEVTEST pDevTest, RTJSONVAL hJsonValTest, PRTERRINFO pErrInfo)
+{
+    RTJSONVAL hJsonValTestcases;
+    int rc = RTJsonValueQueryByName(hJsonValTest, "Testcases", &hJsonValTestcases);
+    if (RT_SUCCESS(rc))
+    {
+        unsigned cTestcases = 0;
+        rc = RTJsonValueQueryArraySize(hJsonValTestcases, &cTestcases);
+        if (RT_SUCCESS(rc))
+        {
+            pDevTest->cTestcases = cTestcases;
+            if (cTestcases > 0)
+            {
+                size_t cbArray = sizeof(void *) * 2 * cTestcases + cTestcases * sizeof(uint32_t); /* One for the testcase ID and one for the associated configuration. */
+                uint8_t *pbTmp = (uint8_t *)RTMemAllocZ(cbArray);
+                if (pbTmp)
+                {
+                    pDevTest->papszTestcaseIds    = (const char **)pbTmp;
+                    pDevTest->pacTestcaseCfgItems = (uint32_t *)&pDevTest->papszTestcaseIds[cTestcases];
+                    pDevTest->papTestcaseCfg      = (PCTSTDEVCFGITEM *)&pDevTest->pacTestcaseCfgItems[cTestcases];
+
+                    for (uint32_t i = 0; i < cTestcases; i++)
+                    {
+                        RTJSONVAL hJsonTestcase;
+
+                        rc = RTJsonValueQueryByIndex(hJsonValTestcases, i, &hJsonTestcase);
+                        if (RT_SUCCESS(rc))
+                        {
+                            rc = tstDevCfgLoadTestcase(hJsonTestcase, &pDevTest->papszTestcaseIds[i],
+                                                       &pDevTest->pacTestcaseCfgItems[i], &pDevTest->papTestcaseCfg[i], pErrInfo);
+                            RTJsonValueRelease(hJsonTestcase);
+                        }
+                        else
+                            rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query testcase item %u", i);
+                    }
+                }
+                else
+                    rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to allocate %zu bytes for the testcases", cbArray);
+            }
+            else
+                rc = tstDevCfgErrorRc(pErrInfo, VERR_INVALID_PARAMETER, "tstDevCfg/JSON: \"Testcases\" doesn't contain anything");
+        }
+        else
+            rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: \"Testcases\" is not an array");
+
+        RTJsonValueRelease(hJsonValTestcases);
+    }
+    else
+        tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query \"Testcases\" value");
+
+    return rc;
+}
+
+
+/**
+ * Loads a test config from the given JSON object.
+ *
+ * @returns VBox status code.
+ * @param   pDevTest            Where to store the test config on success.
+ * @param   hJsonValTest        Where to load the test config from.
+ * @param   pErrInfo            Pointer to error info.
+ */
+static int tstDevCfgLoadTest(PTSTDEVTEST pDevTest, RTJSONVAL hJsonValTest, PRTERRINFO pErrInfo)
+{
+    int rc = tstDevCfgLoadBool(hJsonValTest, "R0Enabled", &pDevTest->fR0Enabled, pErrInfo);
+    if (RT_SUCCESS(rc))
+        rc = tstDevCfgLoadBool(hJsonValTest, "RCEnabled", &pDevTest->fRCEnabled, pErrInfo);
+
+    if (RT_SUCCESS(rc))
+    {
+        RTJSONVAL hJsonValCfg;
+        rc = RTJsonValueQueryByName(hJsonValTest, "Config", &hJsonValCfg);
+        if (RT_SUCCESS(rc))
+        {
+            unsigned cCfgItems = 0;
+            rc = RTJsonValueQueryArraySize(hJsonValCfg, &cCfgItems);
+            if (RT_SUCCESS(rc))
+            {
+                pDevTest->cCfgItems = cCfgItems;
+                if (cCfgItems > 0)
+                {
+                    size_t cbCfg = sizeof(TSTDEVCFGITEM) * cCfgItems;
+                    PTSTDEVCFGITEM paCfg = (PTSTDEVCFGITEM)RTMemAllocZ(cbCfg);
+                    if (paCfg)
+                    {
+                        rc = tstDevCfgLoadTestCfgWorker(paCfg, cCfgItems, hJsonValCfg, pErrInfo);
+                        if (RT_SUCCESS(rc))
+                            pDevTest->paCfgItems = paCfg;
+                        else /* Error already set, free test config structure. */
+                            tstDevCfgItemsDestroy(paCfg, cCfgItems);
+                    }
+                    else
+                        rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to allocate %zu bytes for the test config structure", cbCfg);
+                }
+            }
+            else
+                rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: \"Config\" is not an array");
+
+            RTJsonValueRelease(hJsonValCfg);
+        }
+        else
+            tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query \"Config\" value");
+    }
+
+    /* Load the test configs. */
+    if (RT_SUCCESS(rc))
+        rc = tstDevCfgLoadTestcases(pDevTest, hJsonValTest, pErrInfo);
+
+    return rc;
+}
+
+
+/**
+ * Configuration loader worker.
+ *
+ * @returns VBox status code.
+ * @param   pDevTstCfg          The test config structure to fill.
+ * @param   hJsonRoot           Handle of the root JSON value.
+ * @param   hJsonValDeviceTests Handle to the test JSON array.
+ * @param   pErrInfo            Pointer to the error info.
+ */
+static int tstDevCfgLoadWorker(PTSTDEVCFG pDevTstCfg, RTJSONVAL hJsonRoot, RTJSONVAL hJsonValDeviceTests, PRTERRINFO pErrInfo)
+{
+    int rc = tstDevCfgLoadString(hJsonRoot, "PdmR3Module", (char **)&pDevTstCfg->pszPdmR3Mod, false /*fMissingOk*/, pErrInfo);
+    if (RT_SUCCESS(rc))
+        rc = tstDevCfgLoadString(hJsonRoot, "PdmR0Module", (char **)&pDevTstCfg->pszPdmR0Mod, true /*fMissingOk*/, pErrInfo);
+    if (RT_SUCCESS(rc))
+        rc = tstDevCfgLoadString(hJsonRoot, "PdmRCModule", (char **)&pDevTstCfg->pszPdmRCMod, true /*fMissingOk*/, pErrInfo);
+    if (RT_SUCCESS(rc))
+        rc = tstDevCfgLoadString(hJsonRoot, "TestcaseModule", (char **)&pDevTstCfg->pszTstDevMod, true /*fMissingOk*/, pErrInfo);
+    if (RT_SUCCESS(rc))
+        rc = tstDevCfgLoadString(hJsonRoot, "Device", (char **)&pDevTstCfg->pszDevName, false /*fMissingOk*/, pErrInfo);
+
+    if (RT_SUCCESS(rc))
+    {
+        /* Load the individual test configs. */
+        for (uint32_t idx = 0; idx < pDevTstCfg->cTests && RT_SUCCESS(rc); idx++)
+        {
+            RTJSONVAL hJsonValTest;
+
+            rc = RTJsonValueQueryByIndex(hJsonValDeviceTests, idx, &hJsonValTest);
+            if (RT_SUCCESS(rc))
+            {
+                rc = tstDevCfgLoadTest(&pDevTstCfg->aTests[idx], hJsonValTest, pErrInfo);
+                RTJsonValueRelease(hJsonValTest);
+            }
+            else
+                rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query test %u from \"DeviceTests\"", idx);
+        }
+    }
+
+    return rc;
+}
+
+
+DECLHIDDEN(int) tstDevCfgLoad(const char *pszCfgFilename, PRTERRINFO pErrInfo, PCTSTDEVCFG *ppDevTstCfg)
+{
+    RTJSONVAL hJsonRoot;
+    int rc = RTJsonParseFromFile(&hJsonRoot, pszCfgFilename, pErrInfo);
+    if (RT_SUCCESS(rc))
+    {
+        RTJSONVAL hJsonValDeviceTests;
+
+        rc = RTJsonValueQueryByName(hJsonRoot, "DeviceTests", &hJsonValDeviceTests);
+        if (RT_SUCCESS(rc))
+        {
+            unsigned cTests = 0;
+            rc = RTJsonValueQueryArraySize(hJsonValDeviceTests, &cTests);
+            if (RT_SUCCESS(rc))
+            {
+                if (cTests > 0)
+                {
+                    size_t cbTestCfg = RT_UOFFSETOF_DYN(TSTDEVCFG, aTests[cTests]);
+                    PTSTDEVCFG pDevTstCfg = (PTSTDEVCFG)RTMemAllocZ(cbTestCfg);
+                    if (pDevTstCfg)
+                    {
+                        pDevTstCfg->cTests = cTests;
+                        rc = tstDevCfgLoadWorker(pDevTstCfg, hJsonRoot, hJsonValDeviceTests, pErrInfo);
+                        if (RT_SUCCESS(rc))
+                            *ppDevTstCfg = pDevTstCfg;
+                        else /* Error already set, free test config structure. */
+                            tstDevCfgDestroy(pDevTstCfg);
+                    }
+                    else
+                        rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to allocate %zu bytes for the test config structure", cbTestCfg);
+                }
+                else
+                    rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: \"DeviceTests\" is empty");
+            }
+            else
+                rc = tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: \"DeviceTests\" is not an array");
+
+            RTJsonValueRelease(hJsonValDeviceTests);
+        }
+        else
+            tstDevCfgErrorRc(pErrInfo, rc, "tstDevCfg/JSON: Failed to query \"DeviceTests\" value");
+
+        RTJsonValueRelease(hJsonRoot);
+    }
+
+    return rc;
+}
+
+
+DECLHIDDEN(void) tstDevCfgDestroy(PCTSTDEVCFG pDevTstCfg)
+{
+    RT_NOREF(pDevTstCfg);
+}
+
diff --git a/src/VBox/Devices/testcase/tstDeviceCfg.h b/src/VBox/Devices/testcase/tstDeviceCfg.h
new file mode 100644
index 00000000..c514f987
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDeviceCfg.h
@@ -0,0 +1,169 @@
+/** @file
+ * tstDevice: Configuration handling.
+ */
+
+/*
+ * Copyright (C) 2020-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef VBOX_INCLUDED_SRC_testcase_tstDeviceCfg_h
+#define VBOX_INCLUDED_SRC_testcase_tstDeviceCfg_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/param.h>
+#include <VBox/types.h>
+#include <iprt/err.h>
+
+RT_C_DECLS_BEGIN
+
+/**
+ * Config item type.
+ */
+typedef enum TSTDEVCFGITEMTYPE
+{
+    /** Invalid type. */
+    TSTDEVCFGITEMTYPE_INVALID = 0,
+    /** String type. */
+    TSTDEVCFGITEMTYPE_STRING,
+    /** Integer value encoded in the string. */
+    TSTDEVCFGITEMTYPE_INTEGER,
+    /** Raw bytes. */
+    TSTDEVCFGITEMTYPE_BYTES,
+    /** 32bit hack. */
+    TSTDEVCFGITEMTYPE_32BIT_HACK = 0x7fffffff
+} TSTDEVCFGITEMTYPE;
+/** Pointer to a config item type. */
+typedef TSTDEVCFGITEMTYPE *PTSTDEVCFGITEMTYPE;
+
+
+/**
+ * Testcase config item.
+ */
+typedef struct TSTDEVCFGITEM
+{
+    /** The key of the item. */
+    const char          *pszKey;
+    /** Type of the config item. */
+    TSTDEVCFGITEMTYPE   enmType;
+    /** Type dependent data. */
+    union
+    {
+        /** String value. */
+        const char      *psz;
+        /** Integer value. */
+        int64_t         i64;
+        /** Raw bytes. */
+        struct
+        {
+            /** Size of the byte buffer. */
+            size_t      cb;
+            /** Pointer to the raw buffer. */
+            const void  *pv;
+        } RawBytes;
+    } u;
+} TSTDEVCFGITEM;
+/** Pointer to a testcase config item. */
+typedef TSTDEVCFGITEM *PTSTDEVCFGITEM;
+/** Pointer to a constant testcase config item. */
+typedef const TSTDEVCFGITEM *PCTSTDEVCFGITEM;
+
+
+/**
+ * A single test.
+ */
+typedef struct TSTDEVTEST
+{
+    /** Flag whether to enable the R0 part for testing. */
+    bool                        fR0Enabled;
+    /** Flag whether to enable the RC part for testing. */
+    bool                        fRCEnabled;
+    /** Number of configuration items for the device. */
+    uint32_t                    cCfgItems;
+    /** Pointer to array of configuration items for the device. */
+    PCTSTDEVCFGITEM             paCfgItems;
+    /** Number of testcases to run with that device instance. */
+    uint32_t                    cTestcases;
+    /** Pointer to the array of testcase IDs. */
+    const char                  **papszTestcaseIds;
+    /** Pointer to the array of testcase configuration item numbers. */
+    uint32_t                    *pacTestcaseCfgItems;
+    /** Pointer to the array of configuration item array pointers for each testcase. */
+    PCTSTDEVCFGITEM             *papTestcaseCfg;
+} TSTDEVTEST;
+/** Pointer to a single test. */
+typedef TSTDEVTEST *PTSTDEVTEST;
+/** Pointer to a const single test. */
+typedef const TSTDEVTEST *PCTSTDEVTEST;
+
+
+/**
+ * A device test configuration.
+ */
+typedef struct TSTDEVCFG
+{
+    /** The identifier of the device to test. */
+    const char                  *pszDevName;
+
+    /** R3 PDM module to load containing the device to test. */
+    const char                  *pszPdmR3Mod;
+    /** R0 PDM module to load containing the device to test. */
+    const char                  *pszPdmR0Mod;
+    /** RC PDM module to load containing the device to test. */
+    const char                  *pszPdmRCMod;
+
+    /** Testcase module to load. */
+    const char                  *pszTstDevMod;
+
+    /** Number of tests configured in the config. */
+    uint32_t                    cTests;
+    /** The array of tests to execute for the given device - variable in size. */
+    TSTDEVTEST                  aTests[1];
+} TSTDEVCFG;
+/** Pointer to a device test configuration. */
+typedef TSTDEVCFG *PTSTDEVCFG;
+/** Pointer to a const device test configuration. */
+typedef const TSTDEVCFG *PCTSTDEVCFG;
+/** Pointer to a device test configuration pointer. */
+typedef TSTDEVCFG *PPTSTDEVCFG;
+
+
+/**
+ * Loads the config from the given file returning the configuration structure on success.
+ *
+ * @returns VBox status code.
+ * @param   pszCfgFilename          The configuration file path to load.
+ * @param   pErrInfo                Where to store additional error information if loading the config fails, optional.
+ * @param   ppDevTstCfg             Where to store the pointer to the created test configuration on success.
+ */
+DECLHIDDEN(int) tstDevCfgLoad(const char *pszCfgFilename, PRTERRINFO pErrInfo, PCTSTDEVCFG *ppDevTstCfg);
+
+/**
+ * Destroys the given test configuration freeing all allocated resources.
+ *
+ * @param   pDevTstCfg              The test configuration to destroy.
+ */
+DECLHIDDEN(void) tstDevCfgDestroy(PCTSTDEVCFG pDevTstCfg);
+
+RT_C_DECLS_END
+
+#endif /* !VBOX_INCLUDED_SRC_testcase_tstDeviceCfg_h */
diff --git a/src/VBox/Devices/testcase/tstDeviceInternal.h b/src/VBox/Devices/testcase/tstDeviceInternal.h
new file mode 100644
index 00000000..477eb533
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDeviceInternal.h
@@ -0,0 +1,578 @@
+/** @file
+ * tstDevice: Shared definitions between the framework and the shim library.
+ */
+
+/*
+ * Copyright (C) 2017-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef VBOX_INCLUDED_SRC_testcase_tstDeviceInternal_h
+#define VBOX_INCLUDED_SRC_testcase_tstDeviceInternal_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/param.h>
+#include <VBox/types.h>
+#include <iprt/assert.h>
+#include <iprt/list.h>
+#include <iprt/semaphore.h>
+#include <iprt/critsect.h>
+
+#include "tstDeviceCfg.h"
+#include "tstDevicePlugin.h"
+
+RT_C_DECLS_BEGIN
+
+#define PDM_MAX_DEVICE_INSTANCE_SIZE      _4M
+
+/** Converts PDM device instance to the device under test structure. */
+#define TSTDEV_PDMDEVINS_2_DUT(a_pDevIns) ((a_pDevIns)->Internal.s.pDut)
+
+/** Forward declaration of internal test device instance data. */
+typedef struct TSTDEVDUTINT *PTSTDEVDUTINT;
+
+
+/** Pointer to a const PDM module descriptor. */
+typedef const struct TSTDEVPDMMOD *PCTSTDEVPDMMOD;
+
+
+/**
+ * PDM device descriptor.
+ */
+typedef struct TSTDEVPDMDEV
+{
+    /** Node for the known device list. */
+    RTLISTNODE                      NdPdmDevs;
+    /** Pointer to the PDM module containing the device. */
+    PCTSTDEVPDMMOD                  pPdmMod;
+    /** Device registration structure. */
+    const struct PDMDEVREGR3        *pReg;
+} TSTDEVPDMDEV;
+/** Pointer to a PDM device descriptor .*/
+typedef TSTDEVPDMDEV *PTSTDEVPDMDEV;
+/** Pointer to a constant PDM device descriptor .*/
+typedef const TSTDEVPDMDEV *PCTSTDEVPDMDEV;
+
+
+/**
+ * CFGM node structure.
+ */
+typedef struct CFGMNODE
+{
+    /** Device under test this CFGM node is for. */
+    PTSTDEVDUTINT        pDut;
+    /** @todo: */
+} CFGMNODE;
+
+
+/**
+ * Private device instance data.
+ */
+typedef struct PDMDEVINSINTR3
+{
+    /** Pointer to the device under test the PDM device instance is for. */
+    PTSTDEVDUTINT                   pDut;
+} PDMDEVINSINTR3;
+AssertCompile(sizeof(PDMDEVINSINTR3) <= (HC_ARCH_BITS == 32 ? 72 : 112 + 0x28));
+
+/**
+ * Private device instance data.
+ */
+typedef struct PDMDEVINSINTR0
+{
+    /** Pointer to the device under test the PDM device instance is for. */
+    PTSTDEVDUTINT                   pDut;
+} PDMDEVINSINTR0;
+AssertCompile(sizeof(PDMDEVINSINTR0) <= (HC_ARCH_BITS == 32 ? 72 : 112 + 0x28));
+
+/**
+ * Private device instance data.
+ */
+typedef struct PDMDEVINSINTRC
+{
+    /** Pointer to the device under test the PDM device instance is for. */
+    PTSTDEVDUTINT                   pDut;
+} PDMDEVINSINTRC;
+AssertCompile(sizeof(PDMDEVINSINTRC) <= (HC_ARCH_BITS == 32 ? 72 : 112 + 0x28));
+
+typedef struct PDMPCIDEVINT
+{
+    bool                            fRegistered;
+} PDMPCIDEVINT;
+
+
+/**
+ * Internal PDM critical section structure.
+ */
+typedef struct PDMCRITSECTINT
+{
+    /** The actual critical section used for emulation. */
+    RTCRITSECT           CritSect;
+} PDMCRITSECTINT;
+AssertCompile(sizeof(PDMCRITSECTINT) <= (HC_ARCH_BITS == 32 ? 0x80 : 0xc0));
+
+
+/**
+ * SSM handle state.
+ */
+typedef struct SSMHANDLE
+{
+    /** Pointer to the device under test the handle is for. */
+    PTSTDEVDUTINT                   pDut;
+    /** The saved state data buffer. */
+    uint8_t                         *pbSavedState;
+    /** Size of the saved state. */
+    size_t                          cbSavedState;
+    /** Current offset into the data buffer. */
+    uint32_t                        offDataBuffer;
+    /** Current unit version. */
+    uint32_t                        uCurUnitVer;
+    /** Status code. */
+    int                             rc;
+} SSMHANDLE;
+
+
+/**
+ * MM Heap allocation.
+ */
+typedef struct TSTDEVMMHEAPALLOC
+{
+    /** Node for the list of allocations. */
+    RTLISTNODE                      NdMmHeap;
+    /** Pointer to the device under test the allocation was made for. */
+    PTSTDEVDUTINT                   pDut;
+    /** Size of the allocation. */
+    size_t                          cbAlloc;
+    /** Start of the real allocation. */
+    RT_FLEXIBLE_ARRAY_EXTENSION
+    uint8_t                         abAlloc[RT_FLEXIBLE_ARRAY];
+} TSTDEVMMHEAPALLOC;
+/** Pointer to a MM Heap allocation. */
+typedef TSTDEVMMHEAPALLOC *PTSTDEVMMHEAPALLOC;
+/** Pointer to a const MM Heap allocation. */
+typedef const TSTDEVMMHEAPALLOC *PCTSTDEVMMHEAPALLOC;
+
+AssertCompileMemberAlignment(TSTDEVMMHEAPALLOC, abAlloc, HC_ARCH_BITS == 64 ? 16 : 8);
+
+
+/**
+ * The usual device/driver/internal/external stuff.
+ */
+typedef enum
+{
+    /** The usual invalid entry. */
+    PDMTHREADTYPE_INVALID = 0,
+    /** Device type. */
+    PDMTHREADTYPE_DEVICE,
+    /** USB Device type. */
+    PDMTHREADTYPE_USB,
+    /** Driver type. */
+    PDMTHREADTYPE_DRIVER,
+    /** Internal type. */
+    PDMTHREADTYPE_INTERNAL,
+    /** External type. */
+    PDMTHREADTYPE_EXTERNAL,
+    /** The usual 32-bit hack. */
+    PDMTHREADTYPE_32BIT_HACK = 0x7fffffff
+} PDMTHREADTYPE;
+
+
+/**
+ * The internal structure for the thread.
+ */
+typedef struct PDMTHREADINT
+{
+    /** Node for the list of threads. */
+    RTLISTNODE                      NdPdmThrds;
+    /** Pointer to the device under test the allocation was made for. */
+    PTSTDEVDUTINT                   pDut;
+    /** The event semaphore the thread blocks on when not running. */
+    RTSEMEVENTMULTI                 BlockEvent;
+    /** The event semaphore the thread sleeps on while running. */
+    RTSEMEVENTMULTI                 SleepEvent;
+    /** The thread type. */
+    PDMTHREADTYPE                   enmType;
+} PDMTHREADINT;
+
+
+#define PDMTHREADINT_DECLARED
+#define PDMCRITSECTINT_DECLARED
+#define PDMDEVINSINT_DECLARED
+#define PDMPCIDEVINT_DECLARED
+#define VMM_INCLUDED_SRC_include_VMInternal_h
+#define VMM_INCLUDED_SRC_include_VMMInternal_h
+RT_C_DECLS_END
+#include <VBox/vmm/pdmcritsect.h>
+#include <VBox/vmm/pdmthread.h>
+#include <VBox/vmm/pdmdev.h>
+#include <VBox/vmm/pdmpci.h>
+#include <VBox/vmm/pdmdrv.h>
+#include <VBox/vmm/tm.h>
+RT_C_DECLS_BEGIN
+
+
+/**
+ * TM timer structure.
+ */
+typedef struct TMTIMER
+{
+    /** List of timers created by the device. */
+    RTLISTNODE           NdDevTimers;
+    /** Clock this timer belongs to. */
+    TMCLOCK              enmClock;
+    /** Callback to call when the timer expires. */
+    PFNTMTIMERDEV        pfnCallbackDev;
+    /** Opaque user data to pass to the callback. */
+    void                 *pvUser;
+    /** Flags. */
+    uint32_t             fFlags;
+    /** Assigned critical section. */
+    PPDMCRITSECT         pCritSect;
+    /** @todo: */
+} TMTIMER;
+
+
+/**
+ * PDM module descriptor type.
+ */
+typedef enum TSTDEVPDMMODTYPE
+{
+    /** Invalid module type. */
+    TSTDEVPDMMODTYPE_INVALID = 0,
+    /** Ring 3 module. */
+    TSTDEVPDMMODTYPE_R3,
+    /** Ring 0 module. */
+    TSTDEVPDMMODTYPE_R0,
+    /** Raw context module. */
+    TSTDEVPDMMODTYPE_RC,
+    /** 32bit hack. */
+    TSTDEVPDMMODTYPE_32BIT_HACK = 0x7fffffff
+} TSTDEVPDMMODTYPE;
+
+/**
+ * Registered I/O port access handler.
+ */
+typedef struct RTDEVDUTIOPORT
+{
+    /** Node for the list of registered handlers. */
+    RTLISTNODE                      NdIoPorts;
+    /** Start I/O port the handler is for. */
+    RTIOPORT                        PortStart;
+    /** Number of ports handled. */
+    RTIOPORT                        cPorts;
+    /** Opaque user data - R3. */
+    void                            *pvUserR3;
+    /** Out handler - R3. */
+    PFNIOMIOPORTNEWOUT              pfnOutR3;
+    /** In handler - R3. */
+    PFNIOMIOPORTNEWIN               pfnInR3;
+    /** Out string handler - R3. */
+    PFNIOMIOPORTNEWOUTSTRING        pfnOutStrR3;
+    /** In string handler - R3. */
+    PFNIOMIOPORTNEWINSTRING         pfnInStrR3;
+
+    /** Opaque user data - R0. */
+    void                            *pvUserR0;
+    /** Out handler - R0. */
+    PFNIOMIOPORTNEWOUT              pfnOutR0;
+    /** In handler - R0. */
+    PFNIOMIOPORTNEWIN               pfnInR0;
+    /** Out string handler - R0. */
+    PFNIOMIOPORTNEWOUTSTRING        pfnOutStrR0;
+    /** In string handler - R0. */
+    PFNIOMIOPORTNEWINSTRING         pfnInStrR0;
+
+#ifdef TSTDEV_SUPPORTS_RC
+    /** Opaque user data - RC. */
+    void                            *pvUserRC;
+    /** Out handler - RC. */
+    PFNIOMIOPORTNEWOUT              pfnOutRC;
+    /** In handler - RC. */
+    PFNIOMIOPORTNEWIN               pfnInRC;
+    /** Out string handler - RC. */
+    PFNIOMIOPORTNEWOUTSTRING        pfnOutStrRC;
+    /** In string handler - RC. */
+    PFNIOMIOPORTNEWINSTRING         pfnInStrRC;
+#endif
+} RTDEVDUTIOPORT;
+/** Pointer to a registered I/O port handler. */
+typedef RTDEVDUTIOPORT *PRTDEVDUTIOPORT;
+/** Pointer to a const I/O port handler. */
+typedef const RTDEVDUTIOPORT *PCRTDEVDUTIOPORT;
+
+
+/**
+ * Registered MMIO port access handler.
+ */
+typedef struct RTDEVDUTMMIO
+{
+    /** Node for the list of registered handlers. */
+    RTLISTNODE                      NdMmio;
+    /** Start address of the MMIO region when mapped. */
+    RTGCPHYS                        GCPhysStart;
+    /** Size of the MMIO region in bytes. */
+    RTGCPHYS                        cbRegion;
+    /** Opaque user data - R3. */
+    void                            *pvUserR3;
+    /** Write handler - R3. */
+    PFNIOMMMIONEWWRITE              pfnWriteR3;
+    /** Read handler - R3. */
+    PFNIOMMMIONEWREAD               pfnReadR3;
+    /** Fill handler - R3. */
+    PFNIOMMMIONEWFILL               pfnFillR3;
+
+    /** Opaque user data - R0. */
+    void                            *pvUserR0;
+    /** Write handler - R0. */
+    PFNIOMMMIONEWWRITE              pfnWriteR0;
+    /** Read handler - R0. */
+    PFNIOMMMIONEWREAD               pfnReadR0;
+    /** Fill handler - R0. */
+    PFNIOMMMIONEWFILL               pfnFillR0;
+
+#ifdef TSTDEV_SUPPORTS_RC
+    /** Opaque user data - RC. */
+    void                            *pvUserRC;
+    /** Write handler - RC. */
+    PFNIOMMMIONEWWRITE              pfnWriteRC;
+    /** Read handler - RC. */
+    PFNIOMMMIONEWREAD               pfnReadRC;
+    /** Fill handler - RC. */
+    PFNIOMMMIONEWFILL               pfnFillRC;
+#endif
+} RTDEVDUTMMIO;
+/** Pointer to a registered MMIO handler. */
+typedef RTDEVDUTMMIO *PRTDEVDUTMMIO;
+/** Pointer to a const MMIO handler. */
+typedef const RTDEVDUTMMIO *PCRTDEVDUTMMIO;
+
+
+#ifdef IN_RING3
+/**
+ * Registered SSM handlers.
+ */
+typedef struct TSTDEVDUTSSM
+{
+    /** Node for the list of registered SSM handlers. */
+    RTLISTNODE                      NdSsm;
+    /** Version */
+    uint32_t                        uVersion;
+    PFNSSMDEVLIVEPREP               pfnLivePrep;
+    PFNSSMDEVLIVEEXEC               pfnLiveExec;
+    PFNSSMDEVLIVEVOTE               pfnLiveVote;
+    PFNSSMDEVSAVEPREP               pfnSavePrep;
+    PFNSSMDEVSAVEEXEC               pfnSaveExec;
+    PFNSSMDEVSAVEDONE               pfnSaveDone;
+    PFNSSMDEVLOADPREP               pfnLoadPrep;
+    PFNSSMDEVLOADEXEC               pfnLoadExec;
+    PFNSSMDEVLOADDONE               pfnLoadDone;
+} TSTDEVDUTSSM;
+/** Pointer to the registered SSM handlers. */
+typedef TSTDEVDUTSSM *PTSTDEVDUTSSM;
+/** Pointer to a const SSM handler. */
+typedef const TSTDEVDUTSSM *PCTSTDEVDUTSSM;
+#endif
+
+
+/**
+ * The Support Driver session state.
+ */
+typedef struct TSTDEVSUPDRVSESSION
+{
+    /** Pointer to the owning device under test instance. */
+    PTSTDEVDUTINT                   pDut;
+    /** List of event semaphores. */
+    RTLISTANCHOR                    LstSupSem;
+} TSTDEVSUPDRVSESSION;
+/** Pointer to the Support Driver session state. */
+typedef TSTDEVSUPDRVSESSION *PTSTDEVSUPDRVSESSION;
+
+/** Converts a Support Driver session handle to the internal state. */
+#define TSTDEV_PSUPDRVSESSION_2_PTSTDEVSUPDRVSESSION(a_pSession) ((PTSTDEVSUPDRVSESSION)(a_pSession))
+/** Converts the internal session state to a Support Driver session handle. */
+#define TSTDEV_PTSTDEVSUPDRVSESSION_2_PSUPDRVSESSION(a_pSession) ((PSUPDRVSESSION)(a_pSession))
+
+/**
+ * Support driver event semaphore.
+ */
+typedef struct TSTDEVSUPSEMEVENT
+{
+    /** Node for the event semaphore list. */
+    RTLISTNODE                      NdSupSem;
+    /** Flag whether this is multi event semaphore. */
+    bool                            fMulti;
+    /** Event smeaphore handles depending on the flag above. */
+    union
+    {
+        RTSEMEVENT                  hSemEvt;
+        RTSEMEVENTMULTI             hSemEvtMulti;
+    } u;
+} TSTDEVSUPSEMEVENT;
+/** Pointer to a support event semaphore state. */
+typedef TSTDEVSUPSEMEVENT *PTSTDEVSUPSEMEVENT;
+
+/** Converts a Support event semaphore handle to the internal state. */
+#define TSTDEV_SUPSEMEVENT_2_PTSTDEVSUPSEMEVENT(a_pSupSemEvt) ((PTSTDEVSUPSEMEVENT)(a_pSupSemEvt))
+/** Converts the internal session state to a Support event semaphore handle. */
+#define TSTDEV_PTSTDEVSUPSEMEVENT_2_SUPSEMEVENT(a_pSupSemEvt) ((SUPSEMEVENT)(a_pSupSemEvt))
+
+/**
+ * The contex the device under test is currently in.
+ */
+typedef enum TSTDEVDUTCTX
+{
+    /** Invalid context. */
+    TSTDEVDUTCTX_INVALID = 0,
+    /** R3 context. */
+    TSTDEVDUTCTX_R3,
+    /** R0 context. */
+    TSTDEVDUTCTX_R0,
+    /** RC context. */
+    TSTDEVDUTCTX_RC,
+    /** 32bit hack. */
+    TSTDEVDUTCTX_32BIT_HACK = 0x7fffffff
+} TSTDEVDUTCTX;
+
+/**
+ * PCI region descriptor.
+ */
+typedef struct TSTDEVDUTPCIREGION
+{
+    /** Size of the region. */
+    RTGCPHYS                        cbRegion;
+    /** Address space type. */
+    PCIADDRESSSPACE                 enmType;
+    /** Region mapping callback. */
+    PFNPCIIOREGIONMAP               pfnRegionMap;
+} TSTDEVDUTPCIREGION;
+/** Pointer to a PCI region descriptor. */
+typedef TSTDEVDUTPCIREGION *PTSTDEVDUTPCIREGION;
+/** Pointer to a const PCI region descriptor. */
+typedef const TSTDEVDUTPCIREGION *PCTSTDEVDUTPCIREGION;
+
+/**
+ * Device under test instance data.
+ */
+typedef struct TSTDEVDUTINT
+{
+    /** Pointer to the test this device is running under. */
+    PCTSTDEVTEST                    pTest;
+    /** The PDM device registration record. */
+    PCTSTDEVPDMDEV                  pPdmDev;
+    /** Pointer to the PDM device instance. */
+    struct PDMDEVINSR3             *pDevIns;
+    /** Pointer to the PDM R0 device instance. */
+    struct PDMDEVINSR0             *pDevInsR0;
+    /** CFGM root config node for the device. */
+    CFGMNODE                        Cfg;
+    /** Current device context. */
+    TSTDEVDUTCTX                    enmCtx;
+    /** Critical section protecting the lists below. */
+    RTCRITSECTRW                    CritSectLists;
+    /** List of registered I/O port handlers. */
+    RTLISTANCHOR                    LstIoPorts;
+    /** List of timers registered. */
+    RTLISTANCHOR                    LstTimers;
+    /** List of registered MMIO regions. */
+    RTLISTANCHOR                    LstMmio;
+    /** List of MM Heap allocations. */
+    RTLISTANCHOR                    LstMmHeap;
+    /** List of PDM threads. */
+    RTLISTANCHOR                    LstPdmThreads;
+    /** List of SSM handlers (just one normally). */
+    RTLISTANCHOR                    LstSsmHandlers;
+    /** The SUP session we emulate. */
+    TSTDEVSUPDRVSESSION             SupSession;
+    /** The NOP critical section. */
+    PDMCRITSECT                     CritSectNop;
+    /** The VM state associated with this device. */
+    PVM                             pVm;
+    /** The registered PCI device instance if this is a PCI device. */
+    PPDMPCIDEV                      pPciDev;
+    /** PCI Region descriptors. */
+    TSTDEVDUTPCIREGION              aPciRegions[VBOX_PCI_NUM_REGIONS];
+    /** The status port interface we implement. */
+    PDMIBASE                        IBaseSts;
+    /**  */
+} TSTDEVDUTINT;
+
+
+#ifdef IN_RING3
+extern const PDMDEVHLPR3 g_tstDevPdmDevHlpR3;
+#endif
+extern const PDMDEVHLPR0 g_tstDevPdmDevHlpR0;
+
+DECLHIDDEN(int) tstDevPdmLdrGetSymbol(PTSTDEVDUTINT pThis, const char *pszMod, TSTDEVPDMMODTYPE enmModType,
+                                      const char *pszSymbol, PFNRT *ppfn);
+
+
+DECLINLINE(int) tstDevDutLockShared(PTSTDEVDUTINT pThis)
+{
+    return RTCritSectRwEnterShared(&pThis->CritSectLists);
+}
+
+DECLINLINE(int) tstDevDutUnlockShared(PTSTDEVDUTINT pThis)
+{
+    return RTCritSectRwLeaveShared(&pThis->CritSectLists);
+}
+
+DECLINLINE(int) tstDevDutLockExcl(PTSTDEVDUTINT pThis)
+{
+    return RTCritSectRwEnterExcl(&pThis->CritSectLists);
+}
+
+DECLINLINE(int) tstDevDutUnlockExcl(PTSTDEVDUTINT pThis)
+{
+    return RTCritSectRwLeaveExcl(&pThis->CritSectLists);
+}
+
+DECLHIDDEN(int) tstDevPdmR3ThreadCreateDevice(PTSTDEVDUTINT pDut, PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
+                                              PFNPDMTHREADWAKEUPDEV pfnWakeUp, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
+DECLHIDDEN(int) tstDevPdmR3ThreadCreateUsb(PTSTDEVDUTINT pDut, PPDMUSBINS pUsbIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADUSB pfnThread,
+                                           PFNPDMTHREADWAKEUPUSB pfnWakeUp, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
+DECLHIDDEN(int) tstDevPdmR3ThreadCreateDriver(PTSTDEVDUTINT pDut, PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
+                                              PFNPDMTHREADWAKEUPDRV pfnWakeUp, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
+DECLHIDDEN(int) tstDevPdmR3ThreadCreate(PTSTDEVDUTINT pDut, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADINT pfnThread,
+                                        PFNPDMTHREADWAKEUPINT pfnWakeUp, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
+DECLHIDDEN(int) tstDevPdmR3ThreadCreateExternal(PTSTDEVDUTINT pDut, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADEXT pfnThread,
+                                                PFNPDMTHREADWAKEUPEXT pfnWakeUp, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
+DECLHIDDEN(int) tstDevPdmR3ThreadDestroy(PPDMTHREAD pThread, int *pRcThread);
+DECLHIDDEN(int) tstDevPdmR3ThreadDestroyDevice(PTSTDEVDUTINT pDut, PPDMDEVINS pDevIns);
+DECLHIDDEN(int) tstDevPdmR3ThreadDestroyUsb(PTSTDEVDUTINT pDut, PPDMUSBINS pUsbIns);
+DECLHIDDEN(int) tstDevPdmR3ThreadDestroyDriver(PTSTDEVDUTINT pDut, PPDMDRVINS pDrvIns);
+DECLHIDDEN(void) tstDevPdmR3ThreadDestroyAll(PTSTDEVDUTINT pDut);
+DECLHIDDEN(int) tstDevPdmR3ThreadIAmSuspending(PPDMTHREAD pThread);
+DECLHIDDEN(int) tstDevPdmR3ThreadIAmRunning(PPDMTHREAD pThread);
+DECLHIDDEN(int) tstDevPdmR3ThreadSleep(PPDMTHREAD pThread, RTMSINTERVAL cMillies);
+DECLHIDDEN(int) tstDevPdmR3ThreadSuspend(PPDMTHREAD pThread);
+DECLHIDDEN(int) tstDevPdmR3ThreadResume(PPDMTHREAD pThread);
+
+
+DECLHIDDEN(PCTSTDEVPDMDEV) tstDevPdmDeviceFind(const char *pszName, PCPDMDEVREGR0 *ppR0Reg);
+DECLHIDDEN(int) tstDevPdmDeviceR3Construct(PTSTDEVDUTINT pDut);
+
+DECLHIDDEN(int) tstDevPdmDevR0R3Create(const char *pszName, bool fRCEnabled, PTSTDEVDUTINT pDut);
+
+
+RT_C_DECLS_END
+
+#endif /* !VBOX_INCLUDED_SRC_testcase_tstDeviceInternal_h */
diff --git a/src/VBox/Devices/testcase/tstDeviceIoFuzz.cpp b/src/VBox/Devices/testcase/tstDeviceIoFuzz.cpp
new file mode 100644
index 00000000..0eade5a6
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDeviceIoFuzz.cpp
@@ -0,0 +1,269 @@
+/* $Id: tstDeviceIoFuzz.cpp $ */
+/** @file
+ * tstDeviceSsmFuzz - I/O fuzzing testcase.
+ */
+
+/*
+ * Copyright (C) 2021-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
+#include <VBox/types.h>
+#include <iprt/errcore.h>
+#include <iprt/mem.h>
+#include <iprt/fuzz.h>
+#include <iprt/time.h>
+#include <iprt/rand.h>
+#include <iprt/string.h>
+#include <iprt/stream.h>
+
+#include "tstDeviceBuiltin.h"
+#include "tstDeviceCfg.h"
+#include "tstDeviceInternal.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+
+static const uint32_t g_aAccWidths[] = { 1, 2, 4, 8 };
+
+static PCTSTDEVCFGITEM tstDevSsmFuzzGetCfgItem(PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems, const char *pszName)
+{
+    for (uint32_t i = 0; i < cCfgItems; i++)
+    {
+        if (!RTStrCmp(paCfg[i].pszKey, pszName))
+            return &paCfg[i];
+    }
+
+    return NULL;
+}
+
+
+static uint64_t tstDevSsmFuzzGetCfgU64(PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems, const char *pszName)
+{
+    PCTSTDEVCFGITEM pCfgItem = tstDevSsmFuzzGetCfgItem(paCfg, cCfgItems, pszName);
+    if (   pCfgItem
+        && pCfgItem->enmType == TSTDEVCFGITEMTYPE_INTEGER)
+        return (uint64_t)pCfgItem->u.i64;
+
+    return 0;
+}
+
+
+/**
+ * Entry point for the SSM fuzzer.
+ *
+ * @returns VBox status code.
+ * @param   hDut                The device under test.
+ * @param   paCfg               The testcase config.
+ * @param   cCfgItems           Number of config items.
+ */
+static DECLCALLBACK(int) tstDevIoFuzzEntry(TSTDEVDUT hDut, PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems)
+{
+    /* Determine the amount of I/O port handlers. */
+    uint32_t cIoPortRegs = 0;
+    PRTDEVDUTIOPORT pIoPort;
+    RTListForEach(&hDut->LstIoPorts, pIoPort, RTDEVDUTIOPORT, NdIoPorts)
+    {
+        cIoPortRegs++;
+    }
+
+    /* Determine the amount of MMIO regions. */
+    uint32_t cMmioRegions = 0;
+    PRTDEVDUTMMIO pMmio;
+    RTListForEach(&hDut->LstMmio, pMmio, RTDEVDUTMMIO, NdMmio)
+    {
+        cMmioRegions++;
+    }
+
+    RTRAND hRnd;
+    int rc = RTRandAdvCreateParkMiller(&hRnd);
+    if (RT_SUCCESS(rc))
+    {
+        RTRandAdvSeed(hRnd, 0x123456789);
+        uint64_t cRuntimeMs = tstDevSsmFuzzGetCfgU64(paCfg, cCfgItems, "RuntimeSec") * RT_MS_1SEC_64;
+        uint64_t tsStart = RTTimeMilliTS();
+        uint64_t cFuzzedInputs = 0;
+        RTCritSectEnter(&hDut->pDevIns->pCritSectRoR3->s.CritSect);
+        do
+        {
+            bool fMmio = false;
+
+            if (   cMmioRegions
+                && !cIoPortRegs)
+                fMmio = true;
+            else if (   !cMmioRegions
+                     && cIoPortRegs)
+                fMmio = false;
+            else
+                fMmio = RT_BOOL(RTRandAdvU32Ex(hRnd, 0, 1));
+
+            if (fMmio)
+            {
+                uint32_t iMmio = RTRandAdvU32Ex(hRnd, 0, cMmioRegions - 1);
+                RTListForEach(&hDut->LstMmio, pMmio, RTDEVDUTMMIO, NdMmio)
+                {
+                    if (!iMmio)
+                        break;
+                    iMmio--;
+                }
+
+                uint32_t uMin = pMmio->pfnWriteR3 ? 0 : 1;
+                uint32_t uMax = pMmio->pfnReadR3  ? 1 : 0;
+
+                RTGCPHYS offRegion = RTRandAdvU64Ex(hRnd, 0, pMmio->cbRegion);
+                bool fRead = RT_BOOL(uMin == uMax ? uMin : RTRandAdvU32Ex(hRnd, uMin, uMax));
+                bool fRing0 = false;
+
+                if (   (   fRead
+                        && pMmio->pfnReadR0)
+                    || (   !fRead
+                        && pMmio->pfnWriteR0))
+                    fRing0 = RT_BOOL(RTRandAdvU32Ex(hRnd, 0, 1));
+
+                uint64_t u64Value = fRead ? 0 : RTRandAdvU64(hRnd);
+                uint32_t cbValue = g_aAccWidths[RTRandAdvU32Ex(hRnd, 0, 3)];
+
+                if (fRead)
+                {
+                    if (fRing0)
+                    {
+                        VBOXSTRICTRC rcStrict = pMmio->pfnReadR0((PPDMDEVINS)hDut->pDevInsR0, pIoPort->pvUserR0, offRegion, &u64Value, cbValue);
+                        if (VBOXSTRICTRC_VAL(rcStrict) == VINF_IOM_R3_MMIO_READ)
+                        {
+                            AssertRelease(pMmio->pfnReadR3);
+                            pMmio->pfnReadR3(hDut->pDevIns, pIoPort->pvUserR3, offRegion, &u64Value, cbValue);
+                        }
+
+                    }
+                    else
+                        pMmio->pfnReadR3(hDut->pDevIns, pMmio->pvUserR3, offRegion, &u64Value, cbValue);
+                }
+                else
+                {
+                    if (fRing0)
+                    {
+                        VBOXSTRICTRC rcStrict = pMmio->pfnWriteR0((PPDMDEVINS)hDut->pDevInsR0, pIoPort->pvUserR0, offRegion, &u64Value, cbValue);
+                        if (VBOXSTRICTRC_VAL(rcStrict) == VINF_IOM_R3_MMIO_WRITE)
+                        {
+                            AssertRelease(pMmio->pfnWriteR3);
+                            pMmio->pfnWriteR3(hDut->pDevIns, pIoPort->pvUserR3, offRegion, &u64Value, cbValue);
+                        }
+
+                    }
+                    else
+                        pMmio->pfnWriteR3(hDut->pDevIns, pMmio->pvUserR3, offRegion, &u64Value, cbValue);
+                }
+            }
+            else
+            {
+                uint32_t iIoPort = RTRandAdvU32Ex(hRnd, 0, cIoPortRegs - 1);
+                RTListForEach(&hDut->LstIoPorts, pIoPort, RTDEVDUTIOPORT, NdIoPorts)
+                {
+                    if (!iIoPort)
+                        break;
+                    iIoPort--;
+                }
+
+                uint32_t uMin = pIoPort->pfnOutR3 ? 0 : 1;
+                uint32_t uMax = pIoPort->pfnInR3  ? 1 : 0;
+
+                uint32_t offPort = RTRandAdvU32Ex(hRnd, 0, pIoPort->cPorts);
+                bool fRead = RT_BOOL(uMin == uMax ? uMin : RTRandAdvU32Ex(hRnd, uMin, uMax));
+                bool fRing0 = false;
+
+                if (   (   fRead
+                        && pIoPort->pfnInR0)
+                    || (   !fRead
+                        && pIoPort->pfnOutR3))
+                    fRing0 = RT_BOOL(RTRandAdvU32Ex(hRnd, 0, 1));
+
+                uint32_t u32Value = fRead ? 0 : RTRandAdvU32(hRnd);
+                uint32_t cbValue = g_aAccWidths[RTRandAdvU32Ex(hRnd, 0, 2)];
+
+                if (fRead)
+                {
+                    if (fRing0)
+                    {
+                        VBOXSTRICTRC rcStrict = pIoPort->pfnInR0((PPDMDEVINS)hDut->pDevInsR0, pIoPort->pvUserR0, offPort, &u32Value, cbValue);
+                        if (VBOXSTRICTRC_VAL(rcStrict) == VINF_IOM_R3_IOPORT_READ)
+                        {
+                            AssertRelease(pIoPort->pfnInR3);
+                            pIoPort->pfnInR3(hDut->pDevIns, pIoPort->pvUserR3, offPort, &u32Value, cbValue);
+                        }
+
+                    }
+                    else
+                        pIoPort->pfnInR3(hDut->pDevIns, pIoPort->pvUserR3, offPort, &u32Value, cbValue);
+                }
+                else
+                {
+                    if (fRing0)
+                    {
+                        VBOXSTRICTRC rcStrict = pIoPort->pfnOutR0((PPDMDEVINS)hDut->pDevInsR0, pIoPort->pvUserR0, offPort, u32Value, cbValue);
+                        if (VBOXSTRICTRC_VAL(rcStrict) == VINF_IOM_R3_IOPORT_WRITE)
+                        {
+                            AssertRelease(pIoPort->pfnOutR3);
+                            pIoPort->pfnOutR3(hDut->pDevIns, pIoPort->pvUserR3, offPort, u32Value, cbValue);
+                        }
+
+                    }
+                    else
+                        pIoPort->pfnOutR3(hDut->pDevIns, pIoPort->pvUserR3, offPort, u32Value, cbValue);
+                }
+            }
+
+            cFuzzedInputs++;
+        } while (   RT_SUCCESS(rc)
+                 && RTTimeMilliTS() - tsStart < cRuntimeMs);
+        RTCritSectLeave(&hDut->pDevIns->pCritSectRoR3->s.CritSect);
+
+        RTPrintf("Fuzzed inputs: %u\n", cFuzzedInputs);
+        RTRandAdvDestroy(hRnd);
+    }
+
+    return rc;
+}
+
+
+const TSTDEVTESTCASEREG g_TestcaseIoFuzz =
+{
+    /** szName */
+    "IoFuzz",
+    /** pszDesc */
+    "Fuzzes devices I/O handlers",
+    /** fFlags */
+    0,
+    /** pfnTestEntry */
+    tstDevIoFuzzEntry
+};
+
diff --git a/src/VBox/Devices/testcase/tstDevicePdmDevHlp.cpp b/src/VBox/Devices/testcase/tstDevicePdmDevHlp.cpp
new file mode 100644
index 00000000..0c4d54d9
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDevicePdmDevHlp.cpp
@@ -0,0 +1,6196 @@
+/* $Id: tstDevicePdmDevHlp.cpp $ */
+/** @file
+ * tstDevice - Test framework for PDM devices/drivers, PDM helper implementation.
+ */
+
+/*
+ * Copyright (C) 2017-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
+#include <VBox/types.h>
+#include <VBox/version.h>
+#include <VBox/vmm/pdmpci.h>
+
+#include <iprt/assert.h>
+#include <iprt/mem.h>
+#include <iprt/rand.h>
+
+#include "tstDeviceInternal.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+
+/* Temporarily until the stubs got implemented. */
+#define VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS 1
+
+/** @def PDMDEV_ASSERT_DEVINS
+ * Asserts the validity of the device instance.
+ */
+#ifdef VBOX_STRICT
+# define PDMDEV_ASSERT_DEVINS(pDevIns)   \
+    do { \
+        AssertPtr(pDevIns); \
+        Assert(pDevIns->u32Version == PDM_DEVINS_VERSION); \
+        Assert(pDevIns->CTX_SUFF(pvInstanceDataFor) == (void *)&pDevIns->achInstanceData[0]); \
+    } while (0)
+#else
+# define PDMDEV_ASSERT_DEVINS(pDevIns)   do { } while (0)
+#endif
+
+
+/** Frequency of the real clock. */
+#define TMCLOCK_FREQ_REAL       UINT32_C(1000)
+/** Frequency of the virtual clock. */
+#define TMCLOCK_FREQ_VIRTUAL    UINT32_C(1000000000)
+
+
+/** Start structure magic. (Isaac Asimov) */
+#define SSMR3STRUCT_BEGIN                       UINT32_C(0x19200102)
+/** End structure magic. (Isaac Asimov) */
+#define SSMR3STRUCT_END                         UINT32_C(0x19920406)
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+
+
+/**
+ * Resolves a path reference to a configuration item.
+ *
+ * @returns VBox status code.
+ * @param   paDevCfg        The array of config items.
+ * @param   cCfgItems       Number of config items in the array.
+ * @param   pszName         Name of a byte string value.
+ * @param   ppItem          Where to store the pointer to the item.
+ */
+static int tstDev_CfgmR3ResolveItem(PCTSTDEVCFGITEM paDevCfg, uint32_t cCfgItems, const char *pszName, PCTSTDEVCFGITEM *ppItem)
+{
+    *ppItem = NULL;
+    if (!paDevCfg)
+        return VERR_CFGM_VALUE_NOT_FOUND;
+
+    size_t          cchName = strlen(pszName);
+    PCTSTDEVCFGITEM pDevCfgItem = paDevCfg;
+
+    for (uint32_t i = 0; i < cCfgItems; i++)
+    {
+        size_t cchKey = strlen(pDevCfgItem->pszKey);
+        if (cchName == cchKey)
+        {
+            int iDiff = memcmp(pszName, pDevCfgItem->pszKey, cchName);
+            if (iDiff <= 0)
+            {
+                if (iDiff != 0)
+                    break;
+                *ppItem = pDevCfgItem;
+                return VINF_SUCCESS;
+            }
+        }
+
+        /* next */
+        pDevCfgItem++;
+    }
+    return VERR_CFGM_VALUE_NOT_FOUND;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortCreateEx} */
+static DECLCALLBACK(int) pdmR3DevHlp_IoPortCreateEx(PPDMDEVINS pDevIns, RTIOPORT cPorts, uint32_t fFlags, PPDMPCIDEV pPciDev,
+                                                    uint32_t iPciRegion, PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
+                                                    PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr, RTR3PTR pvUser,
+                                                    const char *pszDesc, PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_IoPortCreateEx: caller='%s'/%d: cPorts=%#x fFlags=%#x pPciDev=%p iPciRegion=%#x pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p pvUser=%p pszDesc=%p:{%s} paExtDescs=%p phIoPorts=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, cPorts, fFlags, pPciDev, iPciRegion, pfnOut, pfnIn, pfnOutStr, pfnInStr,
+             pvUser, pszDesc, pszDesc, paExtDescs, phIoPorts));
+
+    /** @todo Verify there is no overlapping. */
+
+    RT_NOREF(pszDesc);
+    int rc = VINF_SUCCESS;
+    PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)RTMemAllocZ(sizeof(RTDEVDUTIOPORT));
+    if (RT_LIKELY(pIoPort))
+    {
+        pIoPort->cPorts      = cPorts;
+        pIoPort->pvUserR3    = pvUser;
+        pIoPort->pfnOutR3    = pfnOut;
+        pIoPort->pfnInR3     = pfnIn;
+        pIoPort->pfnOutStrR3 = pfnOutStr;
+        pIoPort->pfnInStrR3  = pfnInStr;
+        RTListAppend(&pDevIns->Internal.s.pDut->LstIoPorts, &pIoPort->NdIoPorts);
+        *phIoPorts = (IOMIOPORTHANDLE)pIoPort;
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    LogFlow(("pdmR3DevHlp_IoPortCreateEx: caller='%s'/%d: returns %Rrc (*phIoPorts=%#x)\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc, *phIoPorts));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortMap} */
+static DECLCALLBACK(int) pdmR3DevHlp_IoPortMap(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts, RTIOPORT Port)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: hIoPorts=%#x Port=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts, Port));
+
+    PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)hIoPorts;
+    pIoPort->PortStart = Port;
+
+    LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: returns VINF_SUCCESS\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortUnmap} */
+static DECLCALLBACK(int) pdmR3DevHlp_IoPortUnmap(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: hIoPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts));
+
+    PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)hIoPorts;
+    pIoPort->PortStart = 0;
+    int rc = VINF_SUCCESS;
+
+    LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortGetMappingAddress} */
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_IoPortGetMappingAddress(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_IoPortGetMappingAddress: caller='%s'/%d: hIoPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts));
+
+    PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)hIoPorts;
+    uint32_t uAddress = pIoPort->PortStart;
+
+    LogFlow(("pdmR3DevHlp_IoPortGetMappingAddress: caller='%s'/%d: returns %#RX32\n", pDevIns->pReg->szName, pDevIns->iInstance, uAddress));
+    return uAddress;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnIoPortWrite} */
+static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_IoPortWrite(PPDMDEVINS pDevIns, RTIOPORT Port, uint32_t u32Value, size_t cbValue)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_IoPortWrite: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+    RT_NOREF(Port, u32Value, cbValue);
+    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_IoPortWrite: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict)));
+    return rcStrict;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmioCreateEx} */
+static DECLCALLBACK(int) pdmR3DevHlp_MmioCreateEx(PPDMDEVINS pDevIns, RTGCPHYS cbRegion,
+                                                  uint32_t fFlags, PPDMPCIDEV pPciDev, uint32_t iPciRegion,
+                                                  PFNIOMMMIONEWWRITE pfnWrite, PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill,
+                                                  void *pvUser, const char *pszDesc, PIOMMMIOHANDLE phRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_MmioCreateEx: caller='%s'/%d: cbRegion=%#RGp fFlags=%#x pPciDev=%p iPciRegion=%#x pfnWrite=%p pfnRead=%p pfnFill=%p pvUser=%p pszDesc=%p:{%s} phRegion=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, fFlags, pPciDev, iPciRegion, pfnWrite, pfnRead, pfnFill, pvUser, pszDesc, pszDesc, phRegion));
+
+    /** @todo Verify there is no overlapping. */
+
+    RT_NOREF(pszDesc);
+    int rc = VINF_SUCCESS;
+    PRTDEVDUTMMIO pMmio = (PRTDEVDUTMMIO)RTMemAllocZ(sizeof(*pMmio));
+    if (RT_LIKELY(pMmio))
+    {
+        pMmio->cbRegion    = cbRegion;
+        pMmio->pvUserR3    = pvUser;
+        pMmio->pfnWriteR3  = pfnWrite;
+        pMmio->pfnReadR3   = pfnRead;
+        pMmio->pfnFillR3   = pfnFill;
+        RTListAppend(&pDevIns->Internal.s.pDut->LstMmio, &pMmio->NdMmio);
+        *phRegion = (IOMMMIOHANDLE)pMmio;
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    LogFlow(("pdmR3DevHlp_MmioCreateEx: caller='%s'/%d: returns %Rrc (*phRegion=%#x)\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc, *phRegion));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmioMap} */
+static DECLCALLBACK(int) pdmR3DevHlp_MmioMap(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS GCPhys)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_MmioMap: caller='%s'/%d: hRegion=%#x GCPhys=%#RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, GCPhys));
+
+    int rc = VINF_SUCCESS;
+    PRTDEVDUTMMIO pMmio = (PRTDEVDUTMMIO)hRegion;
+    pMmio->GCPhysStart = GCPhys;
+
+    LogFlow(("pdmR3DevHlp_MmioMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmioUnmap} */
+static DECLCALLBACK(int) pdmR3DevHlp_MmioUnmap(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_MmioUnmap: caller='%s'/%d: hRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
+
+    int rc = VINF_SUCCESS;
+    PRTDEVDUTMMIO pMmio = (PRTDEVDUTMMIO)hRegion;
+    pMmio->GCPhysStart = NIL_RTGCPHYS;
+
+    LogFlow(("pdmR3DevHlp_MmioUnmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmioReduce} */
+static DECLCALLBACK(int) pdmR3DevHlp_MmioReduce(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS cbRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_MmioReduce: caller='%s'/%d: hRegion=%#x cbRegion=%#RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, cbRegion));
+
+    int rc = VINF_SUCCESS;
+    PRTDEVDUTMMIO pMmio = (PRTDEVDUTMMIO)hRegion;
+    pMmio->cbRegion = cbRegion;
+
+    LogFlow(("pdmR3DevHlp_MmioReduce: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmioGetMappingAddress} */
+static DECLCALLBACK(RTGCPHYS) pdmR3DevHlp_MmioGetMappingAddress(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_MmioGetMappingAddress: caller='%s'/%d: hRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
+
+    PRTDEVDUTMMIO pMmio = (PRTDEVDUTMMIO)hRegion;
+    RTGCPHYS GCPhys = pMmio->GCPhysStart;
+
+    LogFlow(("pdmR3DevHlp_MmioGetMappingAddress: caller='%s'/%d: returns %RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
+    return GCPhys;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Create} */
+static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Create(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iPciRegion, RTGCPHYS cbRegion,
+                                                 uint32_t fFlags, const char *pszDesc, void **ppvMapping, PPGMMMIO2HANDLE phRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_Mmio2Create: caller='%s'/%d: pPciDev=%p (%#x) iPciRegion=%#x cbRegion=%#RGp fFlags=%RX32 pszDesc=%p:{%s} ppvMapping=%p phRegion=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iPciRegion, cbRegion,
+             fFlags, pszDesc, pszDesc, ppvMapping, phRegion));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+    *phRegion   = 0;
+    *ppvMapping = RTMemAllocZ(cbRegion);
+    if (!*ppvMapping)
+        rc = VERR_NO_MEMORY;
+#endif
+
+    LogFlow(("pdmR3DevHlp_Mmio2Create: caller='%s'/%d: returns %Rrc *ppvMapping=%p phRegion=%#RX64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc, *ppvMapping, *phRegion));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Destroy} */
+static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Destroy(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_Mmio2Destroy: caller='%s'/%d: hRegion=%#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_Mmio2Destroy: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Map} */
+static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Map(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, RTGCPHYS GCPhys)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_Mmio2Map: caller='%s'/%d: hRegion=%#RX64 GCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, GCPhys));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_Mmio2Map: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Unmap} */
+static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Unmap(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_Mmio2Unmap: caller='%s'/%d: hRegion=%#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_Mmio2Unmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2Reduce} */
+static DECLCALLBACK(int) pdmR3DevHlp_Mmio2Reduce(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, RTGCPHYS cbRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_Mmio2Reduce: caller='%s'/%d: hRegion=%#RX64 cbRegion=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, cbRegion));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_Mmio2Reduce: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2GetMappingAddress} */
+static DECLCALLBACK(RTGCPHYS) pdmR3DevHlp_Mmio2GetMappingAddress(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_Mmio2GetMappingAddress: caller='%s'/%d: hRegion=%#RX6r\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
+
+    RTGCPHYS GCPhys = NIL_RTGCPHYS;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_Mmio2GetMappingAddress: caller='%s'/%d: returns %RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
+    return GCPhys;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2QueryAndResetDirtyBitmap} */
+static DECLCALLBACK(int) pdmR3DevHlp_Mmio2QueryAndResetDirtyBitmap(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion,
+                                                                   void *pvBitmap, size_t cbBitmap)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    //PVM pVM = pDevIns->Internal.s.pVMR3;
+    LogFlow(("pdmR3DevHlp_Mmio2QueryAndResetDirtyBitmap: caller='%s'/%d: hRegion=%#RX64 pvBitmap=%p cbBitmap=%#zx\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hRegion, pvBitmap, cbBitmap));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+
+    LogFlow(("pdmR3DevHlp_Mmio2QueryAndResetDirtyBitmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmio2ControlDirtyPageTracking} */
+static DECLCALLBACK(int) pdmR3DevHlp_Mmio2ControlDirtyPageTracking(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, bool fEnabled)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    //PVM pVM = pDevIns->Internal.s.pVMR3;
+    LogFlow(("pdmR3DevHlp_Mmio2ControlDirtyPageTracking: caller='%s'/%d: hRegion=%#RX64 fEnabled=%RTbool\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hRegion, fEnabled));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+
+    LogFlow(("pdmR3DevHlp_Mmio2ControlDirtyPageTracking: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMmio2ChangeRegionNo
+ */
+static DECLCALLBACK(int) pdmR3DevHlp_Mmio2ChangeRegionNo(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion, uint32_t iNewRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_Mmio2ChangeRegionNo: caller='%s'/%d: hRegion=%#RX6r iNewRegion=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, hRegion, iNewRegion));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_Mmio2ChangeRegionNo: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmioMapMmio2Page} */
+static DECLCALLBACK(int) pdmR3DevHlp_MmioMapMmio2Page(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS offRegion,
+                                                      uint64_t hMmio2, RTGCPHYS offMmio2, uint64_t fPageFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_MmioMapMmio2Page: caller='%s'/%d: hRegion=%RX64 offRegion=%RGp hMmio2=%RX64 offMmio2=%RGp fPageFlags=%RX64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hRegion, offRegion, hMmio2, offMmio2, fPageFlags));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_MmioMapMmio2Page: caller='%s'/%d: returns %Rrc\n",
+         pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMmioResetRegion} */
+static DECLCALLBACK(int) pdmR3DevHlp_MmioResetRegion(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_MmioResetRegion: caller='%s'/%d: hRegion=%RX64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_MmioResetRegion: caller='%s'/%d: returns %Rrc\n",
+         pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnROMRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_ROMRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange,
+                                                 const void *pvBinary, uint32_t cbBinary, uint32_t fFlags, const char *pszDesc)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvBinary=%p cbBinary=%#x fFlags=%#RX32 pszDesc=%p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, cbBinary, fFlags, pszDesc, pszDesc));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnROMProtectShadow} */
+static DECLCALLBACK(int) pdmR3DevHlp_ROMProtectShadow(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, uint32_t cbRange, PGMROMPROT enmProt)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x enmProt=%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, enmProt));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMRegister(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess, const char *pszBefore,
+                                                 PFNSSMDEVLIVEPREP pfnLivePrep, PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVLIVEVOTE pfnLiveVote,
+                                                 PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
+                                                 PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: uVersion=%#x cbGuess=%#x pszBefore=%p:{%s}\n"
+             "    pfnLivePrep=%p pfnLiveExec=%p pfnLiveVote=%p pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoadDone=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, uVersion, cbGuess, pszBefore, pszBefore,
+             pfnLivePrep, pfnLiveExec, pfnLiveVote,
+             pfnSavePrep, pfnSaveExec, pfnSaveDone,
+             pfnLoadPrep, pfnLoadExec, pfnLoadDone));
+
+    RT_NOREF(cbGuess, pszBefore);
+    int rc = VINF_SUCCESS;
+    PTSTDEVDUTSSM pSsm = (PTSTDEVDUTSSM)RTMemAllocZ(sizeof(*pSsm));
+    if (RT_LIKELY(pSsm))
+    {
+        pSsm->uVersion      = uVersion;
+        pSsm->pfnLivePrep   = pfnLivePrep;
+        pSsm->pfnLiveExec   = pfnLiveExec;
+        pSsm->pfnLiveVote   = pfnLiveVote;
+        pSsm->pfnSavePrep   = pfnSavePrep;
+        pSsm->pfnSaveExec   = pfnSaveExec;
+        pSsm->pfnSaveDone   = pfnSaveDone;
+        pSsm->pfnLoadPrep   = pfnLoadPrep;
+        pSsm->pfnLoadExec   = pfnLoadExec;
+        pSsm->pfnLoadDone   = pfnLoadDone;
+        RTListAppend(&pDevIns->Internal.s.pDut->LstSsmHandlers, &pSsm->NdSsm);
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSSMRegisterLegacy} */
+static DECLCALLBACK(int) pdmR3DevHlp_SSMRegisterLegacy(PPDMDEVINS pDevIns, const char *pszOldName, PFNSSMDEVLOADPREP pfnLoadPrep,
+                                                       PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SSMRegisterLegacy: caller='%s'/%d: pszOldName=%p:{%s} pfnLoadPrep=%p pfnLoadExec=%p pfnLoadDone=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pszOldName, pszOldName, pfnLoadPrep, pfnLoadExec, pfnLoadDone));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_SSMRegisterLegacy: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutStruct(PSSMHANDLE pSSM, const void *pvStruct, PCSSMFIELD paFields)
+{
+    RT_NOREF(pSSM, pvStruct, paFields);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutStructEx(PSSMHANDLE pSSM, const void *pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void *pvUser)
+{
+    RT_NOREF(pSSM, pvStruct, cbStruct, fFlags, paFields, pvUser);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutBool(PSSMHANDLE pSSM, bool fBool)
+{
+    RT_NOREF(pSSM, fBool);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU8(PSSMHANDLE pSSM, uint8_t u8)
+{
+    RT_NOREF(pSSM, u8);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS8(PSSMHANDLE pSSM, int8_t i8)
+{
+    RT_NOREF(pSSM, i8);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU16(PSSMHANDLE pSSM, uint16_t u16)
+{
+    RT_NOREF(pSSM, u16);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS16(PSSMHANDLE pSSM, int16_t i16)
+{
+    RT_NOREF(pSSM, i16);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU32(PSSMHANDLE pSSM, uint32_t u32)
+{
+    RT_NOREF(pSSM, u32);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS32(PSSMHANDLE pSSM, int32_t i32)
+{
+    RT_NOREF(pSSM, i32);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU64(PSSMHANDLE pSSM, uint64_t u64)
+{
+    RT_NOREF(pSSM, u64);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS64(PSSMHANDLE pSSM, int64_t i64)
+{
+    RT_NOREF(pSSM, i64);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutU128(PSSMHANDLE pSSM, uint128_t u128)
+{
+    RT_NOREF(pSSM, u128);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutS128(PSSMHANDLE pSSM, int128_t i128)
+{
+    RT_NOREF(pSSM, i128);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutUInt(PSSMHANDLE pSSM, RTUINT u)
+{
+    RT_NOREF(pSSM, u);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutSInt(PSSMHANDLE pSSM, RTINT i)
+{
+    RT_NOREF(pSSM, i);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCUInt(PSSMHANDLE pSSM, RTGCUINT u)
+{
+    RT_NOREF(pSSM, u);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCUIntReg(PSSMHANDLE pSSM, RTGCUINTREG u)
+{
+    RT_NOREF(pSSM, u);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPhys32(PSSMHANDLE pSSM, RTGCPHYS32 GCPhys)
+{
+    RT_NOREF(pSSM, GCPhys);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPhys64(PSSMHANDLE pSSM, RTGCPHYS64 GCPhys)
+{
+    RT_NOREF(pSSM, GCPhys);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPhys(PSSMHANDLE pSSM, RTGCPHYS GCPhys)
+{
+    RT_NOREF(pSSM, GCPhys);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCPtr(PSSMHANDLE pSSM, RTGCPTR GCPtr)
+{
+    RT_NOREF(pSSM, GCPtr);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutGCUIntPtr(PSSMHANDLE pSSM, RTGCUINTPTR GCPtr)
+{
+    RT_NOREF(pSSM, GCPtr);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutRCPtr(PSSMHANDLE pSSM, RTRCPTR RCPtr)
+{
+    RT_NOREF(pSSM, RCPtr);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutIOPort(PSSMHANDLE pSSM, RTIOPORT IOPort)
+{
+    RT_NOREF(pSSM, IOPort);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutSel(PSSMHANDLE pSSM, RTSEL Sel)
+{
+    RT_NOREF(pSSM, Sel);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutMem(PSSMHANDLE pSSM, const void *pv, size_t cb)
+{
+    RT_NOREF(pSSM, pv, cb);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMPutStrZ(PSSMHANDLE pSSM, const char *psz)
+{
+    RT_NOREF(pSSM, psz);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/**
+ * Gets the host bit count of the saved state.
+ *
+ * Works for on both save and load handles.
+ *
+ * @returns 32 or 64.
+ * @param   pSSM                The saved state handle.
+ */
+DECLINLINE(uint32_t) ssmR3GetHostBits(PSSMHANDLE pSSM)
+{
+    /** @todo Don't care about 32bit saved states for now (VBox is 64bit only as of 6.0). */
+    RT_NOREF(pSSM);
+    return HC_ARCH_BITS;
+}
+
+
+/**
+ * Saved state origins on a host using 32-bit MSC?
+ *
+ * Works for on both save and load handles.
+ *
+ * @returns true/false.
+ * @param   pSSM                The saved state handle.
+ */
+DECLINLINE(bool) ssmR3IsHostMsc32(PSSMHANDLE pSSM)
+{
+    /** @todo Don't care about 32bit saved states for now (VBox is 64bit only as of 6.0). */
+    RT_NOREF(pSSM);
+    return false;
+}
+
+
+/**
+ * Inlined worker that handles format checks and buffered reads.
+ *
+ * @param   pSSM            The saved state handle.
+ * @param   pvBuf           Where to store the read data.
+ * @param   cbBuf           Number of bytes to read.
+ */
+DECLINLINE(int) tstDevSsmR3DataRead(PSSMHANDLE pSSM, void *pvBuf, size_t cbBuf)
+{
+    /*
+     * Fend off previous errors and V1 data units.
+     */
+    if (RT_SUCCESS(pSSM->rc))
+    {
+        /** @todo Don't care about version 1 saved states (long obsolete). */
+        uint32_t off = pSSM->offDataBuffer;
+        if (   cbBuf <= pSSM->cbSavedState
+            && pSSM->cbSavedState - cbBuf >= off)
+        {
+            memcpy(pvBuf, &pSSM->pbSavedState[off], cbBuf);
+            pSSM->offDataBuffer = off + (uint32_t)cbBuf;
+            return VINF_SUCCESS;
+        }
+        else
+            pSSM->rc = VERR_BUFFER_OVERFLOW;
+    }
+    return pSSM->rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBool(PSSMHANDLE pSSM, bool *pfBool)
+{
+    uint8_t u8; /* see SSMR3PutBool */
+    int rc = tstDevSsmR3DataRead(pSSM, &u8, sizeof(u8));
+    if (RT_SUCCESS(rc))
+    {
+        Assert(u8 <= 1);
+        *pfBool = RT_BOOL(u8);
+    }
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBoolV(PSSMHANDLE pSSM, bool volatile *pfBool)
+{
+    uint8_t u8; /* see SSMR3PutBool */
+    int rc = tstDevSsmR3DataRead(pSSM, &u8, sizeof(u8));
+    if (RT_SUCCESS(rc))
+    {
+        Assert(u8 <= 1);
+        *pfBool = RT_BOOL(u8);
+    }
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8(PSSMHANDLE pSSM, uint8_t *pu8)
+{
+    return tstDevSsmR3DataRead(pSSM, pu8, sizeof(*pu8));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8V(PSSMHANDLE pSSM, uint8_t volatile *pu8)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pu8, sizeof(*pu8));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8(PSSMHANDLE pSSM, int8_t *pi8)
+{
+    return tstDevSsmR3DataRead(pSSM, pi8, sizeof(*pi8));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8V(PSSMHANDLE pSSM, int8_t volatile *pi8)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pi8, sizeof(*pi8));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16(PSSMHANDLE pSSM, uint16_t *pu16)
+{
+    return tstDevSsmR3DataRead(pSSM, pu16, sizeof(*pu16));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16V(PSSMHANDLE pSSM, uint16_t volatile *pu16)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pu16, sizeof(*pu16));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16(PSSMHANDLE pSSM, int16_t *pi16)
+{
+    return tstDevSsmR3DataRead(pSSM, pi16, sizeof(*pi16));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16V(PSSMHANDLE pSSM, int16_t volatile *pi16)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pi16, sizeof(*pi16));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32(PSSMHANDLE pSSM, uint32_t *pu32)
+{
+    return tstDevSsmR3DataRead(pSSM, pu32, sizeof(*pu32));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32V(PSSMHANDLE pSSM, uint32_t volatile *pu32)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pu32, sizeof(*pu32));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32(PSSMHANDLE pSSM, int32_t *pi32)
+{
+    return tstDevSsmR3DataRead(pSSM, pi32, sizeof(*pi32));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32V(PSSMHANDLE pSSM, int32_t volatile *pi32)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pi32, sizeof(*pi32));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64(PSSMHANDLE pSSM, uint64_t *pu64)
+{
+    return tstDevSsmR3DataRead(pSSM, pu64, sizeof(*pu64));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64V(PSSMHANDLE pSSM, uint64_t volatile *pu64)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pu64, sizeof(*pu64));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64(PSSMHANDLE pSSM, int64_t *pi64)
+{
+    return tstDevSsmR3DataRead(pSSM, pi64, sizeof(*pi64));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64V(PSSMHANDLE pSSM, int64_t volatile *pi64)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pi64, sizeof(*pi64));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128(PSSMHANDLE pSSM, uint128_t *pu128)
+{
+    return tstDevSsmR3DataRead(pSSM, pu128, sizeof(*pu128));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128V(PSSMHANDLE pSSM, uint128_t volatile *pu128)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pu128, sizeof(*pu128));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128(PSSMHANDLE pSSM, int128_t *pi128)
+{
+    return tstDevSsmR3DataRead(pSSM, pi128, sizeof(*pi128));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128V(PSSMHANDLE pSSM, int128_t  volatile *pi128)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pi128, sizeof(*pi128));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32(PSSMHANDLE pSSM, PRTGCPHYS32 pGCPhys)
+{
+    return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(*pGCPhys));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32V(PSSMHANDLE pSSM, RTGCPHYS32 volatile *pGCPhys)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pGCPhys, sizeof(*pGCPhys));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64(PSSMHANDLE pSSM, PRTGCPHYS64 pGCPhys)
+{
+    return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(*pGCPhys));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64V(PSSMHANDLE pSSM, RTGCPHYS64 volatile *pGCPhys)
+{
+    return tstDevSsmR3DataRead(pSSM, (void *)pGCPhys, sizeof(*pGCPhys));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys(PSSMHANDLE pSSM, PRTGCPHYS pGCPhys)
+{
+    /*
+     * Default size?
+     */
+    if (RT_LIKELY(/*sizeof(*pGCPhys) == pSSM->u.Read.cbGCPhys*/true))
+        return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(*pGCPhys));
+
+#if 0 /** @todo Later if necessary (only very old saved states). */
+    /*
+     * Fiddly.
+     */
+    Assert(sizeof(*pGCPhys)      == sizeof(uint64_t) || sizeof(*pGCPhys)      == sizeof(uint32_t));
+    Assert(pSSM->u.Read.cbGCPhys == sizeof(uint64_t) || pSSM->u.Read.cbGCPhys == sizeof(uint32_t));
+    if (pSSM->u.Read.cbGCPhys == sizeof(uint64_t))
+    {
+        /* 64-bit saved, 32-bit load: try truncate it. */
+        uint64_t u64;
+        int rc = tstDevSsmR3DataRead(pSSM, &u64, sizeof(uint64_t));
+        if (RT_FAILURE(rc))
+            return rc;
+        if (u64 >= _4G)
+            return VERR_SSM_GCPHYS_OVERFLOW;
+        *pGCPhys = (RTGCPHYS)u64;
+        return rc;
+    }
+
+    /* 32-bit saved, 64-bit load: clear the high part. */
+    *pGCPhys = 0;
+    return tstDevSsmR3DataRead(pSSM, pGCPhys, sizeof(uint32_t));
+#endif
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhysV(PSSMHANDLE pSSM, RTGCPHYS volatile *pGCPhys)
+{
+    return pdmR3DevHlp_SSMGetGCPhys(pSSM, (PRTGCPHYS)pGCPhys);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetUInt(PSSMHANDLE pSSM, PRTUINT pu)
+{
+    return tstDevSsmR3DataRead(pSSM, pu, sizeof(*pu));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSInt(PSSMHANDLE pSSM, PRTINT pi)
+{
+    return tstDevSsmR3DataRead(pSSM, pi, sizeof(*pi));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPtr(PSSMHANDLE pSSM, PRTGCPTR pGCPtr)
+{
+    return tstDevSsmR3DataRead(pSSM, pGCPtr, sizeof(*pGCPtr));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUInt(PSSMHANDLE pSSM, PRTGCUINT pu)
+{
+    return pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pu);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntReg(PSSMHANDLE pSSM, PRTGCUINTREG pu)
+{
+    AssertCompile(sizeof(RTGCPTR) == sizeof(*pu));
+    return pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pu);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntPtr(PSSMHANDLE pSSM, PRTGCUINTPTR pGCPtr)
+{
+    return pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pGCPtr);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetRCPtr(PSSMHANDLE pSSM, PRTRCPTR pRCPtr)
+{
+    return tstDevSsmR3DataRead(pSSM, pRCPtr, sizeof(*pRCPtr));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetIOPort(PSSMHANDLE pSSM, PRTIOPORT pIOPort)
+{
+    return tstDevSsmR3DataRead(pSSM, pIOPort, sizeof(*pIOPort));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSel(PSSMHANDLE pSSM, PRTSEL pSel)
+{
+    return tstDevSsmR3DataRead(pSSM, pSel, sizeof(*pSel));
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetMem(PSSMHANDLE pSSM, void *pv, size_t cb)
+{
+    return tstDevSsmR3DataRead(pSSM, pv, cb);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZEx(PSSMHANDLE pSSM, char *psz, size_t cbMax, size_t *pcbStr)
+{
+    /* read size prefix. */
+    uint32_t u32;
+    int rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32);
+    if (RT_SUCCESS(rc))
+    {
+        if (pcbStr)
+            *pcbStr = u32;
+        if (u32 < cbMax)
+        {
+            /* terminate and read string content. */
+            psz[u32] = '\0';
+            return tstDevSsmR3DataRead(pSSM, psz, u32);
+        }
+        return VERR_TOO_MUCH_DATA;
+    }
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZ(PSSMHANDLE pSSM, char *psz, size_t cbMax)
+{
+    return pdmR3DevHlp_SSMGetStrZEx(pSSM, psz, cbMax, NULL);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMSkip(PSSMHANDLE pSSM, size_t cb)
+{
+    while (cb > 0)
+    {
+        uint8_t abBuf[8192];
+        size_t  cbCur = RT_MIN(sizeof(abBuf), cb);
+        cb -= cbCur;
+        int rc = tstDevSsmR3DataRead(pSSM, abBuf, cbCur);
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStruct(PSSMHANDLE pSSM, void *pvStruct, PCSSMFIELD paFields)
+{
+    AssertPtr(pvStruct);
+    AssertPtr(paFields);
+
+    /* begin marker. */
+    uint32_t u32Magic;
+    int rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
+    if (RT_FAILURE(rc))
+        return rc;
+    AssertMsgReturn(u32Magic == SSMR3STRUCT_BEGIN, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
+
+    /* get the fields */
+    for (PCSSMFIELD pCur = paFields;
+         pCur->cb != UINT32_MAX && pCur->off != UINT32_MAX;
+         pCur++)
+    {
+        if (pCur->uFirstVer <= pSSM->uCurUnitVer)
+        {
+            uint8_t *pbField = (uint8_t *)pvStruct + pCur->off;
+            switch ((uintptr_t)pCur->pfnGetPutOrTransformer)
+            {
+                case SSMFIELDTRANS_NO_TRANSFORMATION:
+                    rc = tstDevSsmR3DataRead(pSSM, pbField, pCur->cb);
+                    break;
+
+                case SSMFIELDTRANS_GCPTR:
+                    AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pbField);
+                    break;
+
+                case SSMFIELDTRANS_GCPHYS:
+                    AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPHYS), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMGetGCPhys(pSSM, (PRTGCPHYS)pbField);
+                    break;
+
+                case SSMFIELDTRANS_RCPTR:
+                    AssertMsgBreakStmt(pCur->cb == sizeof(RTRCPTR), ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, (PRTRCPTR)pbField);
+                    break;
+
+                case SSMFIELDTRANS_RCPTR_ARRAY:
+                {
+                    uint32_t const cEntries = pCur->cb / sizeof(RTRCPTR);
+                    AssertMsgBreakStmt(pCur->cb == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", pCur->cb, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = VINF_SUCCESS;
+                    for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
+                        rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, &((PRTRCPTR)pbField)[i]);
+                    break;
+                }
+
+                default:
+                    AssertMsgFailedBreakStmt(("%#x\n", pCur->pfnGetPutOrTransformer), rc = VERR_SSM_FIELD_COMPLEX);
+            }
+            if (RT_FAILURE(rc))
+            {
+                if (RT_SUCCESS(pSSM->rc))
+                    pSSM->rc = rc;
+                return rc;
+            }
+        }
+    }
+
+    /* end marker */
+    rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
+    if (RT_FAILURE(rc))
+        return rc;
+    AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
+    return rc;
+}
+
+
+/**
+ * SSMR3GetStructEx helper that gets a HCPTR that is used as a NULL indicator.
+ *
+ * @returns VBox status code.
+ *
+ * @param   pSSM            The saved state handle.
+ * @param   ppv             Where to return the value (0/1).
+ * @param   fFlags          SSMSTRUCT_FLAGS_XXX.
+ */
+DECLINLINE(int) ssmR3GetHCPtrNI(PSSMHANDLE pSSM, void **ppv, uint32_t fFlags)
+{
+    uintptr_t uPtrNI;
+    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
+    {
+        if (ssmR3GetHostBits(pSSM) == 64)
+        {
+            uint64_t u;
+            int rc = tstDevSsmR3DataRead(pSSM, &u, sizeof(u));
+            if (RT_FAILURE(rc))
+                return rc;
+            uPtrNI = u ? 1 : 0;
+        }
+        else
+        {
+            uint32_t u;
+            int rc = tstDevSsmR3DataRead(pSSM, &u, sizeof(u));
+            if (RT_FAILURE(rc))
+                return rc;
+            uPtrNI = u ? 1 : 0;
+        }
+    }
+    else
+    {
+        bool f;
+        int rc = pdmR3DevHlp_SSMGetBool(pSSM, &f);
+        if (RT_FAILURE(rc))
+            return rc;
+        uPtrNI = f ? 1 : 0;
+    }
+    *ppv = (void *)uPtrNI;
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStructEx(PSSMHANDLE pSSM, void *pvStruct, size_t cbStruct, uint32_t fFlags, PCSSMFIELD paFields, void *pvUser)
+{
+    int         rc;
+    uint32_t    u32Magic;
+
+    /*
+     * Validation.
+     */
+    AssertMsgReturn(!(fFlags & ~SSMSTRUCT_FLAGS_VALID_MASK), ("%#x\n", fFlags), pSSM->rc = VERR_INVALID_PARAMETER);
+    AssertPtr(pvStruct);
+    AssertPtr(paFields);
+
+    /*
+     * Begin marker.
+     */
+    if (!(fFlags & (SSMSTRUCT_FLAGS_NO_MARKERS | SSMSTRUCT_FLAGS_NO_LEAD_MARKER)))
+    {
+        rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
+        if (RT_FAILURE(rc))
+            return rc;
+        AssertMsgReturn(u32Magic == SSMR3STRUCT_BEGIN, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
+    }
+
+    /*
+     * Put the fields
+     */
+    rc = VINF_SUCCESS;
+    uint32_t off = 0;
+    for (PCSSMFIELD pCur = paFields;
+         pCur->cb != UINT32_MAX && pCur->off != UINT32_MAX;
+         pCur++)
+    {
+        uint32_t const offField =    (!SSMFIELDTRANS_IS_PADDING(pCur->pfnGetPutOrTransformer) || pCur->off != UINT32_MAX / 2)
+                                  &&  !SSMFIELDTRANS_IS_OLD(pCur->pfnGetPutOrTransformer)
+                                ? pCur->off
+                                : off;
+        uint32_t const cbField  = SSMFIELDTRANS_IS_OLD(pCur->pfnGetPutOrTransformer)
+                                ? 0
+                                : SSMFIELDTRANS_IS_PADDING(pCur->pfnGetPutOrTransformer)
+                                ? RT_HIWORD(pCur->cb)
+                                : pCur->cb;
+        AssertMsgReturn(   cbField            <= cbStruct
+                        && offField + cbField <= cbStruct
+                        && offField + cbField >= offField,
+                        ("off=%#x cb=%#x cbStruct=%#x (%s)\n", cbField, offField, cbStruct, pCur->pszName),
+                        pSSM->rc = VERR_SSM_FIELD_OUT_OF_BOUNDS);
+        AssertMsgReturn(    !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
+                        || off == offField,
+                        ("off=%#x offField=%#x (%s)\n", off, offField, pCur->pszName),
+                        pSSM->rc = VERR_SSM_FIELD_NOT_CONSECUTIVE);
+
+        if (pCur->uFirstVer <= pSSM->uCurUnitVer)
+        {
+            rc = VINF_SUCCESS;
+            uint8_t       *pbField  = (uint8_t *)pvStruct + offField;
+            switch ((uintptr_t)pCur->pfnGetPutOrTransformer)
+            {
+                case SSMFIELDTRANS_NO_TRANSFORMATION:
+                    rc = tstDevSsmR3DataRead(pSSM, pbField, cbField);
+                    break;
+
+                case SSMFIELDTRANS_GCPHYS:
+                    AssertMsgBreakStmt(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMGetGCPhys(pSSM, (PRTGCPHYS)pbField);
+                    break;
+
+                case SSMFIELDTRANS_GCPTR:
+                    AssertMsgBreakStmt(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMGetGCPtr(pSSM, (PRTGCPTR)pbField);
+                    break;
+
+                case SSMFIELDTRANS_RCPTR:
+                    AssertMsgBreakStmt(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, (PRTRCPTR)pbField);
+                    break;
+
+                case SSMFIELDTRANS_RCPTR_ARRAY:
+                {
+                    uint32_t const cEntries = cbField / sizeof(RTRCPTR);
+                    AssertMsgBreakStmt(cbField == cEntries * sizeof(RTRCPTR) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = VINF_SUCCESS;
+                    for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
+                        rc = pdmR3DevHlp_SSMGetRCPtr(pSSM, &((PRTRCPTR)pbField)[i]);
+                    break;
+                }
+
+                case SSMFIELDTRANS_HCPTR_NI:
+                    AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = ssmR3GetHCPtrNI(pSSM, (void **)pbField, fFlags);
+                    break;
+
+                case SSMFIELDTRANS_HCPTR_NI_ARRAY:
+                {
+                    uint32_t const cEntries = cbField / sizeof(void *);
+                    AssertMsgBreakStmt(cbField == cEntries * sizeof(void *) && cEntries, ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = VINF_SUCCESS;
+                    for (uint32_t i = 0; i < cEntries && RT_SUCCESS(rc); i++)
+                        rc = ssmR3GetHCPtrNI(pSSM, &((void **)pbField)[i], fFlags);
+                    break;
+                }
+
+                case SSMFIELDTRANS_HCPTR_HACK_U32:
+                    AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    *(uintptr_t *)pbField = 0;
+                    rc = tstDevSsmR3DataRead(pSSM, pbField, sizeof(uint32_t));
+                    if ((fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE) && ssmR3GetHostBits(pSSM) == 64)
+                    {
+                        uint32_t u32;
+                        rc = tstDevSsmR3DataRead(pSSM, &u32, sizeof(uint32_t));
+                        AssertMsgBreakStmt(RT_FAILURE(rc) || u32 == 0 || (fFlags & SSMSTRUCT_FLAGS_SAVED_AS_MEM),
+                                           ("high=%#x low=%#x (%s)\n", u32, *(uint32_t *)pbField, pCur->pszName),
+                                           rc = VERR_SSM_FIELD_INVALID_VALUE);
+                    }
+                    break;
+
+                case SSMFIELDTRANS_U32_ZX_U64:
+                    AssertMsgBreakStmt(cbField == sizeof(uint64_t), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    ((uint32_t *)pbField)[1] = 0;
+                    rc = pdmR3DevHlp_SSMGetU32(pSSM, (uint32_t *)pbField);
+                    break;
+
+
+                case SSMFIELDTRANS_IGNORE:
+                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
+                        rc = pdmR3DevHlp_SSMSkip(pSSM, cbField);
+                    break;
+
+                case SSMFIELDTRANS_IGN_GCPHYS:
+                    AssertMsgBreakStmt(cbField == sizeof(RTGCPHYS), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
+                        rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPHYS));
+                    break;
+
+                case SSMFIELDTRANS_IGN_GCPTR:
+                    AssertMsgBreakStmt(cbField == sizeof(RTGCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
+                        rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPTR));
+                    break;
+
+                case SSMFIELDTRANS_IGN_RCPTR:
+                    AssertMsgBreakStmt(cbField == sizeof(RTRCPTR), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
+                        rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTRCPTR));
+                    break;
+
+                case SSMFIELDTRANS_IGN_HCPTR:
+                    AssertMsgBreakStmt(cbField == sizeof(void *), ("%#x (%s)\n", cbField, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
+                        rc = pdmR3DevHlp_SSMSkip(pSSM, ssmR3GetHostBits(pSSM) / 8);
+                    break;
+
+
+                case SSMFIELDTRANS_OLD:
+                    AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMSkip(pSSM, pCur->cb);
+                    break;
+
+                case SSMFIELDTRANS_OLD_GCPHYS:
+                    AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPHYS) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPHYS));
+                    break;
+
+                case SSMFIELDTRANS_OLD_GCPTR:
+                    AssertMsgBreakStmt(pCur->cb == sizeof(RTGCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTGCPTR));
+                    break;
+
+                case SSMFIELDTRANS_OLD_RCPTR:
+                    AssertMsgBreakStmt(pCur->cb == sizeof(RTRCPTR) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMSkip(pSSM, sizeof(RTRCPTR));
+                    break;
+
+                case SSMFIELDTRANS_OLD_HCPTR:
+                    AssertMsgBreakStmt(pCur->cb == sizeof(void *) && pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMSkip(pSSM, ssmR3GetHostBits(pSSM) / 8);
+                    break;
+
+                case SSMFIELDTRANS_OLD_PAD_HC:
+                    AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    rc = pdmR3DevHlp_SSMSkip(pSSM, ssmR3GetHostBits(pSSM) == 64 ? RT_HIWORD(pCur->cb) : RT_LOWORD(pCur->cb));
+                    break;
+
+                case SSMFIELDTRANS_OLD_PAD_MSC32:
+                    AssertMsgBreakStmt(pCur->off == UINT32_MAX / 2, ("%#x %#x (%s)\n", pCur->cb, pCur->off, pCur->pszName), rc = VERR_SSM_FIELD_INVALID_SIZE);
+                    if (ssmR3IsHostMsc32(pSSM))
+                        rc = pdmR3DevHlp_SSMSkip(pSSM, pCur->cb);
+                    break;
+
+
+                case SSMFIELDTRANS_PAD_HC:
+                case SSMFIELDTRANS_PAD_HC32:
+                case SSMFIELDTRANS_PAD_HC64:
+                case SSMFIELDTRANS_PAD_HC_AUTO:
+                case SSMFIELDTRANS_PAD_MSC32_AUTO:
+                {
+                    uint32_t cb32    = RT_BYTE1(pCur->cb);
+                    uint32_t cb64    = RT_BYTE2(pCur->cb);
+                    uint32_t cbCtx   =    HC_ARCH_BITS == 64
+                                       || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
+                                     ? cb64 : cb32;
+                    uint32_t cbSaved =    ssmR3GetHostBits(pSSM) == 64
+                                       || (   (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
+                                           && !ssmR3IsHostMsc32(pSSM))
+                                     ? cb64 : cb32;
+                    AssertMsgBreakStmt(    cbField == cbCtx
+                                       &&  (   (   pCur->off == UINT32_MAX / 2
+                                                && (   cbField == 0
+                                                    || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_HC_AUTO
+                                                    || (uintptr_t)pCur->pfnGetPutOrTransformer == SSMFIELDTRANS_PAD_MSC32_AUTO
+                                                   )
+                                               )
+                                            || (pCur->off != UINT32_MAX / 2 && cbField != 0)
+                                            )
+                                       , ("cbField=%#x cb32=%#x cb64=%#x HC_ARCH_BITS=%u cbCtx=%#x cbSaved=%#x off=%#x\n",
+                                          cbField, cb32, cb64, HC_ARCH_BITS, cbCtx, cbSaved, pCur->off),
+                                       rc = VERR_SSM_FIELD_INVALID_PADDING_SIZE);
+                    if (fFlags & SSMSTRUCT_FLAGS_DONT_IGNORE)
+                        rc = pdmR3DevHlp_SSMSkip(pSSM, cbSaved);
+                    break;
+                }
+
+                default:
+                    AssertBreakStmt(pCur->pfnGetPutOrTransformer, rc = VERR_SSM_FIELD_INVALID_CALLBACK);
+                    rc = pCur->pfnGetPutOrTransformer(pSSM, pCur, pvStruct, fFlags, true /*fGetOrPut*/, pvUser);
+                    break;
+            }
+            if (RT_FAILURE(rc))
+                break;
+        }
+
+        off = offField + cbField;
+    }
+
+    if (RT_SUCCESS(rc))
+        AssertMsgStmt(   !(fFlags & SSMSTRUCT_FLAGS_FULL_STRUCT)
+                      || off == cbStruct,
+                      ("off=%#x cbStruct=%#x\n", off, cbStruct),
+                      rc = VERR_SSM_FIELD_NOT_CONSECUTIVE);
+
+    if (RT_FAILURE(rc))
+    {
+        if (RT_SUCCESS(pSSM->rc))
+            pSSM->rc = rc;
+        return rc;
+    }
+
+    /*
+     * End marker
+     */
+    if (!(fFlags & (SSMSTRUCT_FLAGS_NO_MARKERS | SSMSTRUCT_FLAGS_NO_TAIL_MARKER)))
+    {
+        rc = pdmR3DevHlp_SSMGetU32(pSSM, &u32Magic);
+        if (RT_FAILURE(rc))
+            return rc;
+        AssertMsgReturn(u32Magic == SSMR3STRUCT_END, ("u32Magic=%#RX32\n", u32Magic), pSSM->rc = VERR_SSM_STRUCTURE_MAGIC);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMSkipToEndOfUnit(PSSMHANDLE pSSM)
+{
+    RT_NOREF(pSSM);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMSetLoadError(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(6, 7)
+{
+    RT_NOREF(pSSM, rc, RT_SRC_POS_ARGS, pszFormat);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMSetLoadErrorV(PSSMHANDLE pSSM, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(6, 0)
+{
+    RT_NOREF(pSSM, rc, RT_SRC_POS_ARGS, pszFormat, va);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMSetCfgError(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, ...) RT_IPRT_FORMAT_ATTR(5, 6)
+{
+    RT_NOREF(pSSM, RT_SRC_POS_ARGS, pszFormat);
+    pSSM->rc = VERR_SSM_LOAD_CONFIG_MISMATCH;
+    return pSSM->rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMSetCfgErrorV(PSSMHANDLE pSSM, RT_SRC_POS_DECL, const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(5, 0)
+{
+    RT_NOREF(pSSM, RT_SRC_POS_ARGS, pszFormat, va);
+    pSSM->rc = VERR_SSM_LOAD_CONFIG_MISMATCH;
+    return pSSM->rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMHandleGetStatus(PSSMHANDLE pSSM)
+{
+    RT_NOREF(pSSM);
+    return pSSM->rc;
+}
+
+
+static DECLCALLBACK(SSMAFTER) pdmR3DevHlp_SSMHandleGetAfter(PSSMHANDLE pSSM)
+{
+    RT_NOREF(pSSM);
+    AssertFailed();
+    return SSMAFTER_INVALID;
+}
+
+
+static DECLCALLBACK(bool) pdmR3DevHlp_SSMHandleIsLiveSave(PSSMHANDLE pSSM)
+{
+    RT_NOREF(pSSM);
+    AssertFailed();
+    return false;
+}
+
+
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleMaxDowntime(PSSMHANDLE pSSM)
+{
+    RT_NOREF(pSSM);
+    AssertFailed();
+    return 0;
+}
+
+
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleHostBits(PSSMHANDLE pSSM)
+{
+    RT_NOREF(pSSM);
+    AssertFailed();
+    return 0;
+}
+
+
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleRevision(PSSMHANDLE pSSM)
+{
+    RT_NOREF(pSSM);
+    AssertFailed();
+    return 0;
+}
+
+
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_SSMHandleVersion(PSSMHANDLE pSSM)
+{
+    RT_NOREF(pSSM);
+    AssertFailed();
+    return 0;
+}
+
+
+static DECLCALLBACK(const char *) pdmR3DevHlp_SSMHandleHostOSAndArch(PSSMHANDLE pSSM)
+{
+    RT_NOREF(pSSM);
+    AssertFailed();
+    return NULL;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerCreate} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
+                                                 void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} phTimer=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, phTimer));
+
+    int rc = VINF_SUCCESS;
+    PTMTIMERR3 pTimer = (PTMTIMERR3)RTMemAllocZ(sizeof(TMTIMER));
+    if (RT_LIKELY(pTimer))
+    {
+        pTimer->enmClock       = enmClock;
+        pTimer->pfnCallbackDev = pfnCallback;
+        pTimer->pvUser         = pvUser;
+        pTimer->fFlags         = fFlags;
+        RTListAppend(&pDevIns->Internal.s.pDut->LstTimers, &pTimer->NdDevTimers);
+        *phTimer = (TMTIMERHANDLE)pTimer;
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerFromMicro} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
+{
+    RT_NOREF(pDevIns, hTimer, cMicroSecs);
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerFromMilli} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromMilli(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliSecs)
+{
+    RT_NOREF(pDevIns, hTimer, cMilliSecs);
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerFromNano} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
+{
+    RT_NOREF(pDevIns, hTimer, cNanoSecs);
+    AssertFailed();
+    return 0;
+}
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerGet} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    RT_NOREF(pDevIns, hTimer);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    AssertFailed();
+    return 0;
+#else
+    static uint64_t cCnt = 0;
+    return cCnt++;
+#endif
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerGetFreq} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    PTMTIMERR3 pTimer = (PTMTIMERR3)hTimer;
+    switch (pTimer->enmClock)
+    {
+        case TMCLOCK_VIRTUAL:
+        case TMCLOCK_VIRTUAL_SYNC:
+            return TMCLOCK_FREQ_VIRTUAL;
+
+        case TMCLOCK_REAL:
+            return TMCLOCK_FREQ_REAL;
+
+        default:
+            AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
+            return 0;
+    }
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerGetNano} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    RT_NOREF(pDevIns, hTimer);
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerIsActive} */
+static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    RT_NOREF(pDevIns, hTimer);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    AssertFailed();
+    return false;
+#else
+    return true;
+#endif
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerIsLockOwner} */
+static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    RT_NOREF(pDevIns, hTimer);
+    AssertFailed();
+    return false;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerLockClock} */
+static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_TimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy)
+{
+    RT_NOREF(pDevIns, hTimer, rcBusy);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerLockClock2} */
+static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_TimerLockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer,
+                                                              PPDMCRITSECT pCritSect, int rcBusy)
+{
+    RT_NOREF(pDevIns, hTimer, pCritSect, rcBusy);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSet} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
+{
+    RT_NOREF(pDevIns, hTimer, uExpire);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetFrequencyHint} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz)
+{
+    RT_NOREF(pDevIns, hTimer, uHz);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetMicro} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
+{
+    RT_NOREF(pDevIns, hTimer, cMicrosToNext);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetMillies} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
+{
+    RT_NOREF(pDevIns, hTimer, cMilliesToNext);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetNano} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
+{
+    RT_NOREF(pDevIns, hTimer, cNanosToNext);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetRelative} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
+{
+    RT_NOREF(pDevIns, hTimer, cTicksToNext, pu64Now);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerStop} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    RT_NOREF(pDevIns, hTimer);
+
+#if 1 /** @todo */
+    int rc = VINF_SUCCESS;
+#else
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#endif
+
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerUnlockClock} */
+static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    RT_NOREF(pDevIns, hTimer);
+    AssertFailed();
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerUnlockClock2} */
+static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
+{
+    RT_NOREF(pDevIns, hTimer, pCritSect);
+    AssertFailed();
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetCritSect} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSetCritSect(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    PTMTIMERR3 pTimer = (PTMTIMERR3)hTimer;
+    pTimer->pCritSect = pCritSect;
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSave} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSave(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
+{
+    RT_NOREF(pDevIns, hTimer, pSSM);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerLoad} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerLoad(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
+{
+    RT_NOREF(pDevIns, hTimer);
+
+/** @name Saved state values (comes directly from TM.cpp)
+ * @{ */
+#define TMTIMERSTATE_SAVED_PENDING_STOP         4
+#define TMTIMERSTATE_SAVED_PENDING_SCHEDULE     7
+/** @}  */
+
+    /*
+     * Load the state and validate it.
+     */
+    uint8_t u8State;
+    int rc = pdmR3DevHlp_SSMGetU8(pSSM, &u8State);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    /* TMTIMERSTATE_SAVED_XXX: Workaround for accidental state shift in r47786 (2009-05-26 19:12:12). */
+    if (    u8State == TMTIMERSTATE_SAVED_PENDING_STOP + 1
+        ||  u8State == TMTIMERSTATE_SAVED_PENDING_SCHEDULE + 1)
+        u8State--;
+
+    if (    u8State != TMTIMERSTATE_SAVED_PENDING_STOP
+        &&  u8State != TMTIMERSTATE_SAVED_PENDING_SCHEDULE)
+    {
+        /*AssertLogRelMsgFailed(("u8State=%d\n", u8State));*/
+        return VERR_TM_LOAD_STATE;
+    }
+
+    if (u8State == TMTIMERSTATE_SAVED_PENDING_SCHEDULE)
+    {
+        /*
+         * Load the expire time.
+         */
+        uint64_t u64Expire;
+        rc = pdmR3DevHlp_SSMGetU64(pSSM, &u64Expire);
+        if (RT_FAILURE(rc))
+            return rc;
+
+        /*
+         * Set it.
+         */
+        Log(("u8State=%d u64Expire=%llu\n", u8State, u64Expire));
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerDestroy} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerDestroy(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    RT_NOREF(pDevIns, hTimer);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSkipLoad(PSSMHANDLE pSSM, bool *pfActive)
+{
+    RT_NOREF(pSSM, pfActive);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTMUtcNow} */
+static DECLCALLBACK(PRTTIMESPEC) pdmR3DevHlp_TMUtcNow(PPDMDEVINS pDevIns, PRTTIMESPEC pTime)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: pTime=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pTime));
+
+    RT_NOREF(pDevIns, pTime);
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
+    return pTime;
+}
+
+
+static DECLCALLBACK(bool) pdmR3DevHlp_CFGMExists(PCFGMNODE pNode, const char *pszName)
+{
+    RT_NOREF(pNode, pszName);
+    AssertFailed();
+    return false;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryType(PCFGMNODE pNode, const char *pszName, PCFGMVALUETYPE penmType)
+{
+    RT_NOREF(pNode, pszName, penmType);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQuerySize(PCFGMNODE pNode, const char *pszName, size_t *pcb)
+{
+    if (!pNode)
+        return VERR_CFGM_NO_PARENT;
+
+    PCTSTDEVCFGITEM pCfgItem;
+    int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTest->paCfgItems, pNode->pDut->pTest->cCfgItems, pszName, &pCfgItem);
+    if (RT_SUCCESS(rc))
+    {
+        switch (pCfgItem->enmType)
+        {
+            case TSTDEVCFGITEMTYPE_INTEGER:
+                *pcb = sizeof(uint64_t);
+                break;
+
+            case TSTDEVCFGITEMTYPE_STRING:
+                *pcb = strlen(pCfgItem->u.psz) + 1;
+                break;
+
+            case TSTDEVCFGITEMTYPE_BYTES:
+                AssertFailed();
+                break;
+
+            default:
+                rc = VERR_CFGM_IPE_1;
+                AssertMsgFailed(("Invalid value type %d\n", pCfgItem->enmType));
+                break;
+        }
+    }
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryInteger(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
+{
+    if (!pNode)
+        return VERR_CFGM_NO_PARENT;
+
+    PCTSTDEVCFGITEM pCfgItem;
+    int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTest->paCfgItems, pNode->pDut->pTest->cCfgItems, pszName, &pCfgItem);
+    if (RT_SUCCESS(rc))
+    {
+        if (pCfgItem->enmType == TSTDEVCFGITEMTYPE_INTEGER)
+            *pu64 = (uint64_t)pCfgItem->u.i64;
+        else
+            rc = VERR_CFGM_NOT_INTEGER;
+    }
+
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryIntegerDef(PCFGMNODE pNode, const char *pszName, uint64_t *pu64, uint64_t u64Def)
+{
+    int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, pu64);
+    if (RT_FAILURE(rc))
+    {
+        *pu64 = u64Def;
+        if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
+            rc = VINF_SUCCESS;
+    }
+
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryString(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString)
+{
+    if (!pNode)
+        return VERR_CFGM_NO_PARENT;
+
+    PCTSTDEVCFGITEM pCfgItem;
+    int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTest->paCfgItems, pNode->pDut->pTest->cCfgItems, pszName, &pCfgItem);
+    if (RT_SUCCESS(rc))
+    {
+        switch (pCfgItem->enmType)
+        {
+            case TSTDEVCFGITEMTYPE_STRING:
+            {
+                size_t cchVal = strlen(pCfgItem->u.psz);
+                if (cchString <= cchVal + 1)
+                    memcpy(pszString, pCfgItem->u.psz, cchVal);
+                else
+                    rc = VERR_CFGM_NOT_ENOUGH_SPACE;
+                break;
+            }
+            case TSTDEVCFGITEMTYPE_INTEGER:
+            case TSTDEVCFGITEMTYPE_BYTES:
+            default:
+                rc = VERR_CFGM_IPE_1;
+                AssertMsgFailed(("Invalid value type %d\n", pCfgItem->enmType));
+                break;
+        }
+    }
+    else
+        rc = VERR_CFGM_VALUE_NOT_FOUND;
+
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringDef(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString, const char *pszDef)
+{
+    int rc = pdmR3DevHlp_CFGMQueryString(pNode, pszName, pszString, cchString);
+    if (RT_FAILURE(rc) && rc != VERR_CFGM_NOT_ENOUGH_SPACE)
+    {
+        size_t cchDef = strlen(pszDef);
+        if (cchString > cchDef)
+        {
+            memcpy(pszString, pszDef, cchDef);
+            memset(pszString + cchDef, 0, cchString - cchDef);
+            if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
+                rc = VINF_SUCCESS;
+        }
+        else if (rc == VERR_CFGM_VALUE_NOT_FOUND || rc == VERR_CFGM_NO_PARENT)
+            rc = VERR_CFGM_NOT_ENOUGH_SPACE;
+    }
+
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPassword(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString)
+{
+    return pdmR3DevHlp_CFGMQueryString(pNode, pszName, pszString, cchString);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPasswordDef(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString, const char *pszDef)
+{
+    return pdmR3DevHlp_CFGMQueryStringDef(pNode, pszName, pszString, cchString, pszDef);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBytes(PCFGMNODE pNode, const char *pszName, void *pvData, size_t cbData)
+{
+    RT_NOREF(pNode, pszName, pvData, cbData);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+#else
+    memset(pvData, 0, cbData);
+    return VINF_SUCCESS;
+#endif
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU64(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
+{
+    return pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, pu64);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU64Def(PCFGMNODE pNode, const char *pszName, uint64_t *pu64, uint64_t u64Def)
+{
+    return pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, pu64, u64Def);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS64(PCFGMNODE pNode, const char *pszName, int64_t *pi64)
+{
+    RT_NOREF(pNode, pszName, pi64);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS64Def(PCFGMNODE pNode, const char *pszName, int64_t *pi64, int64_t i64Def)
+{
+    RT_NOREF(pNode, pszName, pi64, i64Def);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU32(PCFGMNODE pNode, const char *pszName, uint32_t *pu32)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
+    if (RT_SUCCESS(rc))
+    {
+        if (!(u64 & UINT64_C(0xffffffff00000000)))
+            *pu32 = (uint32_t)u64;
+        else
+            rc = VERR_CFGM_INTEGER_TOO_BIG;
+    }
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU32Def(PCFGMNODE pNode, const char *pszName, uint32_t *pu32, uint32_t u32Def)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, u32Def);
+    if (RT_SUCCESS(rc))
+    {
+        if (!(u64 & UINT64_C(0xffffffff00000000)))
+            *pu32 = (uint32_t)u64;
+        else
+            rc = VERR_CFGM_INTEGER_TOO_BIG;
+    }
+    if (RT_FAILURE(rc))
+        *pu32 = u32Def;
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS32(PCFGMNODE pNode, const char *pszName, int32_t *pi32)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
+    if (RT_SUCCESS(rc))
+    {
+        if (   !(u64 & UINT64_C(0xffffffff80000000))
+            ||  (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
+            *pi32 = (int32_t)u64;
+        else
+            rc = VERR_CFGM_INTEGER_TOO_BIG;
+    }
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS32Def(PCFGMNODE pNode, const char *pszName, int32_t *pi32, int32_t i32Def)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, i32Def);
+    if (RT_SUCCESS(rc))
+    {
+        if (   !(u64 & UINT64_C(0xffffffff80000000))
+            ||  (u64 & UINT64_C(0xffffffff80000000)) == UINT64_C(0xffffffff80000000))
+            *pi32 = (int32_t)u64;
+        else
+            rc = VERR_CFGM_INTEGER_TOO_BIG;
+    }
+    if (RT_FAILURE(rc))
+        *pi32 = i32Def;
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU16(PCFGMNODE pNode, const char *pszName, uint16_t *pu16)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
+    if (RT_SUCCESS(rc))
+    {
+        if (!(u64 & UINT64_C(0xffffffffffff0000)))
+            *pu16 = (int16_t)u64;
+        else
+            rc = VERR_CFGM_INTEGER_TOO_BIG;
+    }
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU16Def(PCFGMNODE pNode, const char *pszName, uint16_t *pu16, uint16_t u16Def)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, u16Def);
+    if (RT_SUCCESS(rc))
+    {
+        if (!(u64 & UINT64_C(0xffffffffffff0000)))
+            *pu16 = (int16_t)u64;
+        else
+            rc = VERR_CFGM_INTEGER_TOO_BIG;
+    }
+    if (RT_FAILURE(rc))
+        *pu16 = u16Def;
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS16(PCFGMNODE pNode, const char *pszName, int16_t *pi16)
+{
+    RT_NOREF(pNode, pszName, pi16);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS16Def(PCFGMNODE pNode, const char *pszName, int16_t *pi16, int16_t i16Def)
+{
+    RT_NOREF(pNode, pszName, pi16, i16Def);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU8(PCFGMNODE pNode, const char *pszName, uint8_t *pu8)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
+    if (RT_SUCCESS(rc))
+    {
+        if (!(u64 & UINT64_C(0xffffffffffffff00)))
+            *pu8 = (uint8_t)u64;
+        else
+            rc = VERR_CFGM_INTEGER_TOO_BIG;
+    }
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU8Def(PCFGMNODE pNode, const char *pszName, uint8_t *pu8, uint8_t u8Def)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, u8Def);
+    if (RT_SUCCESS(rc))
+    {
+        if (!(u64 & UINT64_C(0xffffffffffffff00)))
+            *pu8 = (uint8_t)u64;
+        else
+            rc = VERR_CFGM_INTEGER_TOO_BIG;
+    }
+    if (RT_FAILURE(rc))
+        *pu8 = u8Def;
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS8(PCFGMNODE pNode, const char *pszName, int8_t *pi8)
+{
+    RT_NOREF(pNode, pszName, pi8);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS8Def(PCFGMNODE pNode, const char *pszName, int8_t *pi8, int8_t i8Def)
+{
+    RT_NOREF(pNode, pszName, pi8, i8Def);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBool(PCFGMNODE pNode, const char *pszName, bool *pf)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
+    if (RT_SUCCESS(rc))
+        *pf = u64 ? true : false;
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBoolDef(PCFGMNODE pNode, const char *pszName, bool *pf, bool fDef)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryIntegerDef(pNode, pszName, &u64, fDef);
+    *pf = u64 ? true : false;
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPort(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort)
+{
+    RT_NOREF(pNode, pszName, pPort);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPortDef(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort, RTIOPORT PortDef)
+{
+    AssertCompileSize(RTIOPORT, 2);
+    return pdmR3DevHlp_CFGMQueryU16Def(pNode, pszName, pPort, PortDef);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryUInt(PCFGMNODE pNode, const char *pszName, unsigned int *pu)
+{
+    RT_NOREF(pNode, pszName, pu);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryUIntDef(PCFGMNODE pNode, const char *pszName, unsigned int *pu, unsigned int uDef)
+{
+    RT_NOREF(pNode, pszName, pu, uDef);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQuerySInt(PCFGMNODE pNode, const char *pszName, signed int *pi)
+{
+    RT_NOREF(pNode, pszName, pi);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQuerySIntDef(PCFGMNODE pNode, const char *pszName, signed int *pi, signed int iDef)
+{
+    RT_NOREF(pNode, pszName, pi, iDef);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPtr(PCFGMNODE pNode, const char *pszName, void **ppv)
+{
+    uint64_t u64;
+    int rc = pdmR3DevHlp_CFGMQueryInteger(pNode, pszName, &u64);
+    if (RT_SUCCESS(rc))
+    {
+        uintptr_t u = (uintptr_t)u64;
+        if (u64 == u)
+            *ppv = (void *)u;
+        else
+            rc = VERR_CFGM_INTEGER_TOO_BIG;
+    }
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryPtrDef(PCFGMNODE pNode, const char *pszName, void **ppv, void *pvDef)
+{
+    RT_NOREF(pNode, pszName, ppv, pvDef);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtr(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr)
+{
+    RT_NOREF(pNode, pszName, pGCPtr);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrDef(PCFGMNODE pNode, const char *pszName, PRTGCPTR pGCPtr, RTGCPTR GCPtrDef)
+{
+    RT_NOREF(pNode, pszName, pGCPtr, GCPtrDef);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrU(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr)
+{
+    RT_NOREF(pNode, pszName, pGCPtr);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrUDef(PCFGMNODE pNode, const char *pszName, PRTGCUINTPTR pGCPtr, RTGCUINTPTR GCPtrDef)
+{
+    RT_NOREF(pNode, pszName, pGCPtr, GCPtrDef);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrS(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr)
+{
+    RT_NOREF(pNode, pszName, pGCPtr);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryGCPtrSDef(PCFGMNODE pNode, const char *pszName, PRTGCINTPTR pGCPtr, RTGCINTPTR GCPtrDef)
+{
+    RT_NOREF(pNode, pszName, pGCPtr, GCPtrDef);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringAlloc(PCFGMNODE pNode, const char *pszName, char **ppszString)
+{
+    if (!pNode)
+        return VERR_CFGM_NO_PARENT;
+
+    PCTSTDEVCFGITEM pCfgItem;
+    int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTest->paCfgItems, pNode->pDut->pTest->cCfgItems, pszName, &pCfgItem);
+    if (RT_SUCCESS(rc))
+    {
+        switch (pCfgItem->enmType)
+        {
+            case TSTDEVCFGITEMTYPE_STRING:
+            {
+                *ppszString = (char *)RTMemDup(pCfgItem->u.psz, strlen(pCfgItem->u.psz) + 1);
+                if (RT_LIKELY(*ppszString))
+                    rc = VINF_SUCCESS;
+                else
+                    rc = VERR_NO_STR_MEMORY;
+                break;
+            }
+            case TSTDEVCFGITEMTYPE_INTEGER:
+            case TSTDEVCFGITEMTYPE_BYTES:
+            default:
+                rc = VERR_CFGM_IPE_1;
+                AssertMsgFailed(("Invalid value type %d\n", pCfgItem->enmType));
+                break;
+        }
+    }
+    else
+        rc = VERR_CFGM_VALUE_NOT_FOUND;
+
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringAllocDef(PCFGMNODE pNode, const char *pszName, char **ppszString, const char *pszDef)
+{
+    if (!pNode)
+        return VERR_CFGM_NO_PARENT;
+
+    PCTSTDEVCFGITEM pCfgItem;
+    int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTest->paCfgItems, pNode->pDut->pTest->cCfgItems, pszName, &pCfgItem);
+    if (RT_SUCCESS(rc))
+    {
+        switch (pCfgItem->enmType)
+        {
+            case TSTDEVCFGITEMTYPE_STRING:
+            {
+                *ppszString = (char *)RTMemDup(pCfgItem->u.psz, strlen(pCfgItem->u.psz) + 1);
+                if (RT_LIKELY(*ppszString))
+                    rc = VINF_SUCCESS;
+                else
+                    rc = VERR_NO_STR_MEMORY;
+                break;
+            }
+            case TSTDEVCFGITEMTYPE_INTEGER:
+            case TSTDEVCFGITEMTYPE_BYTES:
+            default:
+                rc = VERR_CFGM_IPE_1;
+                AssertMsgFailed(("Invalid value type %d\n", pCfgItem->enmType));
+                break;
+        }
+    }
+    else
+    {
+        if (pszDef)
+        {
+            *ppszString = (char *)RTMemDup(pszDef, strlen(pszDef) + 1);
+            if (RT_LIKELY(*ppszString))
+                rc = VINF_SUCCESS;
+            else
+                rc = VERR_NO_STR_MEMORY;
+        }
+        else
+        {
+            *ppszString = NULL;
+            rc = VINF_SUCCESS;
+        }
+    }
+
+    return rc;
+}
+
+
+static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetParent(PCFGMNODE pNode)
+{
+    RT_NOREF(pNode);
+    AssertFailed();
+    return NULL;
+}
+
+
+static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetChild(PCFGMNODE pNode, const char *pszPath)
+{
+    RT_NOREF(pNode, pszPath);
+    AssertFailed();
+    return NULL;
+}
+
+
+static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetChildF(PCFGMNODE pNode, const char *pszPathFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3)
+{
+    RT_NOREF(pNode, pszPathFormat);
+    AssertFailed();
+    return NULL;
+}
+
+
+static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetChildFV(PCFGMNODE pNode, const char *pszPathFormat, va_list Args) RT_IPRT_FORMAT_ATTR(3, 0)
+{
+    RT_NOREF(pNode, pszPathFormat, Args);
+    AssertFailed();
+    return NULL;
+}
+
+
+static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetFirstChild(PCFGMNODE pNode)
+{
+    RT_NOREF(pNode);
+    AssertFailed();
+    return NULL;
+}
+
+
+static DECLCALLBACK(PCFGMNODE) pdmR3DevHlp_CFGMGetNextChild(PCFGMNODE pCur)
+{
+    RT_NOREF(pCur);
+    AssertFailed();
+    return NULL;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMGetName(PCFGMNODE pCur, char *pszName, size_t cchName)
+{
+    RT_NOREF(pCur, pszName, cchName);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(size_t) pdmR3DevHlp_CFGMGetNameLen(PCFGMNODE pCur)
+{
+    RT_NOREF(pCur);
+    AssertFailed();
+    return 0;
+}
+
+
+static DECLCALLBACK(bool) pdmR3DevHlp_CFGMAreChildrenValid(PCFGMNODE pNode, const char *pszzValid)
+{
+    RT_NOREF(pNode, pszzValid);
+    AssertFailed();
+    return false;
+}
+
+
+static DECLCALLBACK(PCFGMLEAF) pdmR3DevHlp_CFGMGetFirstValue(PCFGMNODE pCur)
+{
+    RT_NOREF(pCur);
+    AssertFailed();
+    return NULL;
+}
+
+
+static DECLCALLBACK(PCFGMLEAF) pdmR3DevHlp_CFGMGetNextValue(PCFGMLEAF pCur)
+{
+    RT_NOREF(pCur);
+    AssertFailed();
+    return NULL;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMGetValueName(PCFGMLEAF pCur, char *pszName, size_t cchName)
+{
+    RT_NOREF(pCur, pszName, cchName);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(size_t) pdmR3DevHlp_CFGMGetValueNameLen(PCFGMLEAF pCur)
+{
+    RT_NOREF(pCur);
+    AssertFailed();
+    return 0;
+}
+
+
+static DECLCALLBACK(CFGMVALUETYPE) pdmR3DevHlp_CFGMGetValueType(PCFGMLEAF pCur)
+{
+    RT_NOREF(pCur);
+    AssertFailed();
+    return CFGMVALUETYPE_INTEGER;
+}
+
+
+static DECLCALLBACK(bool) pdmR3DevHlp_CFGMAreValuesValid(PCFGMNODE pNode, const char *pszzValid)
+{
+    if (pNode && pNode->pDut->pTest->paCfgItems)
+    {
+        PCTSTDEVCFGITEM pDevCfgItem = pNode->pDut->pTest->paCfgItems;
+        for (uint32_t i = 0; i < pNode->pDut->pTest->cCfgItems; i++)
+        {
+            size_t cchKey = strlen(pDevCfgItem->pszKey);
+
+            /* search pszzValid for the name */
+            const char *psz = pszzValid;
+            while (*psz)
+            {
+                size_t cch = strlen(psz);
+                if (    cch == cchKey
+                    &&  !memcmp(psz, pDevCfgItem->pszKey, cch))
+                    break;
+
+                /* next */
+                psz += cch + 1;
+            }
+
+            /* if at end of pszzValid we didn't find it => failure */
+            if (!*psz)
+                return false;
+
+            pDevCfgItem++;
+        }
+    }
+
+    return true;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMValidateConfig(PCFGMNODE pNode, const char *pszNode,
+                                                        const char *pszValidValues, const char *pszValidNodes,
+                                                        const char *pszWho, uint32_t uInstance)
+{
+    RT_NOREF(pNode, pszNode, pszValidValues, pszValidNodes, pszWho, uInstance);
+#if 1
+    return VINF_SUCCESS;
+#else
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+#endif
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGet} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGet(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_TMTimeVirtGet: caller='%s'/%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    uint64_t u64Time = 0;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_TMTimeVirtGet: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Time));
+    return u64Time;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGetFreq} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGetFreq(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_TMTimeVirtGetFreq: caller='%s'/%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    uint64_t u64Freq = 0;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_TMTimeVirtGetFreq: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Freq));
+    return u64Freq;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGetNano} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGetNano(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    uint64_t u64Nano = RTTimeNanoTS();
+
+    LogFlow(("pdmR3DevHlp_TMTimeVirtGetNano: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Nano));
+    return u64Nano;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTMCpuTicksPerSecond} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMCpuTicksPerSecond(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_TMCpuTicksPerSecond: caller='%s'/%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    AssertFailed();
+    uint64_t u64CpuTicksPerSec = 0;
+
+    LogFlow(("pdmR3DevHlp_TMCpuTicksPerSecond: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64CpuTicksPerSec));
+    return u64CpuTicksPerSec;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnGetSupDrvSession} */
+static DECLCALLBACK(PSUPDRVSESSION) pdmR3DevHlp_GetSupDrvSession(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    PSUPDRVSESSION pSession = NIL_RTR0PTR;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d: returns %#p\n", pDevIns->pReg->szName, pDevIns->iInstance, pSession));
+    return pSession;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnQueryGenericUserObject} */
+static DECLCALLBACK(void *) pdmR3DevHlp_QueryGenericUserObject(PPDMDEVINS pDevIns, PCRTUUID pUuid)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_QueryGenericUserObject: caller='%s'/%d: pUuid=%p:%RTuuid\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pUuid, pUuid));
+
+#if defined(DEBUG_bird) || defined(DEBUG_ramshankar) || defined(DEBUG_sunlover) || defined(DEBUG_michael) || defined(DEBUG_andy)
+    AssertMsgFailed(("'%s' wants %RTuuid - external only interface!\n", pDevIns->pReg->szName, pUuid));
+#endif
+
+    void *pvRet = NULL;
+    AssertFailed();
+
+    LogRel(("pdmR3DevHlp_QueryGenericUserObject: caller='%s'/%d: returns %#p for %RTuuid\n",
+            pDevIns->pReg->szName, pDevIns->iInstance, pvRet, pUuid));
+    return pvRet;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalTypeRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalTypeRegister(PPDMDEVINS pDevIns, PGMPHYSHANDLERKIND enmKind,
+                                                                    R3PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR3,
+                                                                    const char *pszHandlerR0, const char *pszPfHandlerR0,
+                                                                    const char *pszHandlerRC, const char *pszPfHandlerRC,
+                                                                    const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(enmKind, pfnHandlerR3, pszHandlerR0, pszPfHandlerR0, pszHandlerRC, pszPfHandlerRC, pszDesc, phType);
+    LogFlow(("pdmR3DevHlp_PGMHandlerPhysicalTypeRegister: caller='%s'/%d: enmKind=%d pfnHandlerR3=%p pszHandlerR0=%p:{%s} pszPfHandlerR0=%p:{%s} pszHandlerRC=%p:{%s} pszPfHandlerRC=%p:{%s} pszDesc=%p:{%s} phType=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pfnHandlerR3,
+             pszHandlerR0, pszHandlerR0, pszPfHandlerR0, pszPfHandlerR0,
+             pszHandlerRC, pszHandlerRC, pszPfHandlerRC, pszPfHandlerRC,
+             pszDesc, pszDesc, phType));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogRel(("pdmR3DevHlp_PGMHandlerPhysicalTypeRegister: caller='%s'/%d: returns %Rrc\n",
+            pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysRead} */
+static DECLCALLBACK(int) pdmR3DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, uint32_t fFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x fFlags=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead, fFlags));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    RTRandBytes(pvBuf, cbRead);
+    VBOXSTRICTRC rcStrict = VINF_SUCCESS;
+#endif
+
+    Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
+    return VBOXSTRICTRC_VAL(rcStrict);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWrite} */
+static DECLCALLBACK(int) pdmR3DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, uint32_t fFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#xfFlags=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite, fFlags));
+
+    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;;
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
+    return VBOXSTRICTRC_VAL(rcStrict);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtr} */
+static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtr(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, void **ppv, PPGMPAGEMAPLOCK pLock)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
+
+    int rc = VERR_NOT_IMPLEMENTED;;
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPhys2CCPtrReadOnly} */
+static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, uint32_t fFlags, const void **ppv, PPGMPAGEMAPLOCK pLock)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
+
+    int rc = VERR_NOT_IMPLEMENTED;;
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReleasePageMappingLock} */
+static DECLCALLBACK(void) pdmR3DevHlp_PhysReleasePageMappingLock(PPDMDEVINS pDevIns, PPGMPAGEMAPLOCK pLock)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: pLock=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pLock));
+
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkGCPhys2CCPtr} */
+static DECLCALLBACK(int) pdmR3DevHlp_PhysBulkGCPhys2CCPtr(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
+                                                          uint32_t fFlags, void **papvPages, PPGMPAGEMAPLOCK paLocks)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysBulkGCPhys2CCPtr: caller='%s'/%d: cPages=%#x paGCPhysPages=%p (%RGp,..) fFlags=%#x papvPages=%p paLocks=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, cPages, paGCPhysPages, paGCPhysPages[0], fFlags, papvPages, paLocks));
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
+    AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
+
+    int rc = VERR_NOT_IMPLEMENTED;;
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_PhysBulkGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkGCPhys2CCPtrReadOnly} */
+static DECLCALLBACK(int) pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, uint32_t cPages, PCRTGCPHYS paGCPhysPages,
+                                                                  uint32_t fFlags, const void **papvPages, PPGMPAGEMAPLOCK paLocks)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly: caller='%s'/%d: cPages=%#x paGCPhysPages=%p (%RGp,...) fFlags=%#x papvPages=%p paLocks=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, cPages, paGCPhysPages, paGCPhysPages[0], fFlags, papvPages, paLocks));
+    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
+    AssertReturn(cPages > 0, VERR_INVALID_PARAMETER);
+
+    int rc = VERR_NOT_IMPLEMENTED;;
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysBulkReleasePageMappingLocks} */
+static DECLCALLBACK(void) pdmR3DevHlp_PhysBulkReleasePageMappingLocks(PPDMDEVINS pDevIns, uint32_t cPages, PPGMPAGEMAPLOCK paLocks)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysBulkReleasePageMappingLocks: caller='%s'/%d: cPages=%#x paLocks=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, cPages, paLocks));
+    Assert(cPages > 0);
+
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_PhysBulkReleasePageMappingLocks: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysIsGCPhysNormal} */
+static DECLCALLBACK(bool) pdmR3DevHlp_PhysIsGCPhysNormal(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysIsGCPhysNormal: caller='%s'/%d: GCPhys=%RGp\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
+
+    bool fNormal = true;
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_PhysIsGCPhysNormal: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance, fNormal));
+    return fNormal;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysChangeMemBalloon} */
+static DECLCALLBACK(int) pdmR3DevHlp_PhysChangeMemBalloon(PPDMDEVINS pDevIns, bool fInflate, unsigned cPages, RTGCPHYS *paPhysPage)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysChangeMemBalloon: caller='%s'/%d: fInflate=%RTbool cPages=%u paPhysPage=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, fInflate, cPages, paPhysPage));
+
+    int rc = VERR_NOT_IMPLEMENTED;;
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_PhysChangeMemBalloon: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCpuGetGuestMicroarch} */
+static DECLCALLBACK(CPUMMICROARCH) pdmR3DevHlp_CpuGetGuestMicroarch(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_CpuGetGuestMicroarch: caller='%s'/%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    CPUMMICROARCH enmMicroarch = kCpumMicroarch_Intel_P6;
+
+    Log(("pdmR3DevHlp_CpuGetGuestMicroarch: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, enmMicroarch));
+    return enmMicroarch;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCpuGetGuestAddrWidths} */
+static DECLCALLBACK(void) pdmR3DevHlp_CpuGetGuestAddrWidths(PPDMDEVINS pDevIns, uint8_t *pcPhysAddrWidth,
+                                                            uint8_t *pcLinearAddrWidth)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_CpuGetGuestAddrWidths: caller='%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
+    AssertPtrReturnVoid(pcPhysAddrWidth);
+    AssertPtrReturnVoid(pcLinearAddrWidth);
+
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_CpuGetGuestAddrWidths: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCpuGetGuestScalableBusFrequency} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_CpuGetGuestScalableBusFrequency(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_CpuGetGuestScalableBusFrequency: caller='%s'/%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    AssertFailed();
+    uint64_t u64Fsb = 0;
+
+    Log(("pdmR3DevHlp_CpuGetGuestScalableBusFrequency: caller='%s'/%d: returns %#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, u64Fsb));
+    return u64Fsb;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysReadGCVirt} */
+static DECLCALLBACK(int) pdmR3DevHlp_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: pvDst=%p GCVirt=%RGv cb=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
+
+    int rc = VERR_NOT_IMPLEMENTED;;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysWriteGCVirt} */
+static DECLCALLBACK(int) pdmR3DevHlp_PhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: GCVirtDst=%RGv pvSrc=%p cb=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
+
+    int rc = VERR_NOT_IMPLEMENTED;;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPhysGCPtr2GCPhys} */
+static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPtr2GCPhys(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: GCPtr=%RGv pGCPhys=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, GCPtr, pGCPhys));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc *pGCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *pGCPhys));
+
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAlloc} */
+static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAlloc(PPDMDEVINS pDevIns, size_t cb)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    void *pv = NULL;
+    AssertFailed();
+#else
+    void *pv = RTMemAlloc(cb);
+#endif
+
+    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
+    return pv;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAllocZ} */
+static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAllocZ(PPDMDEVINS pDevIns, size_t cb)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    void *pv = NULL;
+    AssertFailed();
+#else
+    void *pv = RTMemAllocZ(cb);
+#endif
+
+    LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
+    return pv;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapAPrintfV} */
+static DECLCALLBACK(char *) pdmR3DevHlp_MMHeapAPrintfV(PPDMDEVINS pDevIns, MMTAG enmTag, const char *pszFormat, va_list va)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_MMHeapAPrintfV: caller='%s'/%d: enmTag=%u pszFormat=%p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, enmTag, pszFormat, pszFormat));
+
+    RT_NOREF(va);
+    AssertFailed();
+    char *psz = NULL;
+
+    LogFlow(("pdmR3DevHlp_MMHeapAPrintfV: caller='%s'/%d: returns %p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, psz, psz));
+    return psz;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMMHeapFree} */
+static DECLCALLBACK(void) pdmR3DevHlp_MMHeapFree(PPDMDEVINS pDevIns, void *pv)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
+    LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    PTSTDEVMMHEAPALLOC pHeapAlloc = (PTSTDEVMMHEAPALLOC)((uint8_t *)pv - RT_UOFFSETOF(TSTDEVMMHEAPALLOC, abAlloc[0]));
+    PTSTDEVDUTINT pThis = pHeapAlloc->pDut;
+
+    tstDevDutLockExcl(pThis);
+    RTListNodeRemove(&pHeapAlloc->NdMmHeap);
+    tstDevDutUnlockExcl(pThis);
+
+    /* Poison */
+    memset(&pHeapAlloc->abAlloc[0], 0xfc, pHeapAlloc->cbAlloc);
+    RTMemFree(pHeapAlloc);
+#else
+    RTMemFree(pv);
+#endif
+
+    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMMPhysGetRamSize} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_MMPhysGetRamSize(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
+    LogFlow(("pdmR3DevHlp_MMPhysGetRamSize: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    AssertFailed();
+    uint64_t cb = 0;
+#else
+    uint64_t cb = _4G;
+#endif
+
+    LogFlow(("pdmR3DevHlp_MMPhysGetRamSize: caller='%s'/%d: returns %RU64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, cb));
+    return cb;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMMPhysGetRamSizeBelow4GB} */
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_MMPhysGetRamSizeBelow4GB(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
+    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeBelow4GB: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+    AssertFailed();
+    uint32_t cb = 0;
+
+    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeBelow4GB: caller='%s'/%d: returns %RU32\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, cb));
+    return cb;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnMMPhysGetRamSizeAbove4GB} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_MMPhysGetRamSizeAbove4GB(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
+    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeAbove4GB: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+    AssertFailed();
+    uint64_t cb = 0;
+
+    LogFlow(("pdmR3DevHlp_MMPhysGetRamSizeAbove4GB: caller='%s'/%d: returns %RU64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, cb));
+    return cb;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMState} */
+static DECLCALLBACK(VMSTATE) pdmR3DevHlp_VMState(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    VMSTATE enmVMState = VMSTATE_CREATING;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance,
+             enmVMState));
+    return enmVMState;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMTeleportedAndNotFullyResumedYet} */
+static DECLCALLBACK(bool) pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    bool fRc = false;
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    AssertFailed();
+#endif
+
+    LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance,
+             fRc));
+    return fRc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetErrorV} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMSetErrorV(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
+    AssertFailed();
+
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMSetRuntimeErrorV} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeErrorV(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, fFlags, pszErrorId, pszFormat, va);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMWaitForDeviceReady} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMWaitForDeviceReady(PPDMDEVINS pDevIns, VMCPUID idCpu)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_VMWaitForDeviceReady: caller='%s'/%d: idCpu=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_VMWaitForDeviceReady: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMNotifyCpuDeviceReady} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMNotifyCpuDeviceReady(PPDMDEVINS pDevIns, VMCPUID idCpu)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_VMNotifyCpuDeviceReady: caller='%s'/%d: idCpu=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_VMNotifyCpuDeviceReady: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMReqCallNoWaitV} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMReqCallNoWaitV(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, va_list Args)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: idDstCpu=%u pfnFunction=%p cArgs=%u\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, idDstCpu, pfnFunction, cArgs));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed(); RT_NOREF(Args);
+
+    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMReqPriorityCallWaitV} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMReqPriorityCallWaitV(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, va_list Args)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: idDstCpu=%u pfnFunction=%p cArgs=%u\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, idDstCpu, pfnFunction, cArgs));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed(); RT_NOREF(Args);
+
+    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFStopV} */
+static DECLCALLBACK(int) pdmR3DevHlp_DBGFStopV(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction, const char *pszFormat, va_list args)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+#ifdef LOG_ENABLED
+    va_list va2;
+    va_copy(va2, args);
+    LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: pszFile=%p:{%s} iLine=%d pszFunction=%p:{%s} pszFormat=%p:{%s} (%N)\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
+    va_end(va2);
+#endif
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegister(PPDMDEVINS pDevIns, const char *pszName, const char *pszDesc, PFNDBGFHANDLERDEV pfnHandler)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+
+    LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoRegisterArgv} */
+static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegisterArgv(PPDMDEVINS pDevIns, const char *pszName, const char *pszDesc, PFNDBGFINFOARGVDEV pfnHandler)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DBGFInfoRegisterArgv: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_DBGFInfoRegisterArgv: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFRegRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_DBGFRegRegister(PPDMDEVINS pDevIns, PCDBGFREGDESC paRegisters)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: paRegisters=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, paRegisters));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_DBGFRegRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFTraceBuf} */
+static DECLCALLBACK(RTTRACEBUF) pdmR3DevHlp_DBGFTraceBuf(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RTTRACEBUF hTraceBuf = NIL_RTTRACEBUF;
+    AssertFailed();
+    LogFlow(("pdmR3DevHlp_DBGFTraceBuf: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, hTraceBuf));
+    return hTraceBuf;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFReportBugCheck} */
+static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_DBGFReportBugCheck(PPDMDEVINS pDevIns, DBGFEVENTTYPE enmEvent, uint64_t uBugCheck,
+                                                                 uint64_t uP1, uint64_t uP2, uint64_t uP3, uint64_t uP4)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DBGFReportBugCheck: caller='%s'/%d: enmEvent=%u uBugCheck=%#x uP1=%#x uP2=%#x uP3=%#x uP4=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, enmEvent, uBugCheck, uP1, uP2, uP3, uP4));
+
+    AssertFailed();
+    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
+
+    LogFlow(("pdmR3DevHlp_DBGFReportBugCheck: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict)));
+    return rcStrict;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFCoreWrite} */
+static DECLCALLBACK(int) pdmR3DevHlp_DBGFCoreWrite(PPDMDEVINS pDevIns, const char *pszFilename, bool fReplaceFile)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DBGFCoreWrite: caller='%s'/%d: pszFilename=%p:{%s} fReplaceFile=%RTbool\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pszFilename, pszFilename, fReplaceFile));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED;
+
+    LogFlow(("pdmR3DevHlp_DBGFCoreWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFInfoLogHlp} */
+static DECLCALLBACK(PCDBGFINFOHLP) pdmR3DevHlp_DBGFInfoLogHlp(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF(pDevIns);
+    LogFlow(("pdmR3DevHlp_DBGFInfoLogHlp: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+    AssertFailed();
+    PCDBGFINFOHLP pHlp = NULL;
+
+    LogFlow(("pdmR3DevHlp_DBGFInfoLogHlp: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pHlp));
+    return pHlp;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFRegNmQueryU64} */
+static DECLCALLBACK(int) pdmR3DevHlp_DBGFRegNmQueryU64(PPDMDEVINS pDevIns, VMCPUID idDefCpu, const char *pszReg, uint64_t *pu64)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DBGFRegNmQueryU64: caller='%s'/%d: idDefCpu=%u pszReg=%p:{%s} pu64=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, idDefCpu, pszReg, pszReg, pu64));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED;
+
+    LogFlow(("pdmR3DevHlp_DBGFRegNmQueryU64: caller='%s'/%d: returns %Rrc *pu64=%#RX64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc, *pu64));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDBGFRegPrintfV} */
+static DECLCALLBACK(int) pdmR3DevHlp_DBGFRegPrintfV(PPDMDEVINS pDevIns, VMCPUID idCpu, char *pszBuf, size_t cbBuf,
+                                                    const char *pszFormat, va_list va)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DBGFRegPrintfV: caller='%s'/%d: idCpu=%u pszBuf=%p cbBuf=%u pszFormat=%p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, idCpu, pszBuf, cbBuf, pszFormat, pszFormat));
+
+    AssertFailed();
+    RT_NOREF(va);
+    int rc = VERR_NOT_IMPLEMENTED;
+
+    LogFlow(("pdmR3DevHlp_DBGFRegPrintfV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegister} */
+static DECLCALLBACK(void) pdmR3DevHlp_STAMRegister(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, const char *pszName,
+                                                   STAMUNIT enmUnit, const char *pszDesc)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pvSample, enmType, pszName, enmUnit, pszDesc);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    AssertFailed();
+#endif
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterV} */
+static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterV(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
+                                                    STAMUNIT enmUnit, const char *pszDesc, const char *pszName, va_list args)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    AssertFailed();
+#endif
+}
+
+
+/**
+ * @interface_method_impl{PDMDEVHLPR3,pfnPCIRegister}
+ */
+static DECLCALLBACK(int) pdmR3DevHlp_PCIRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
+                                                 uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: pPciDev=%p:{.config={%#.256Rhxs} fFlags=%#x uPciDevNo=%#x uPciFunNo=%#x pszName=%p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->abConfig, fFlags, uPciDevNo, uPciFunNo, pszName, pszName ? pszName : ""));
+
+    /*
+     * Validate input.
+     */
+    AssertLogRelMsgReturn(pDevIns->pReg->cMaxPciDevices > 0,
+                          ("'%s'/%d: cMaxPciDevices is 0\n", pDevIns->pReg->szName, pDevIns->iInstance),
+                          VERR_WRONG_ORDER);
+    AssertLogRelMsgReturn(RT_VALID_PTR(pPciDev),
+                          ("'%s'/%d: Invalid pPciDev value: %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pPciDev),
+                          VERR_INVALID_POINTER);
+    AssertLogRelMsgReturn(PDMPciDevGetVendorId(pPciDev),
+                          ("'%s'/%d: Vendor ID is not set!\n", pDevIns->pReg->szName, pDevIns->iInstance),
+                          VERR_INVALID_POINTER);
+    AssertLogRelMsgReturn(   uPciDevNo < 32
+                          || uPciDevNo == PDMPCIDEVREG_DEV_NO_FIRST_UNUSED
+                          || uPciDevNo == PDMPCIDEVREG_DEV_NO_SAME_AS_PREV,
+                          ("'%s'/%d: Invalid PCI device number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciDevNo),
+                          VERR_INVALID_PARAMETER);
+    AssertLogRelMsgReturn(   uPciFunNo < 8
+                          || uPciFunNo == PDMPCIDEVREG_FUN_NO_FIRST_UNUSED,
+                          ("'%s'/%d: Invalid PCI funcion number: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, uPciFunNo),
+                          VERR_INVALID_PARAMETER);
+    AssertLogRelMsgReturn(!(fFlags & ~PDMPCIDEVREG_F_VALID_MASK),
+                          ("'%s'/%d: Invalid flags: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags),
+                          VERR_INVALID_FLAGS);
+    if (!pszName)
+        pszName = pDevIns->pReg->szName;
+
+#if 0
+    AssertLogRelReturn(RT_VALID_PTR(pszName), VERR_INVALID_POINTER);
+    AssertLogRelReturn(!pPciDev->Int.s.fRegistered, VERR_PDM_NOT_PCI_DEVICE);
+    AssertLogRelReturn(pPciDev == PDMDEV_GET_PPCIDEV(pDevIns, pPciDev->Int.s.idxSubDev), VERR_PDM_NOT_PCI_DEVICE);
+    AssertLogRelReturn(pPciDev == PDMDEV_CALC_PPCIDEV(pDevIns, pPciDev->Int.s.idxSubDev), VERR_PDM_NOT_PCI_DEVICE);
+    AssertMsgReturn(pPciDev->u32Magic == PDMPCIDEV_MAGIC, ("%#x\n", pPciDev->u32Magic), VERR_PDM_NOT_PCI_DEVICE);
+#endif
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIRegisterMsi} */
+static DECLCALLBACK(int) pdmR3DevHlp_PCIRegisterMsi(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PPDMMSIREG pMsiReg)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: pPciDev=%p:{%#x} pMsgReg=%p:{cMsiVectors=%d, cMsixVectors=%d}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, pMsiReg, pMsiReg->cMsiVectors, pMsiReg->cMsixVectors));
+    PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
+
+    AssertLogRelMsgReturn(pDevIns->pReg->cMaxPciDevices > 0,
+                          ("'%s'/%d: cMaxPciDevices is 0\n", pDevIns->pReg->szName, pDevIns->iInstance),
+                          VERR_WRONG_ORDER);
+    AssertLogRelMsgReturn(pMsiReg->cMsixVectors <= pDevIns->pReg->cMaxMsixVectors,
+                          ("'%s'/%d: cMsixVectors=%u cMaxMsixVectors=%u\n",
+                           pDevIns->pReg->szName, pDevIns->iInstance, pMsiReg->cMsixVectors, pDevIns->pReg->cMaxMsixVectors),
+                          VERR_INVALID_FLAGS);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+
+    LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIIORegionRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_PCIIORegionRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
+                                                         RTGCPHYS cbRegion, PCIADDRESSSPACE enmType, uint32_t fFlags,
+                                                         uint64_t hHandle, PFNPCIIOREGIONMAP pfnMapUnmap)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%d cbRegion=%RGp enmType=%d fFlags=%#x, hHandle=%#RX64 pfnMapUnmap=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iRegion, cbRegion, enmType, fFlags, hHandle, pfnMapUnmap));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
+#endif
+
+    /*
+     * Validate input.
+     */
+    if (iRegion >= VBOX_PCI_NUM_REGIONS)
+    {
+        Assert(iRegion < VBOX_PCI_NUM_REGIONS);
+        LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (iRegion)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    switch ((int)enmType)
+    {
+        case PCI_ADDRESS_SPACE_IO:
+            /*
+             * Sanity check: don't allow to register more than 32K of the PCI I/O space.
+             */
+            AssertLogRelMsgReturn(cbRegion <= _32K,
+                                  ("caller='%s'/%d: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cbRegion),
+                                  VERR_INVALID_PARAMETER);
+            break;
+
+        case PCI_ADDRESS_SPACE_MEM:
+        case PCI_ADDRESS_SPACE_MEM_PREFETCH:
+            /*
+             * Sanity check: Don't allow to register more than 2GB of the PCI MMIO space.
+             */
+            AssertLogRelMsgReturn(cbRegion <= MM_MMIO_32_MAX,
+                                  ("caller='%s'/%d: %RGp (max %RGp)\n",
+                                   pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, (RTGCPHYS)MM_MMIO_32_MAX),
+                                  VERR_OUT_OF_RANGE);
+            break;
+
+        case PCI_ADDRESS_SPACE_BAR64 | PCI_ADDRESS_SPACE_MEM:
+        case PCI_ADDRESS_SPACE_BAR64 | PCI_ADDRESS_SPACE_MEM_PREFETCH:
+            /*
+             * Sanity check: Don't allow to register more than 64GB of the 64-bit PCI MMIO space.
+             */
+            AssertLogRelMsgReturn(cbRegion <= MM_MMIO_64_MAX,
+                                  ("caller='%s'/%d: %RGp (max %RGp)\n",
+                                   pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, MM_MMIO_64_MAX),
+                                  VERR_OUT_OF_RANGE);
+            break;
+
+        default:
+            AssertMsgFailed(("enmType=%#x is unknown\n", enmType));
+            LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (enmType)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+            return VERR_INVALID_PARAMETER;
+    }
+
+    AssertMsgReturn(   pfnMapUnmap
+                    || (   hHandle != UINT64_MAX
+                        && (fFlags & PDMPCIDEV_IORGN_F_HANDLE_MASK) != PDMPCIDEV_IORGN_F_NO_HANDLE),
+                    ("caller='%s'/%d: fFlags=%#x hHandle=%#RX64\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags, hHandle),
+                    VERR_INVALID_PARAMETER);
+
+    AssertMsgReturn(!(fFlags & ~PDMPCIDEV_IORGN_F_VALID_MASK), ("fFlags=%#x\n", fFlags), VERR_INVALID_FLAGS);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIInterceptConfigAccesses} */
+static DECLCALLBACK(int) pdmR3DevHlp_PCIInterceptConfigAccesses(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev,
+                                                                PFNPCICONFIGREAD pfnRead, PFNPCICONFIGWRITE pfnWrite)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    LogFlow(("pdmR3DevHlp_PCIInterceptConfigAccesses: caller='%s'/%d: pPciDev=%p pfnRead=%p pfnWrite=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pfnRead, pfnWrite));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_PCIInterceptConfigAccesses: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIConfigWrite} */
+static DECLCALLBACK(VBOXSTRICTRC)
+pdmR3DevHlp_PCIConfigWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t uAddress, unsigned cb, uint32_t u32Value)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertPtrReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    LogFlow(("pdmR3DevHlp_PCIConfigWrite: caller='%s'/%d: pPciDev=%p uAddress=%#x cd=%d u32Value=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, uAddress, cb, u32Value));
+
+    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_PCIConfigWrite: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict)));
+    return rcStrict;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIConfigRead} */
+static DECLCALLBACK(VBOXSTRICTRC)
+pdmR3DevHlp_PCIConfigRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t uAddress, unsigned cb, uint32_t *pu32Value)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertPtrReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    LogFlow(("pdmR3DevHlp_PCIConfigRead: caller='%s'/%d: pPciDev=%p uAddress=%#x cd=%d pu32Value=%p:{%#x}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, uAddress, cb, pu32Value, *pu32Value));
+
+    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_PCIConfigRead: caller='%s'/%d: returns %Rrc (*pu32Value=%#x)\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict), *pu32Value));
+    return rcStrict;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysRead} */
+static DECLCALLBACK(int)
+pdmR3DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, uint32_t fFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    //PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
+
+#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
+    /*
+     * Just check the busmaster setting here and forward the request to the generic read helper.
+     */
+    if (PCIDevIsBusmaster(pPciDev))
+    { /* likely */ }
+    else
+    {
+        Log(("pdmR3DevHlp_PCIPhysRead: caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbRead=%#zx\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbRead));
+        memset(pvBuf, 0xff, cbRead);
+        return VERR_PDM_NOT_PCI_BUS_MASTER;
+    }
+#endif
+
+    RT_NOREF(fFlags);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    RTRandBytes(pvBuf, cbRead);
+    int rc = VINF_SUCCESS;
+#endif
+
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysWrite} */
+static DECLCALLBACK(int)
+pdmR3DevHlp_PCIPhysWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, uint32_t fFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    //PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
+
+#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
+    /*
+     * Just check the busmaster setting here and forward the request to the generic read helper.
+     */
+    if (PCIDevIsBusmaster(pPciDev))
+    { /* likely */ }
+    else
+    {
+        Log(("pdmR3DevHlp_PCIPhysWrite: caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbWrite=%#zx\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbWrite));
+        return VERR_PDM_NOT_PCI_BUS_MASTER;
+    }
+#endif
+
+    RT_NOREF(GCPhys, pvBuf, cbWrite, fFlags);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysGCPhys2CCPtr} */
+static DECLCALLBACK(int) pdmR3DevHlp_PCIPhysGCPhys2CCPtr(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
+                                                         uint32_t fFlags, void **ppv, PPGMPAGEMAPLOCK pLock)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
+
+#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
+    if (PCIDevIsBusmaster(pPciDev))
+    { /* likely */ }
+    else
+    {
+        LogFunc(("caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp fFlags=%#RX32\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, fFlags));
+        return VERR_PDM_NOT_PCI_BUS_MASTER;
+    }
+#endif
+
+    AssertFailed(); RT_NOREF(ppv, pLock);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysGCPhys2CCPtrReadOnly} */
+static DECLCALLBACK(int) pdmR3DevHlp_PCIPhysGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
+                                                                 uint32_t fFlags, void const **ppv, PPGMPAGEMAPLOCK pLock)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
+
+#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
+    if (PCIDevIsBusmaster(pPciDev))
+    { /* likely */ }
+    else
+    {
+        LogFunc(("caller='%s'/%d: returns %Rrc - Not bus master! GCPhys=%RGp fFlags=%#RX32\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, fFlags));
+        return VERR_PDM_NOT_PCI_BUS_MASTER;
+    }
+#endif
+
+    AssertFailed(); RT_NOREF(ppv, pLock);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysBulkGCPhys2CCPtr} */
+static DECLCALLBACK(int) pdmR3DevHlp_PCIPhysBulkGCPhys2CCPtr(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t cPages,
+                                                             PCRTGCPHYS paGCPhysPages, uint32_t fFlags, void **papvPages,
+                                                             PPGMPAGEMAPLOCK paLocks)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
+
+#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
+    if (PCIDevIsBusmaster(pPciDev))
+    { /* likely */ }
+    else
+    {
+        LogFunc(("caller='%s'/%d: returns %Rrc - Not bus master! cPages=%zu fFlags=%#RX32\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, cPages, fFlags));
+        return VERR_PDM_NOT_PCI_BUS_MASTER;
+    }
+#endif
+
+    AssertFailed(); RT_NOREF(paGCPhysPages, fFlags, papvPages, paLocks);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysBulkGCPhys2CCPtrReadOnly} */
+static DECLCALLBACK(int) pdmR3DevHlp_PCIPhysBulkGCPhys2CCPtrReadOnly(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t cPages,
+                                                                     PCRTGCPHYS paGCPhysPages, uint32_t fFlags,
+                                                                     const void **papvPages, PPGMPAGEMAPLOCK paLocks)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
+
+#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
+    if (PCIDevIsBusmaster(pPciDev))
+    { /* likely */ }
+    else
+    {
+        LogFunc(("caller='%s'/%d: returns %Rrc - Not bus master! cPages=%zu fFlags=%#RX32\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_NOT_PCI_BUS_MASTER, cPages, fFlags));
+        return VERR_PDM_NOT_PCI_BUS_MASTER;
+    }
+#endif
+
+    AssertFailed(); RT_NOREF(paGCPhysPages, fFlags, papvPages, paLocks);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrq} */
+static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrq(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturnVoid(pPciDev);
+    LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: pPciDev=%p:{%#x} iIrq=%d iLevel=%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iIrq, iLevel));
+    //PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    RT_NOREF(iIrq, iLevel);
+    AssertFailed();
+#endif
+
+    LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetIrqNoWait} */
+static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrqNoWait(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
+{
+    pdmR3DevHlp_PCISetIrq(pDevIns, pPciDev, iIrq, iLevel);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrq} */
+static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
+
+    /*
+     * Validate input.
+     */
+    Assert(iIrq < 16);
+    Assert((uint32_t)iLevel <= PDM_IRQ_LEVEL_FLIP_FLOP);
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    AssertFailed();
+#endif
+
+    LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnISASetIrqNoWait} */
+static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
+{
+    pdmR3DevHlp_ISASetIrq(pDevIns, iIrq, iLevel);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDriverAttach} */
+static DECLCALLBACK(int) pdmR3DevHlp_DriverAttach(PPDMDEVINS pDevIns, uint32_t iLun, PPDMIBASE pBaseInterface, PPDMIBASE *ppBaseInterface, const char *pszDesc)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
+
+#if 1
+    int rc = VINF_SUCCESS;
+    if (iLun == PDM_STATUS_LUN)
+        *ppBaseInterface = &pDevIns->Internal.s.pDut->IBaseSts;
+    else
+        rc = VERR_PDM_NO_ATTACHED_DRIVER;
+#else
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#endif
+
+    LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDriverDetach} */
+static DECLCALLBACK(int) pdmR3DevHlp_DriverDetach(PPDMDEVINS pDevIns, PPDMDRVINS pDrvIns, uint32_t fFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
+    LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: pDrvIns=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pDrvIns));
+
+    RT_NOREF(fFlags);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_DriverDetach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDriverReconfigure} */
+static DECLCALLBACK(int) pdmR3DevHlp_DriverReconfigure(PPDMDEVINS pDevIns, uint32_t iLun, uint32_t cDepth,
+                                                       const char * const *papszDrivers, PCFGMNODE *papConfigs, uint32_t fFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DriverReconfigure: caller='%s'/%d: iLun=%u cDepth=%u fFlags=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, iLun, cDepth, fFlags));
+
+    /*
+     * Validate input.
+     */
+    AssertReturn(cDepth <= 8, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(papszDrivers, VERR_INVALID_POINTER);
+    AssertPtrNullReturn(papConfigs, VERR_INVALID_POINTER);
+    for (uint32_t i = 0; i < cDepth; i++)
+    {
+        AssertPtrReturn(papszDrivers[i], VERR_INVALID_POINTER);
+        size_t cchDriver = strlen(papszDrivers[i]);
+        AssertReturn(cchDriver > 0 && cchDriver < RT_SIZEOFMEMB(PDMDRVREG, szName), VERR_OUT_OF_RANGE);
+
+        if (papConfigs)
+            AssertPtrNullReturn(papConfigs[i], VERR_INVALID_POINTER);
+    }
+    AssertReturn(fFlags == 0, VERR_INVALID_FLAGS);
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_DriverReconfigure: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnQueueCreate} */
+static DECLCALLBACK(int) pdmR3DevHlp_QueueCreate(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
+                                                 PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char *pszName,
+                                                 PDMQUEUEHANDLE *phQueue)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} phQueue=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, phQueue));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *phQueue));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnQueueAlloc} */
+static DECLCALLBACK(PPDMQUEUEITEMCORE) pdmR3DevHlp_QueueAlloc(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
+{
+    RT_NOREF(pDevIns, hQueue);
+    AssertFailed();
+    return NULL;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnQueueInsert} */
+static DECLCALLBACK(void) pdmR3DevHlp_QueueInsert(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem)
+{
+    RT_NOREF(pDevIns, hQueue, pItem);
+    AssertFailed();
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnQueueFlushIfNecessary} */
+static DECLCALLBACK(bool) pdmR3DevHlp_QueueFlushIfNecessary(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
+{
+    RT_NOREF(pDevIns, hQueue);
+    AssertFailed();
+    return false;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTaskCreate} */
+static DECLCALLBACK(int) pdmR3DevHlp_TaskCreate(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszName,
+                                                PFNPDMTASKDEV pfnCallback, void *pvUser, PDMTASKHANDLE *phTask)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: pfnCallback=%p fFlags=%#x pszName=%p:{%s} phTask=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pfnCallback, fFlags, pszName, pszName, phTask));
+
+    RT_NOREF(pDevIns, fFlags, pszName, pfnCallback, pvUser, phTask);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTaskTrigger} */
+static DECLCALLBACK(int) pdmR3DevHlp_TaskTrigger(PPDMDEVINS pDevIns, PDMTASKHANDLE hTask)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: hTask=%RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, hTask));
+
+    RT_NOREF(pDevIns, hTask);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventCreate} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventCreate(PPDMDEVINS pDevIns, PSUPSEMEVENT phEvent)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, phEvent));
+
+    RTSEMEVENT hEvt;
+    int rc = RTSemEventCreate(&hEvt);
+    if (RT_SUCCESS(rc))
+        *phEvent = (SUPSEMEVENT)hEvt;
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventCreate: caller='%s'/%d: returns %Rrc *phEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *phEvent));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventClose} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventClose(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
+
+    int rc = RTSemEventDestroy((RTSEMEVENT)hEvent);
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventSignal} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventSignal(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
+
+    int rc = RTSemEventSignal((RTSEMEVENT)hEvent);
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNoResume} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint32_t cMillies)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: hEvent=%p cNsTimeout=%RU32\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cMillies));
+
+    int rc = RTSemEventWaitNoResume((RTSEMEVENT)hEvent, cMillies);
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNsAbsIntr} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t uNsTimeout)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: hEvent=%p uNsTimeout=%RU64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEvent, uNsTimeout));
+
+    int rc = RTSemEventWait((RTSEMEVENT)hEvent, uNsTimeout / RT_NS_1MS);
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventWaitNsRelIntr} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t cNsTimeout)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: hEvent=%p cNsTimeout=%RU64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cNsTimeout));
+
+    int rc = RTSemEventWait((RTSEMEVENT)hEvent, cNsTimeout / RT_NS_1MS);
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventGetResolution} */
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_SUPSemEventGetResolution(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+    RT_NOREF(pDevIns);
+    uint32_t cNsResolution = 0;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
+    return cNsResolution;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiCreate} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiCreate(PPDMDEVINS pDevIns, PSUPSEMEVENTMULTI phEventMulti)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiCreate: caller='%s'/%d: phEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, phEventMulti));
+
+    RT_NOREF(pDevIns, phEventMulti);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiCreate: caller='%s'/%d: returns %Rrc *phEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *phEventMulti));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiClose} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiClose(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiClose: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
+
+    RT_NOREF(pDevIns, hEventMulti);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiClose: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiSignal} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiSignal(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
+
+    RT_NOREF(pDevIns, hEventMulti);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiReset} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiReset(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiReset: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
+
+    RT_NOREF(pDevIns, hEventMulti);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNoResume} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
+                                                                  uint32_t cMillies)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: hEventMulti=%p cMillies=%RU32\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cMillies));
+
+    RT_NOREF(pDevIns, hEventMulti, cMillies);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNsAbsIntr} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
+                                                                   uint64_t uNsTimeout)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: hEventMulti=%p uNsTimeout=%RU64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, uNsTimeout));
+
+    RT_NOREF(pDevIns, hEventMulti, uNsTimeout);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiWaitNsRelIntr} */
+static DECLCALLBACK(int) pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
+                                                                   uint64_t cNsTimeout)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: hEventMulti=%p cNsTimeout=%RU64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cNsTimeout));
+
+    RT_NOREF(pDevIns, hEventMulti, cNsTimeout);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSUPSemEventMultiGetResolution} */
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_SUPSemEventMultiGetResolution(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+    uint32_t cNsResolution = 0;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
+    return cNsResolution;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectInit} */
+static DECLCALLBACK(int) pdmR3DevHlp_CritSectInit(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RT_SRC_POS_DECL,
+                                                  const char *pszNameFmt, va_list va)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
+
+    RT_NOREF(RT_SRC_POS_ARGS, pszNameFmt, va);
+    int rc = RTCritSectInit(&pCritSect->s.CritSect);
+
+    LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetNop} */
+static DECLCALLBACK(PPDMCRITSECT) pdmR3DevHlp_CritSectGetNop(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    PPDMCRITSECT pCritSect = &pDevIns->Internal.s.pDut->CritSectNop;
+
+    LogFlow(("pdmR3DevHlp_CritSectGetNop: caller='%s'/%d: return %p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
+    return pCritSect;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSetDeviceCritSect} */
+static DECLCALLBACK(int) pdmR3DevHlp_SetDeviceCritSect(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
+{
+    /*
+     * Validate input.
+     */
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertPtrReturn(pCritSect, VERR_INVALID_POINTER);
+
+    LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: pCritSect=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
+
+    pDevIns->pCritSectRoR3 = pCritSect;
+    LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectYield} */
+static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectYield(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pCritSect);
+    AssertFailed();
+    return false;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectEnter} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, rcBusy);
+    return RTCritSectEnter(&pCritSect->s.CritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectEnterDebug} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, rcBusy, uId, RT_SRC_POS_ARGS);
+    return RTCritSectEnter(&pCritSect->s.CritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectTryEnter} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectTryEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pCritSect);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectTryEnterDebug} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectTryEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pCritSect, uId, RT_SRC_POS_ARGS);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectLeave} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectLeave(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    return RTCritSectLeave(&pCritSect->s.CritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectIsOwner} */
+static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectIsOwner(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    return RTCritSectIsOwner(&pCritSect->s.CritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectIsInitialized} */
+static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectIsInitialized(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pCritSect);
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    AssertFailed();
+    return false;
+#else
+    return true;
+#endif
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectHasWaiters} */
+static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectHasWaiters(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns, pCritSect);
+    AssertFailed();
+    return false;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectGetRecursion} */
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_CritSectGetRecursion(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pCritSect);
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectScheduleExitEvent} */
+static DECLCALLBACK(int) pdmR3DevHlp_CritSectScheduleExitEvent(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect,
+                                                               SUPSEMEVENT hEventToSignal)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pCritSect, hEventToSignal);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectDelete} */
+static DECLCALLBACK(int) pdmR3DevHlp_CritSectDelete(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pCritSect);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwInit} */
+static DECLCALLBACK(int) pdmR3DevHlp_CritSectRwInit(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, RT_SRC_POS_DECL,
+                                                    const char *pszNameFmt, va_list va)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_CritSectRwInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed(); RT_NOREF(RT_SRC_POS_ARGS, va);
+
+    LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwDelete} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwDelete(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwEnterShared} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwEnterShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect, rcBusy);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwEnterSharedDebug} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwEnterSharedDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy,
+                                                                     RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwTryEnterShared} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwTryEnterShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwTryEnterSharedDebug} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwTryEnterSharedDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect,
+                                                                        RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect, uId, RT_SRC_POS_ARGS);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwLeaveShared} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwLeaveShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwEnterExcl} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwEnterExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect, rcBusy);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwEnterExclDebug} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwEnterExclDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy,
+                                                                   RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwTryEnterExcl} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwTryEnterExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwTryEnterExclDebug} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwTryEnterExclDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect,
+                                                                      RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect, uId, RT_SRC_POS_ARGS);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwLeaveExcl} */
+static DECLCALLBACK(int)      pdmR3DevHlp_CritSectRwLeaveExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwIsWriteOwner} */
+static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectRwIsWriteOwner(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwIsReadOwner} */
+static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectRwIsReadOwner(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, bool fWannaHear)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed(); RT_NOREF(pCritSect, fWannaHear);
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwGetWriteRecursion} */
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_CritSectRwGetWriteRecursion(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns, pCritSect);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwGetWriterReadRecursion} */
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_CritSectRwGetWriterReadRecursion(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns, pCritSect);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwGetReadCount} */
+static DECLCALLBACK(uint32_t) pdmR3DevHlp_CritSectRwGetReadCount(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns, pCritSect);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectRwIsInitialized} */
+static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectRwIsInitialized(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns, pCritSect);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
+                                                  PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
+
+    int rc = tstDevPdmR3ThreadCreateDevice(pDevIns->Internal.s.pDut, pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
+
+    LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szName, pDevIns->iInstance,
+            rc, *ppThread));
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadDestroy(PPDMTHREAD pThread, int *pRcThread)
+{
+    return tstDevPdmR3ThreadDestroy(pThread, pRcThread);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadIAmSuspending(PPDMTHREAD pThread)
+{
+    return tstDevPdmR3ThreadIAmSuspending(pThread);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadIamRunning(PPDMTHREAD pThread)
+{
+    return tstDevPdmR3ThreadIAmRunning(pThread);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadSleep(PPDMTHREAD pThread, RTMSINTERVAL cMillies)
+{
+    return tstDevPdmR3ThreadSleep(pThread, cMillies);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadSuspend(PPDMTHREAD pThread)
+{
+    return tstDevPdmR3ThreadSuspend(pThread);
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadResume(PPDMTHREAD pThread)
+{
+    return tstDevPdmR3ThreadResume(pThread);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSetAsyncNotification} */
+static DECLCALLBACK(int) pdmR3DevHlp_SetAsyncNotification(PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pfnAsyncNotify));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertStmt(pfnAsyncNotify, rc = VERR_INVALID_PARAMETER);
+#if 0
+    AssertStmt(!pDevIns->Internal.s.pfnAsyncNotify, rc = VERR_WRONG_ORDER);
+    AssertStmt(pDevIns->Internal.s.fIntFlags & (PDMDEVINSINT_FLAGS_SUSPENDED | PDMDEVINSINT_FLAGS_RESET), rc = VERR_WRONG_ORDER);
+#endif
+
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnAsyncNotificationCompleted} */
+static DECLCALLBACK(void) pdmR3DevHlp_AsyncNotificationCompleted(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    AssertFailed();
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnRTCRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_RTCRegister(PPDMDEVINS pDevIns, PCPDMRTCREG pRtcReg, PCPDMRTCHLP *ppRtcHlp)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: pRtcReg=%p:{.u32Version=%#x, .pfnWrite=%p, .pfnRead=%p} ppRtcHlp=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
+             pRtcReg->pfnWrite, ppRtcHlp));
+
+    /*
+     * Validate input.
+     */
+    if (pRtcReg->u32Version != PDM_RTCREG_VERSION)
+    {
+        AssertMsgFailed(("u32Version=%#x expected %#x\n", pRtcReg->u32Version,
+                         PDM_RTCREG_VERSION));
+        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (version)\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+    if (    !pRtcReg->pfnWrite
+        ||  !pRtcReg->pfnRead)
+    {
+        Assert(pRtcReg->pfnWrite);
+        Assert(pRtcReg->pfnRead);
+        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    if (!ppRtcHlp)
+    {
+        Assert(ppRtcHlp);
+        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (ppRtcHlp)\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDMARegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_DMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: uChannel=%d pfnTransferHandler=%p pvUser=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDMAReadMemory} */
+static DECLCALLBACK(int) pdmR3DevHlp_DMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbRead)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbRead=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDMAWriteMemory} */
+static DECLCALLBACK(int) pdmR3DevHlp_DMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbWritten)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbWritten=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDMASetDREQ} */
+static DECLCALLBACK(int) pdmR3DevHlp_DMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: uChannel=%d uLevel=%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, uChannel, uLevel));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDMAGetChannelMode} */
+static DECLCALLBACK(uint8_t) pdmR3DevHlp_DMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: uChannel=%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, uChannel));
+
+    uint8_t u8Mode = (3 << 2); /* Invalid mode. */
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: returns %#04x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, u8Mode));
+    return u8Mode;
+}
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDMASchedule} */
+static DECLCALLBACK(void) pdmR3DevHlp_DMASchedule(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DMASchedule: caller='%s'/%d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    AssertFailed();
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSWrite} */
+static DECLCALLBACK(int) pdmR3DevHlp_CMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x u8Value=%#04x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, iReg, u8Value));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCMOSRead} */
+static DECLCALLBACK(int) pdmR3DevHlp_CMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x pu8Value=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, iReg, pu8Value));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnAssertEMT} */
+static DECLCALLBACK(bool) pdmR3DevHlp_AssertEMT(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    char szMsg[100];
+    RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
+    RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
+    AssertBreakpoint();
+    return false;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnAssertOther} */
+static DECLCALLBACK(bool) pdmR3DevHlp_AssertOther(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    char szMsg[100];
+    RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
+    RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
+    AssertBreakpoint();
+    return false;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetRCInterfaceSymbols} */
+static DECLCALLBACK(int) pdmR3DevHlp_LdrGetRCInterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
+                                                              const char *pszSymPrefix, const char *pszSymList)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
+             pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnLdrGetR0InterfaceSymbols} */
+static DECLCALLBACK(int) pdmR3DevHlp_LdrGetR0InterfaceSymbols(PPDMDEVINS pDevIns, void *pvInterface, size_t cbInterface,
+                                                              const char *pszSymPrefix, const char *pszSymList)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
+             pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCallR0} */
+static DECLCALLBACK(int) pdmR3DevHlp_CallR0(PPDMDEVINS pDevIns, uint32_t uOperation, uint64_t u64Arg)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: uOperation=%#x u64Arg=%#RX64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, uOperation, u64Arg));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_CallR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
+             pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetSuspendReason} */
+static DECLCALLBACK(VMSUSPENDREASON) pdmR3DevHlp_VMGetSuspendReason(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    VMSUSPENDREASON enmReason = VMSUSPENDREASON_INVALID;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_VMGetSuspendReason: caller='%s'/%d: returns %d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
+    return enmReason;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMGetResumeReason} */
+static DECLCALLBACK(VMRESUMEREASON) pdmR3DevHlp_VMGetResumeReason(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    VMRESUMEREASON enmReason = VMRESUMEREASON_INVALID;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_VMGetResumeReason: caller='%s'/%d: returns %d\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
+    return enmReason;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnGetUVM} */
+static DECLCALLBACK(PUVM) pdmR3DevHlp_GetUVM(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    AssertFailed();
+    LogFlow(("pdmR3DevHlp_GetUVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
+    return NULL;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnGetVM} */
+static DECLCALLBACK(PVMCC) pdmR3DevHlp_GetVM(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns->Internal.s.pDut->pVm));
+    return pDevIns->Internal.s.pDut->pVm;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnGetVMCPU} */
+static DECLCALLBACK(PVMCPU) pdmR3DevHlp_GetVMCPU(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    AssertFailed();
+    LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
+    return NULL;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnGetCurrentCpuId} */
+static DECLCALLBACK(VMCPUID) pdmR3DevHlp_GetCurrentCpuId(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    VMCPUID idCpu = 0;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_GetCurrentCpuId: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
+    return idCpu;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPCIBusRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_PCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREGR3 pPciBusReg,
+                                                    PCPDMPCIHLPR3 *ppPciHlp, uint32_t *piBus)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: pPciBusReg=%p:{.u32Version=%#x, .pfnRegisterR3=%p, .pfnIORegionRegisterR3=%p, "
+             ".pfnInterceptConfigAccesses=%p, pfnConfigRead=%p, pfnConfigWrite=%p, .pfnSetIrqR3=%p, .u32EndVersion=%#x} ppPciHlpR3=%p piBus=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
+             pPciBusReg->pfnIORegionRegisterR3, pPciBusReg->pfnInterceptConfigAccesses, pPciBusReg->pfnConfigRead,
+             pPciBusReg->pfnConfigWrite, pPciBusReg->pfnSetIrqR3, pPciBusReg->u32EndVersion, ppPciHlp, piBus));
+
+    /*
+     * Validate the structure and output parameters.
+     */
+    AssertLogRelMsgReturn(pPciBusReg->u32Version == PDM_PCIBUSREGR3_VERSION,
+                          ("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREGR3_VERSION),
+                          VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pPciBusReg->pfnRegisterR3, VERR_INVALID_PARAMETER);
+    AssertPtrNullReturn(pPciBusReg->pfnRegisterMsiR3, VERR_INVALID_POINTER);
+    AssertPtrReturn(pPciBusReg->pfnIORegionRegisterR3, VERR_INVALID_POINTER);
+    AssertPtrReturn(pPciBusReg->pfnInterceptConfigAccesses, VERR_INVALID_POINTER);
+    AssertPtrReturn(pPciBusReg->pfnConfigWrite, VERR_INVALID_POINTER);
+    AssertPtrReturn(pPciBusReg->pfnConfigRead, VERR_INVALID_POINTER);
+    AssertPtrReturn(pPciBusReg->pfnSetIrqR3, VERR_INVALID_POINTER);
+    AssertLogRelMsgReturn(pPciBusReg->u32EndVersion == PDM_PCIBUSREGR3_VERSION,
+                          ("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREGR3_VERSION),
+                          VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppPciHlp, VERR_INVALID_POINTER);
+    AssertPtrNullReturn(piBus, VERR_INVALID_POINTER);
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    Log(("PDM: Registered PCI bus device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
+
+    LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc *piBus=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *piBus));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnIommuRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_IommuRegister(PPDMDEVINS pDevIns, PPDMIOMMUREGR3 pIommuReg, PCPDMIOMMUHLPR3 *ppIommuHlp,
+                                                   uint32_t *pidxIommu)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_IommuRegister: caller='%s'/%d: pIommuReg=%p:{.u32Version=%#x, .u32TheEnd=%#x } ppIommuHlp=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pIommuReg, pIommuReg->u32Version, pIommuReg->u32TheEnd, ppIommuHlp));
+
+    /*
+     * Validate input.
+     */
+    AssertMsgReturn(pIommuReg->u32Version == PDM_IOMMUREGR3_VERSION,
+                    ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIommuReg->u32Version, PDM_IOMMUREGR3_VERSION),
+                    VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pIommuReg->pfnMsiRemap, VERR_INVALID_POINTER);
+    AssertMsgReturn(pIommuReg->u32TheEnd == PDM_IOMMUREGR3_VERSION,
+                    ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIommuReg->u32TheEnd, PDM_IOMMUREGR3_VERSION),
+                    VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppIommuHlp, VERR_INVALID_POINTER);
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed(); RT_NOREF(pidxIommu);
+    Log(("PDM: Registered IOMMU device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
+
+    LogFlow(("pdmR3DevHlp_IommuRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPICRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnGetInterrupt=%p, .u32TheEnd=%#x } ppPicHlp=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrq, pPicReg->pfnGetInterrupt, pPicReg->u32TheEnd, ppPicHlp));
+
+    /*
+     * Validate input.
+     */
+    AssertMsgReturn(pPicReg->u32Version == PDM_PICREG_VERSION,
+                    ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32Version, PDM_PICREG_VERSION),
+                    VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pPicReg->pfnSetIrq, VERR_INVALID_POINTER);
+    AssertPtrReturn(pPicReg->pfnGetInterrupt, VERR_INVALID_POINTER);
+    AssertMsgReturn(pPicReg->u32TheEnd == PDM_PICREG_VERSION,
+                    ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32TheEnd, PDM_PICREG_VERSION),
+                    VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppPicHlp, VERR_INVALID_POINTER);
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
+
+    LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnApicRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_ApicRegister(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_ApicRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnIoApicRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_IoApicRegister(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_IoApicRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnSendMsi=%p, .pfnSetEoi=%p, .u32TheEnd=%#x } ppIoApicHlp=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrq, pIoApicReg->pfnSendMsi, pIoApicReg->pfnSetEoi, pIoApicReg->u32TheEnd, ppIoApicHlp));
+
+    /*
+     * Validate input.
+     */
+    AssertMsgReturn(pIoApicReg->u32Version == PDM_IOAPICREG_VERSION,
+                    ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32Version, PDM_IOAPICREG_VERSION),
+                    VERR_VERSION_MISMATCH);
+    AssertPtrReturn(pIoApicReg->pfnSetIrq, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIoApicReg->pfnSendMsi, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIoApicReg->pfnSetEoi, VERR_INVALID_POINTER);
+    AssertMsgReturn(pIoApicReg->u32TheEnd == PDM_IOAPICREG_VERSION,
+                    ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32TheEnd, PDM_IOAPICREG_VERSION),
+                    VERR_VERSION_MISMATCH);
+    AssertPtrReturn(ppIoApicHlp, VERR_INVALID_POINTER);
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_IoApicRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnHpetRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_HpetRegister(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR3 *ppHpetHlpR3)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_HpetRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+    /*
+     * Validate input.
+     */
+    AssertMsgReturn(pHpetReg->u32Version == PDM_HPETREG_VERSION,
+                    ("%s/%u: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg->u32Version, PDM_HPETREG_VERSION),
+                    VERR_VERSION_MISMATCH);
+    AssertPtrReturn(ppHpetHlpR3, VERR_INVALID_POINTER);
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_HpetRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPciRawRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_PciRawRegister(PPDMDEVINS pDevIns, PPDMPCIRAWREG pPciRawReg, PCPDMPCIRAWHLPR3 *ppPciRawHlpR3)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
+    LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+    /*
+     * Validate input.
+     */
+    if (pPciRawReg->u32Version != PDM_PCIRAWREG_VERSION)
+    {
+        AssertMsgFailed(("u32Version=%#x expected %#x\n", pPciRawReg->u32Version, PDM_PCIRAWREG_VERSION));
+        LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    if (!ppPciRawHlpR3)
+    {
+        Assert(ppPciRawHlpR3);
+        LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc (ppPciRawHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnDMACRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_DMACRegister(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: pDmacReg=%p:{.u32Version=%#x, .pfnRun=%p, .pfnRegister=%p, .pfnReadMemory=%p, .pfnWriteMemory=%p, .pfnSetDREQ=%p, .pfnGetChannelMode=%p} ppDmacHlp=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
+             pDmacReg->pfnReadMemory, pDmacReg->pfnWriteMemory, pDmacReg->pfnSetDREQ, pDmacReg->pfnGetChannelMode, ppDmacHlp));
+
+    /*
+     * Validate input.
+     */
+    if (pDmacReg->u32Version != PDM_DMACREG_VERSION)
+    {
+        AssertMsgFailed(("u32Version=%#x expected %#x\n", pDmacReg->u32Version,
+                         PDM_DMACREG_VERSION));
+        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (version)\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+    if (    !pDmacReg->pfnRun
+        ||  !pDmacReg->pfnRegister
+        ||  !pDmacReg->pfnReadMemory
+        ||  !pDmacReg->pfnWriteMemory
+        ||  !pDmacReg->pfnSetDREQ
+        ||  !pDmacReg->pfnGetChannelMode)
+    {
+        Assert(pDmacReg->pfnRun);
+        Assert(pDmacReg->pfnRegister);
+        Assert(pDmacReg->pfnReadMemory);
+        Assert(pDmacReg->pfnWriteMemory);
+        Assert(pDmacReg->pfnSetDREQ);
+        Assert(pDmacReg->pfnGetChannelMode);
+        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    if (!ppDmacHlp)
+    {
+        Assert(ppDmacHlp);
+        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (ppDmacHlp)\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
+ */
+static DECLCALLBACK(int) pdmR3DevHlp_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbHeap)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: GCPhys=%RGp pvHeap=%p cbHeap=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvHeap, cbHeap));
+
+#ifndef VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+#else
+    int rc = VINF_SUCCESS;
+#endif
+
+    LogFlow(("pdmR3DevHlp_RegisterVMMDevHeap: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{PDMDEVHLPR3,pfnFirmwareRegister}
+ */
+static DECLCALLBACK(int) pdmR3DevHlp_FirmwareRegister(PPDMDEVINS pDevIns, PCPDMFWREG pFwReg, PCPDMFWHLPR3 *ppFwHlp)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: pFWReg=%p:{.u32Version=%#x, .pfnIsHardReset=%p, .u32TheEnd=%#x} ppFwHlp=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pFwReg, pFwReg->u32Version, pFwReg->pfnIsHardReset, pFwReg->u32TheEnd, ppFwHlp));
+
+    /*
+     * Validate input.
+     */
+    if (pFwReg->u32Version != PDM_FWREG_VERSION)
+    {
+        AssertMsgFailed(("u32Version=%#x expected %#x\n", pFwReg->u32Version, PDM_FWREG_VERSION));
+        LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (version)\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+    if (!pFwReg->pfnIsHardReset)
+    {
+        Assert(pFwReg->pfnIsHardReset);
+        LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    if (!ppFwHlp)
+    {
+        Assert(ppFwHlp);
+        LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc (ppFwHlp)\n",
+                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        return VERR_INVALID_PARAMETER;
+    }
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_FirmwareRegister: caller='%s'/%d: returns %Rrc\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMReset} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMReset(PPDMDEVINS pDevIns, uint32_t fFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: fFlags=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, fFlags));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspend} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMSuspend(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d:\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMSuspendSaveAndPowerOff} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMSuspendSaveAndPowerOff(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d:\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_VMSuspendSaveAndPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMPowerOff} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMPowerOff(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d:\n",
+             pDevIns->pReg->szName, pDevIns->iInstance));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnA20IsEnabled} */
+static DECLCALLBACK(bool) pdmR3DevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    bool fRc = false;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance, fRc));
+    return fRc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnA20Set} */
+static DECLCALLBACK(void) pdmR3DevHlp_A20Set(PPDMDEVINS pDevIns, bool fEnable)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, fEnable));
+    AssertFailed();
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnGetCpuId} */
+static DECLCALLBACK(void) pdmR3DevHlp_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
+                                               uint32_t *pEax, uint32_t *pEbx, uint32_t *pEcx, uint32_t *pEdx)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: iLeaf=%d pEax=%p pEbx=%p pEcx=%p pEdx=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
+    AssertPtr(pEax); AssertPtr(pEbx); AssertPtr(pEcx); AssertPtr(pEdx);
+
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - *pEax=%#x *pEbx=%#x *pEcx=%#x *pEdx=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, *pEax, *pEbx, *pEcx, *pEdx));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnGetMainExecutionEngine} */
+static DECLCALLBACK(uint8_t) pdmR3DevHlp_GetMainExecutionEngine(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    //VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
+    LogFlow(("pdmR3DevHlp_GetMainExecutionEngine: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+    return VM_EXEC_ENGINE_NOT_SET;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast,
+                                                                PGMPHYSHANDLERTYPE hType, RTR3PTR pvUserR3, RTR0PTR pvUserR0,
+                                                                RTRCPTR pvUserRC, R3PTRTYPE(const char *) pszDesc)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(GCPhys, GCPhysLast, hType, pvUserR3, pvUserR0, pvUserRC, pszDesc);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalDeregister} */
+static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalDeregister(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(GCPhys);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalPageTempOff} */
+static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalPageTempOff(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(GCPhys, GCPhysPage);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalReset} */
+static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalReset(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(GCPhys);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMMRegisterPatchMemory} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMMRegisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(GCPtrPatchMem, cbPatchMem);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnVMMDeregisterPatchMemory} */
+static DECLCALLBACK(int) pdmR3DevHlp_VMMDeregisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(GCPtrPatchMem, cbPatchMem);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSharedModuleRegister} */
+static DECLCALLBACK(int) pdmR3DevHlp_SharedModuleRegister(PPDMDEVINS pDevIns, VBOXOSFAMILY enmGuestOS, char *pszModuleName, char *pszVersion,
+                                                                    RTGCPTR GCBaseAddr, uint32_t cbModule,
+                                                                    uint32_t cRegions, VMMDEVSHAREDREGIONDESC const *paRegions)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(enmGuestOS, pszModuleName, pszVersion, GCBaseAddr, cbModule, cRegions, paRegions);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSharedModuleUnregister} */
+static DECLCALLBACK(int) pdmR3DevHlp_SharedModuleUnregister(PPDMDEVINS pDevIns, char *pszModuleName, char *pszVersion,
+                                                                      RTGCPTR GCBaseAddr, uint32_t cbModule)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pszModuleName, pszVersion, GCBaseAddr, cbModule);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSharedModuleGetPageState} */
+static DECLCALLBACK(int) pdmR3DevHlp_SharedModuleGetPageState(PPDMDEVINS pDevIns, RTGCPTR GCPtrPage, bool *pfShared, uint64_t *pfPageFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(GCPtrPage, pfShared, pfPageFlags);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnSharedModuleCheckAll} */
+static DECLCALLBACK(int) pdmR3DevHlp_SharedModuleCheckAll(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnQueryLun} */
+static DECLCALLBACK(int) pdmR3DevHlp_QueryLun(PPDMDEVINS pDevIns, const char *pszDevice, unsigned iInstance, unsigned iLun, PPDMIBASE *ppBase)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pszDevice, iInstance, iLun, ppBase);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnGIMDeviceRegister} */
+static DECLCALLBACK(void) pdmR3DevHlp_GIMDeviceRegister(PPDMDEVINS pDevIns, PGIMDEBUG pDbg)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDbg);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnGIMGetDebugSetup} */
+static DECLCALLBACK(int) pdmR3DevHlp_GIMGetDebugSetup(PPDMDEVINS pDevIns, PGIMDEBUGSETUP pDbgSetup)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDbgSetup);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return VERR_ACCESS_DENIED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnGIMGetMmio2Regions} */
+static DECLCALLBACK(PGIMMMIO2REGION) pdmR3DevHlp_GIMGetMmio2Regions(PPDMDEVINS pDevIns, uint32_t *pcRegions)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pcRegions);
+    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
+                            pDevIns->pReg->szName, pDevIns->iInstance));
+    return NULL;
+}
+
+const PDMDEVHLPR3 g_tstDevPdmDevHlpR3 =
+{
+    PDM_DEVHLPR3_VERSION,
+    pdmR3DevHlp_IoPortCreateEx,
+    pdmR3DevHlp_IoPortMap,
+    pdmR3DevHlp_IoPortUnmap,
+    pdmR3DevHlp_IoPortGetMappingAddress,
+    pdmR3DevHlp_IoPortWrite,
+    pdmR3DevHlp_MmioCreateEx,
+    pdmR3DevHlp_MmioMap,
+    pdmR3DevHlp_MmioUnmap,
+    pdmR3DevHlp_MmioReduce,
+    pdmR3DevHlp_MmioGetMappingAddress,
+    pdmR3DevHlp_Mmio2Create,
+    pdmR3DevHlp_Mmio2Destroy,
+    pdmR3DevHlp_Mmio2Map,
+    pdmR3DevHlp_Mmio2Unmap,
+    pdmR3DevHlp_Mmio2Reduce,
+    pdmR3DevHlp_Mmio2GetMappingAddress,
+    pdmR3DevHlp_Mmio2QueryAndResetDirtyBitmap,
+    pdmR3DevHlp_Mmio2ControlDirtyPageTracking,
+    pdmR3DevHlp_Mmio2ChangeRegionNo,
+    pdmR3DevHlp_MmioMapMmio2Page,
+    pdmR3DevHlp_MmioResetRegion,
+    pdmR3DevHlp_ROMRegister,
+    pdmR3DevHlp_ROMProtectShadow,
+    pdmR3DevHlp_SSMRegister,
+    pdmR3DevHlp_SSMRegisterLegacy,
+    pdmR3DevHlp_SSMPutStruct,
+    pdmR3DevHlp_SSMPutStructEx,
+    pdmR3DevHlp_SSMPutBool,
+    pdmR3DevHlp_SSMPutU8,
+    pdmR3DevHlp_SSMPutS8,
+    pdmR3DevHlp_SSMPutU16,
+    pdmR3DevHlp_SSMPutS16,
+    pdmR3DevHlp_SSMPutU32,
+    pdmR3DevHlp_SSMPutS32,
+    pdmR3DevHlp_SSMPutU64,
+    pdmR3DevHlp_SSMPutS64,
+    pdmR3DevHlp_SSMPutU128,
+    pdmR3DevHlp_SSMPutS128,
+    pdmR3DevHlp_SSMPutUInt,
+    pdmR3DevHlp_SSMPutSInt,
+    pdmR3DevHlp_SSMPutGCUInt,
+    pdmR3DevHlp_SSMPutGCUIntReg,
+    pdmR3DevHlp_SSMPutGCPhys32,
+    pdmR3DevHlp_SSMPutGCPhys64,
+    pdmR3DevHlp_SSMPutGCPhys,
+    pdmR3DevHlp_SSMPutGCPtr,
+    pdmR3DevHlp_SSMPutGCUIntPtr,
+    pdmR3DevHlp_SSMPutRCPtr,
+    pdmR3DevHlp_SSMPutIOPort,
+    pdmR3DevHlp_SSMPutSel,
+    pdmR3DevHlp_SSMPutMem,
+    pdmR3DevHlp_SSMPutStrZ,
+    pdmR3DevHlp_SSMGetStruct,
+    pdmR3DevHlp_SSMGetStructEx,
+    pdmR3DevHlp_SSMGetBool,
+    pdmR3DevHlp_SSMGetBoolV,
+    pdmR3DevHlp_SSMGetU8,
+    pdmR3DevHlp_SSMGetU8V,
+    pdmR3DevHlp_SSMGetS8,
+    pdmR3DevHlp_SSMGetS8V,
+    pdmR3DevHlp_SSMGetU16,
+    pdmR3DevHlp_SSMGetU16V,
+    pdmR3DevHlp_SSMGetS16,
+    pdmR3DevHlp_SSMGetS16V,
+    pdmR3DevHlp_SSMGetU32,
+    pdmR3DevHlp_SSMGetU32V,
+    pdmR3DevHlp_SSMGetS32,
+    pdmR3DevHlp_SSMGetS32V,
+    pdmR3DevHlp_SSMGetU64,
+    pdmR3DevHlp_SSMGetU64V,
+    pdmR3DevHlp_SSMGetS64,
+    pdmR3DevHlp_SSMGetS64V,
+    pdmR3DevHlp_SSMGetU128,
+    pdmR3DevHlp_SSMGetU128V,
+    pdmR3DevHlp_SSMGetS128,
+    pdmR3DevHlp_SSMGetS128V,
+    pdmR3DevHlp_SSMGetGCPhys32,
+    pdmR3DevHlp_SSMGetGCPhys32V,
+    pdmR3DevHlp_SSMGetGCPhys64,
+    pdmR3DevHlp_SSMGetGCPhys64V,
+    pdmR3DevHlp_SSMGetGCPhys,
+    pdmR3DevHlp_SSMGetGCPhysV,
+    pdmR3DevHlp_SSMGetUInt,
+    pdmR3DevHlp_SSMGetSInt,
+    pdmR3DevHlp_SSMGetGCUInt,
+    pdmR3DevHlp_SSMGetGCUIntReg,
+    pdmR3DevHlp_SSMGetGCPtr,
+    pdmR3DevHlp_SSMGetGCUIntPtr,
+    pdmR3DevHlp_SSMGetRCPtr,
+    pdmR3DevHlp_SSMGetIOPort,
+    pdmR3DevHlp_SSMGetSel,
+    pdmR3DevHlp_SSMGetMem,
+    pdmR3DevHlp_SSMGetStrZ,
+    pdmR3DevHlp_SSMGetStrZEx,
+    pdmR3DevHlp_SSMSkip,
+    pdmR3DevHlp_SSMSkipToEndOfUnit,
+    pdmR3DevHlp_SSMSetLoadError,
+    pdmR3DevHlp_SSMSetLoadErrorV,
+    pdmR3DevHlp_SSMSetCfgError,
+    pdmR3DevHlp_SSMSetCfgErrorV,
+    pdmR3DevHlp_SSMHandleGetStatus,
+    pdmR3DevHlp_SSMHandleGetAfter,
+    pdmR3DevHlp_SSMHandleIsLiveSave,
+    pdmR3DevHlp_SSMHandleMaxDowntime,
+    pdmR3DevHlp_SSMHandleHostBits,
+    pdmR3DevHlp_SSMHandleRevision,
+    pdmR3DevHlp_SSMHandleVersion,
+    pdmR3DevHlp_SSMHandleHostOSAndArch,
+    pdmR3DevHlp_TimerCreate,
+    pdmR3DevHlp_TimerFromMicro,
+    pdmR3DevHlp_TimerFromMilli,
+    pdmR3DevHlp_TimerFromNano,
+    pdmR3DevHlp_TimerGet,
+    pdmR3DevHlp_TimerGetFreq,
+    pdmR3DevHlp_TimerGetNano,
+    pdmR3DevHlp_TimerIsActive,
+    pdmR3DevHlp_TimerIsLockOwner,
+    pdmR3DevHlp_TimerLockClock,
+    pdmR3DevHlp_TimerLockClock2,
+    pdmR3DevHlp_TimerSet,
+    pdmR3DevHlp_TimerSetFrequencyHint,
+    pdmR3DevHlp_TimerSetMicro,
+    pdmR3DevHlp_TimerSetMillies,
+    pdmR3DevHlp_TimerSetNano,
+    pdmR3DevHlp_TimerSetRelative,
+    pdmR3DevHlp_TimerStop,
+    pdmR3DevHlp_TimerUnlockClock,
+    pdmR3DevHlp_TimerUnlockClock2,
+    pdmR3DevHlp_TimerSetCritSect,
+    pdmR3DevHlp_TimerSave,
+    pdmR3DevHlp_TimerLoad,
+    pdmR3DevHlp_TimerDestroy,
+    pdmR3DevHlp_TimerSkipLoad,
+    pdmR3DevHlp_TMUtcNow,
+    pdmR3DevHlp_CFGMExists,
+    pdmR3DevHlp_CFGMQueryType,
+    pdmR3DevHlp_CFGMQuerySize,
+    pdmR3DevHlp_CFGMQueryInteger,
+    pdmR3DevHlp_CFGMQueryIntegerDef,
+    pdmR3DevHlp_CFGMQueryString,
+    pdmR3DevHlp_CFGMQueryStringDef,
+    pdmR3DevHlp_CFGMQueryPassword,
+    pdmR3DevHlp_CFGMQueryPasswordDef,
+    pdmR3DevHlp_CFGMQueryBytes,
+    pdmR3DevHlp_CFGMQueryU64,
+    pdmR3DevHlp_CFGMQueryU64Def,
+    pdmR3DevHlp_CFGMQueryS64,
+    pdmR3DevHlp_CFGMQueryS64Def,
+    pdmR3DevHlp_CFGMQueryU32,
+    pdmR3DevHlp_CFGMQueryU32Def,
+    pdmR3DevHlp_CFGMQueryS32,
+    pdmR3DevHlp_CFGMQueryS32Def,
+    pdmR3DevHlp_CFGMQueryU16,
+    pdmR3DevHlp_CFGMQueryU16Def,
+    pdmR3DevHlp_CFGMQueryS16,
+    pdmR3DevHlp_CFGMQueryS16Def,
+    pdmR3DevHlp_CFGMQueryU8,
+    pdmR3DevHlp_CFGMQueryU8Def,
+    pdmR3DevHlp_CFGMQueryS8,
+    pdmR3DevHlp_CFGMQueryS8Def,
+    pdmR3DevHlp_CFGMQueryBool,
+    pdmR3DevHlp_CFGMQueryBoolDef,
+    pdmR3DevHlp_CFGMQueryPort,
+    pdmR3DevHlp_CFGMQueryPortDef,
+    pdmR3DevHlp_CFGMQueryUInt,
+    pdmR3DevHlp_CFGMQueryUIntDef,
+    pdmR3DevHlp_CFGMQuerySInt,
+    pdmR3DevHlp_CFGMQuerySIntDef,
+    pdmR3DevHlp_CFGMQueryPtr,
+    pdmR3DevHlp_CFGMQueryPtrDef,
+    pdmR3DevHlp_CFGMQueryGCPtr,
+    pdmR3DevHlp_CFGMQueryGCPtrDef,
+    pdmR3DevHlp_CFGMQueryGCPtrU,
+    pdmR3DevHlp_CFGMQueryGCPtrUDef,
+    pdmR3DevHlp_CFGMQueryGCPtrS,
+    pdmR3DevHlp_CFGMQueryGCPtrSDef,
+    pdmR3DevHlp_CFGMQueryStringAlloc,
+    pdmR3DevHlp_CFGMQueryStringAllocDef,
+    pdmR3DevHlp_CFGMGetParent,
+    pdmR3DevHlp_CFGMGetChild,
+    pdmR3DevHlp_CFGMGetChildF,
+    pdmR3DevHlp_CFGMGetChildFV,
+    pdmR3DevHlp_CFGMGetFirstChild,
+    pdmR3DevHlp_CFGMGetNextChild,
+    pdmR3DevHlp_CFGMGetName,
+    pdmR3DevHlp_CFGMGetNameLen,
+    pdmR3DevHlp_CFGMAreChildrenValid,
+    pdmR3DevHlp_CFGMGetFirstValue,
+    pdmR3DevHlp_CFGMGetNextValue,
+    pdmR3DevHlp_CFGMGetValueName,
+    pdmR3DevHlp_CFGMGetValueNameLen,
+    pdmR3DevHlp_CFGMGetValueType,
+    pdmR3DevHlp_CFGMAreValuesValid,
+    pdmR3DevHlp_CFGMValidateConfig,
+    pdmR3DevHlp_PhysRead,
+    pdmR3DevHlp_PhysWrite,
+    pdmR3DevHlp_PhysGCPhys2CCPtr,
+    pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly,
+    pdmR3DevHlp_PhysReleasePageMappingLock,
+    pdmR3DevHlp_PhysReadGCVirt,
+    pdmR3DevHlp_PhysWriteGCVirt,
+    pdmR3DevHlp_PhysGCPtr2GCPhys,
+    pdmR3DevHlp_PhysIsGCPhysNormal,
+    pdmR3DevHlp_PhysChangeMemBalloon,
+    pdmR3DevHlp_MMHeapAlloc,
+    pdmR3DevHlp_MMHeapAllocZ,
+    pdmR3DevHlp_MMHeapAPrintfV,
+    pdmR3DevHlp_MMHeapFree,
+    pdmR3DevHlp_MMPhysGetRamSize,
+    pdmR3DevHlp_MMPhysGetRamSizeBelow4GB,
+    pdmR3DevHlp_MMPhysGetRamSizeAbove4GB,
+    pdmR3DevHlp_VMState,
+    pdmR3DevHlp_VMTeleportedAndNotFullyResumedYet,
+    pdmR3DevHlp_VMSetErrorV,
+    pdmR3DevHlp_VMSetRuntimeErrorV,
+    pdmR3DevHlp_VMWaitForDeviceReady,
+    pdmR3DevHlp_VMNotifyCpuDeviceReady,
+    pdmR3DevHlp_VMReqCallNoWaitV,
+    pdmR3DevHlp_VMReqPriorityCallWaitV,
+    pdmR3DevHlp_DBGFStopV,
+    pdmR3DevHlp_DBGFInfoRegister,
+    pdmR3DevHlp_DBGFInfoRegisterArgv,
+    pdmR3DevHlp_DBGFRegRegister,
+    pdmR3DevHlp_DBGFTraceBuf,
+    pdmR3DevHlp_DBGFReportBugCheck,
+    pdmR3DevHlp_DBGFCoreWrite,
+    pdmR3DevHlp_DBGFInfoLogHlp,
+    pdmR3DevHlp_DBGFRegNmQueryU64,
+    pdmR3DevHlp_DBGFRegPrintfV,
+    pdmR3DevHlp_STAMRegister,
+    pdmR3DevHlp_STAMRegisterV,
+    pdmR3DevHlp_PCIRegister,
+    pdmR3DevHlp_PCIRegisterMsi,
+    pdmR3DevHlp_PCIIORegionRegister,
+    pdmR3DevHlp_PCIInterceptConfigAccesses,
+    pdmR3DevHlp_PCIConfigWrite,
+    pdmR3DevHlp_PCIConfigRead,
+    pdmR3DevHlp_PCIPhysRead,
+    pdmR3DevHlp_PCIPhysWrite,
+    pdmR3DevHlp_PCIPhysGCPhys2CCPtr,
+    pdmR3DevHlp_PCIPhysGCPhys2CCPtrReadOnly,
+    pdmR3DevHlp_PCIPhysBulkGCPhys2CCPtr,
+    pdmR3DevHlp_PCIPhysBulkGCPhys2CCPtrReadOnly,
+    pdmR3DevHlp_PCISetIrq,
+    pdmR3DevHlp_PCISetIrqNoWait,
+    pdmR3DevHlp_ISASetIrq,
+    pdmR3DevHlp_ISASetIrqNoWait,
+    pdmR3DevHlp_DriverAttach,
+    pdmR3DevHlp_DriverDetach,
+    pdmR3DevHlp_DriverReconfigure,
+    pdmR3DevHlp_QueueCreate,
+    pdmR3DevHlp_QueueAlloc,
+    pdmR3DevHlp_QueueInsert,
+    pdmR3DevHlp_QueueFlushIfNecessary,
+    pdmR3DevHlp_TaskCreate,
+    pdmR3DevHlp_TaskTrigger,
+    pdmR3DevHlp_SUPSemEventCreate,
+    pdmR3DevHlp_SUPSemEventClose,
+    pdmR3DevHlp_SUPSemEventSignal,
+    pdmR3DevHlp_SUPSemEventWaitNoResume,
+    pdmR3DevHlp_SUPSemEventWaitNsAbsIntr,
+    pdmR3DevHlp_SUPSemEventWaitNsRelIntr,
+    pdmR3DevHlp_SUPSemEventGetResolution,
+    pdmR3DevHlp_SUPSemEventMultiCreate,
+    pdmR3DevHlp_SUPSemEventMultiClose,
+    pdmR3DevHlp_SUPSemEventMultiSignal,
+    pdmR3DevHlp_SUPSemEventMultiReset,
+    pdmR3DevHlp_SUPSemEventMultiWaitNoResume,
+    pdmR3DevHlp_SUPSemEventMultiWaitNsAbsIntr,
+    pdmR3DevHlp_SUPSemEventMultiWaitNsRelIntr,
+    pdmR3DevHlp_SUPSemEventMultiGetResolution,
+    pdmR3DevHlp_CritSectInit,
+    pdmR3DevHlp_CritSectGetNop,
+    pdmR3DevHlp_SetDeviceCritSect,
+    pdmR3DevHlp_CritSectYield,
+    pdmR3DevHlp_CritSectEnter,
+    pdmR3DevHlp_CritSectEnterDebug,
+    pdmR3DevHlp_CritSectTryEnter,
+    pdmR3DevHlp_CritSectTryEnterDebug,
+    pdmR3DevHlp_CritSectLeave,
+    pdmR3DevHlp_CritSectIsOwner,
+    pdmR3DevHlp_CritSectIsInitialized,
+    pdmR3DevHlp_CritSectHasWaiters,
+    pdmR3DevHlp_CritSectGetRecursion,
+    pdmR3DevHlp_CritSectScheduleExitEvent,
+    pdmR3DevHlp_CritSectDelete,
+    pdmR3DevHlp_CritSectRwInit,
+    pdmR3DevHlp_CritSectRwDelete,
+    pdmR3DevHlp_CritSectRwEnterShared,
+    pdmR3DevHlp_CritSectRwEnterSharedDebug,
+    pdmR3DevHlp_CritSectRwTryEnterShared,
+    pdmR3DevHlp_CritSectRwTryEnterSharedDebug,
+    pdmR3DevHlp_CritSectRwLeaveShared,
+    pdmR3DevHlp_CritSectRwEnterExcl,
+    pdmR3DevHlp_CritSectRwEnterExclDebug,
+    pdmR3DevHlp_CritSectRwTryEnterExcl,
+    pdmR3DevHlp_CritSectRwTryEnterExclDebug,
+    pdmR3DevHlp_CritSectRwLeaveExcl,
+    pdmR3DevHlp_CritSectRwIsWriteOwner,
+    pdmR3DevHlp_CritSectRwIsReadOwner,
+    pdmR3DevHlp_CritSectRwGetWriteRecursion,
+    pdmR3DevHlp_CritSectRwGetWriterReadRecursion,
+    pdmR3DevHlp_CritSectRwGetReadCount,
+    pdmR3DevHlp_CritSectRwIsInitialized,
+    pdmR3DevHlp_ThreadCreate,
+    pdmR3DevHlp_ThreadDestroy,
+    pdmR3DevHlp_ThreadIAmSuspending,
+    pdmR3DevHlp_ThreadIamRunning,
+    pdmR3DevHlp_ThreadSleep,
+    pdmR3DevHlp_ThreadSuspend,
+    pdmR3DevHlp_ThreadResume,
+    pdmR3DevHlp_SetAsyncNotification,
+    pdmR3DevHlp_AsyncNotificationCompleted,
+    pdmR3DevHlp_RTCRegister,
+    pdmR3DevHlp_PCIBusRegister,
+    pdmR3DevHlp_IommuRegister,
+    pdmR3DevHlp_PICRegister,
+    pdmR3DevHlp_ApicRegister,
+    pdmR3DevHlp_IoApicRegister,
+    pdmR3DevHlp_HpetRegister,
+    pdmR3DevHlp_PciRawRegister,
+    pdmR3DevHlp_DMACRegister,
+    pdmR3DevHlp_DMARegister,
+    pdmR3DevHlp_DMAReadMemory,
+    pdmR3DevHlp_DMAWriteMemory,
+    pdmR3DevHlp_DMASetDREQ,
+    pdmR3DevHlp_DMAGetChannelMode,
+    pdmR3DevHlp_DMASchedule,
+    pdmR3DevHlp_CMOSWrite,
+    pdmR3DevHlp_CMOSRead,
+    pdmR3DevHlp_AssertEMT,
+    pdmR3DevHlp_AssertOther,
+    pdmR3DevHlp_LdrGetRCInterfaceSymbols,
+    pdmR3DevHlp_LdrGetR0InterfaceSymbols,
+    pdmR3DevHlp_CallR0,
+    pdmR3DevHlp_VMGetSuspendReason,
+    pdmR3DevHlp_VMGetResumeReason,
+    pdmR3DevHlp_PhysBulkGCPhys2CCPtr,
+    pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly,
+    pdmR3DevHlp_PhysBulkReleasePageMappingLocks,
+    pdmR3DevHlp_CpuGetGuestMicroarch,
+    pdmR3DevHlp_CpuGetGuestAddrWidths,
+    pdmR3DevHlp_CpuGetGuestScalableBusFrequency,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    pdmR3DevHlp_GetUVM,
+    pdmR3DevHlp_GetVM,
+    pdmR3DevHlp_GetVMCPU,
+    pdmR3DevHlp_GetCurrentCpuId,
+    pdmR3DevHlp_RegisterVMMDevHeap,
+    pdmR3DevHlp_FirmwareRegister,
+    pdmR3DevHlp_VMReset,
+    pdmR3DevHlp_VMSuspend,
+    pdmR3DevHlp_VMSuspendSaveAndPowerOff,
+    pdmR3DevHlp_VMPowerOff,
+    pdmR3DevHlp_A20IsEnabled,
+    pdmR3DevHlp_A20Set,
+    pdmR3DevHlp_GetCpuId,
+    pdmR3DevHlp_GetMainExecutionEngine,
+    pdmR3DevHlp_TMTimeVirtGet,
+    pdmR3DevHlp_TMTimeVirtGetFreq,
+    pdmR3DevHlp_TMTimeVirtGetNano,
+    pdmR3DevHlp_TMCpuTicksPerSecond,
+    pdmR3DevHlp_GetSupDrvSession,
+    pdmR3DevHlp_QueryGenericUserObject,
+    pdmR3DevHlp_PGMHandlerPhysicalTypeRegister,
+    pdmR3DevHlp_PGMHandlerPhysicalRegister,
+    pdmR3DevHlp_PGMHandlerPhysicalDeregister,
+    pdmR3DevHlp_PGMHandlerPhysicalPageTempOff,
+    pdmR3DevHlp_PGMHandlerPhysicalReset,
+    pdmR3DevHlp_VMMRegisterPatchMemory,
+    pdmR3DevHlp_VMMDeregisterPatchMemory,
+    pdmR3DevHlp_SharedModuleRegister,
+    pdmR3DevHlp_SharedModuleUnregister,
+    pdmR3DevHlp_SharedModuleGetPageState,
+    pdmR3DevHlp_SharedModuleCheckAll,
+    pdmR3DevHlp_QueryLun,
+    pdmR3DevHlp_GIMDeviceRegister,
+    pdmR3DevHlp_GIMGetDebugSetup,
+    pdmR3DevHlp_GIMGetMmio2Regions,
+    PDM_DEVHLPR3_VERSION /* the end */
+};
+
diff --git a/src/VBox/Devices/testcase/tstDevicePdmDevHlpR0.cpp b/src/VBox/Devices/testcase/tstDevicePdmDevHlpR0.cpp
new file mode 100644
index 00000000..5a990c72
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDevicePdmDevHlpR0.cpp
@@ -0,0 +1,1523 @@
+/* $Id: tstDevicePdmDevHlpR0.cpp $ */
+/** @file
+ * tstDevice - Test framework for PDM devices/drivers, PDM fake R0 helper implementation.
+ */
+
+/*
+ * Copyright (C) 2021-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
+#undef IN_RING3
+#undef IN_SUP_R3
+#define IN_RING0
+#define IN_SUP_R0
+#define LINUX_VERSION_CODE 0
+#define KERNEL_VERSION(a,b,c) 1
+#include <iprt/linux/version.h>
+#include <VBox/types.h>
+#include <VBox/version.h>
+#include <VBox/vmm/pdmpci.h>
+
+#include <iprt/assert.h>
+#include <iprt/mem.h>
+#include <iprt/rand.h>
+#include <iprt/string.h>
+
+#include "tstDeviceInternal.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+
+/* Temporarily until the stubs got implemented. */
+#define VBOX_TSTDEV_NOT_IMPLEMENTED_STUBS_FAKE_SUCCESS 1
+
+/** @def PDMDEV_ASSERT_DEVINS
+ * Asserts the validity of the device instance.
+ */
+#ifdef VBOX_STRICT
+# define PDMDEV_ASSERT_DEVINS(pDevIns)   \
+    do { \
+        AssertPtr(pDevIns); \
+        Assert(pDevIns->u32Version == PDM_DEVINS_VERSION); \
+        Assert(pDevIns->CTX_SUFF(pvInstanceDataFor) == (void *)&pDevIns->achInstanceData[0]); \
+    } while (0)
+#else
+# define PDMDEV_ASSERT_DEVINS(pDevIns)   do { } while (0)
+#endif
+
+
+/** Frequency of the real clock. */
+#define TMCLOCK_FREQ_REAL       UINT32_C(1000)
+/** Frequency of the virtual clock. */
+#define TMCLOCK_FREQ_VIRTUAL    UINT32_C(1000000000)
+
+#undef RT_VALID_PTR
+#define RT_VALID_PTR(ptr) true
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnIoPortSetUpContextEx} */
+static DECLCALLBACK(int) pdmR0DevHlp_IoPortSetUpContextEx(PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts,
+                                                          PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
+                                                          PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr,
+                                                          void *pvUser)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_IoPortSetUpContextEx: caller='%s'/%d: hIoPorts=%#x pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p pvUser=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hIoPorts, pfnOut, pfnIn, pfnOutStr, pfnInStr, pvUser));
+
+    int rc = VINF_SUCCESS;
+    PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)hIoPorts;
+    if (RT_LIKELY(pIoPort))
+    {
+        pIoPort->pvUserR0    = pvUser;
+        pIoPort->pfnOutR0    = pfnOut;
+        pIoPort->pfnInR0     = pfnIn;
+        pIoPort->pfnOutStrR0 = pfnOutStr;
+        pIoPort->pfnInStrR0  = pfnInStr;
+    }
+    else
+        AssertReleaseFailed();
+
+    LogFlow(("pdmR0DevHlp_IoPortSetUpContextEx: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnMmioSetUpContextEx} */
+static DECLCALLBACK(int) pdmR0DevHlp_MmioSetUpContextEx(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, PFNIOMMMIONEWWRITE pfnWrite,
+                                                        PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill, void *pvUser)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_MmioSetUpContextEx: caller='%s'/%d: hRegion=%#x pfnWrite=%p pfnRead=%p pfnFill=%p pvUser=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hRegion, pfnWrite, pfnRead, pfnFill, pvUser));
+
+    int rc = VINF_SUCCESS;
+    PRTDEVDUTMMIO pMmio = (PRTDEVDUTMMIO)hRegion;
+    if (RT_LIKELY(pMmio))
+    {
+        pMmio->pvUserR0    = pvUser;
+        pMmio->pfnWriteR0  = pfnWrite;
+        pMmio->pfnReadR0   = pfnRead;
+        pMmio->pfnFillR0   = pfnFill;
+    }
+    else
+        AssertReleaseFailed();
+
+    LogFlow(("pdmR0DevHlp_MmioSetUpContextEx: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnMmio2SetUpContext} */
+static DECLCALLBACK(int) pdmR0DevHlp_Mmio2SetUpContext(PPDMDEVINS pDevIns, PGMMMIO2HANDLE hRegion,
+                                                       size_t offSub, size_t cbSub, void **ppvMapping)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_Mmio2SetUpContext: caller='%s'/%d: hRegion=%#x offSub=%#zx cbSub=%#zx ppvMapping=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hRegion, offSub, cbSub, ppvMapping));
+    *ppvMapping = NULL;
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR0DevHlp_Mmio2SetUpContext: caller='%s'/%d: returns %Rrc (%p)\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *ppvMapping));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnPCIPhysRead} */
+static DECLCALLBACK(int) pdmR0DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
+                                                 void *pvBuf, size_t cbRead, uint32_t fFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
+
+#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
+    /*
+     * Just check the busmaster setting here and forward the request to the generic read helper.
+     */
+    if (PCIDevIsBusmaster(pPciDev))
+    { /* likely */ }
+    else
+    {
+        LogFunc(("caller=%p/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbRead=%#zx\n", pDevIns, pDevIns->iInstance,
+                 VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbRead));
+        memset(pvBuf, 0xff, cbRead);
+        return VERR_PDM_NOT_PCI_BUS_MASTER;
+    }
+#endif
+
+    return pDevIns->pHlpR0->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead, fFlags);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnPCIPhysWrite} */
+static DECLCALLBACK(int) pdmR0DevHlp_PCIPhysWrite(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys,
+                                                  const void *pvBuf, size_t cbWrite, uint32_t fFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturn(pPciDev, VERR_PDM_NOT_PCI_DEVICE);
+    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
+
+#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
+    /*
+     * Just check the busmaster setting here and forward the request to the generic read helper.
+     */
+    if (PCIDevIsBusmaster(pPciDev))
+    { /* likely */ }
+    else
+    {
+        LogFunc(("caller=%p/%d: returns %Rrc - Not bus master! GCPhys=%RGp cbWrite=%#zx\n", pDevIns, pDevIns->iInstance,
+                 VERR_PDM_NOT_PCI_BUS_MASTER, GCPhys, cbWrite));
+        return VERR_PDM_NOT_PCI_BUS_MASTER;
+    }
+#endif
+
+    return pDevIns->pHlpR0->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite, fFlags);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnPCISetIrq} */
+static DECLCALLBACK(void) pdmR0DevHlp_PCISetIrq(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iIrq, int iLevel)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    if (!pPciDev) /* NULL is an alias for the default PCI device. */
+        pPciDev = pDevIns->apPciDevs[0];
+    AssertReturnVoid(pPciDev);
+    LogFlow(("pdmR0DevHlp_PCISetIrq: caller=%p/%d: pPciDev=%p:{%#x} iIrq=%d iLevel=%d\n",
+             pDevIns, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iIrq, iLevel));
+    PDMPCIDEV_ASSERT_VALID_AND_REGISTERED(pDevIns, pPciDev);
+
+    AssertFailed();
+
+    LogFlow(("pdmR0DevHlp_PCISetIrq: caller=%p/%d: returns void; uTagSrc=%#x\n", pDevIns, pDevIns->iInstance, 0 /*uTagSrc*/));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnISASetIrq} */
+static DECLCALLBACK(void) pdmR0DevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_ISASetIrq: caller=%p/%d: iIrq=%d iLevel=%d\n", pDevIns, pDevIns->iInstance, iIrq, iLevel));
+
+    AssertFailed();
+
+    LogFlow(("pdmR0DevHlp_ISASetIrq: caller=%p/%d: returns void; uTagSrc=%#x\n", pDevIns, pDevIns->iInstance, 0 /*uTagSrc*/));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnPhysRead} */
+static DECLCALLBACK(int) pdmR0DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead, uint32_t fFlags)
+{
+    RT_NOREF(fFlags);
+
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_PhysRead: caller=%p/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
+             pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
+
+    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    Log(("pdmR0DevHlp_PhysRead: caller=%p/%d: returns %Rrc\n", pDevIns, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
+    return VBOXSTRICTRC_VAL(rcStrict);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnPhysWrite} */
+static DECLCALLBACK(int) pdmR0DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite, uint32_t fFlags)
+{
+    RT_NOREF(fFlags);
+
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_PhysWrite: caller=%p/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
+             pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
+
+    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    Log(("pdmR0DevHlp_PhysWrite: caller=%p/%d: returns %Rrc\n", pDevIns, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
+    return VBOXSTRICTRC_VAL(rcStrict);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnA20IsEnabled} */
+static DECLCALLBACK(bool) pdmR0DevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_A20IsEnabled: caller=%p/%d:\n", pDevIns, pDevIns->iInstance));
+
+    bool fEnabled = false;
+    AssertFailed();
+
+    Log(("pdmR0DevHlp_A20IsEnabled: caller=%p/%d: returns %RTbool\n", pDevIns, pDevIns->iInstance, fEnabled));
+    return fEnabled;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnVMState} */
+static DECLCALLBACK(VMSTATE) pdmR0DevHlp_VMState(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    VMSTATE enmVMState = VMSTATE_CREATING;// pDevIns->Internal.s.pGVM->enmVMState;
+
+    LogFlow(("pdmR0DevHlp_VMState: caller=%p/%d: returns %d\n", pDevIns, pDevIns->iInstance, enmVMState));
+    return enmVMState;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnGetVM} */
+static DECLCALLBACK(PVMCC)  pdmR0DevHlp_GetVM(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_GetVM: caller='%p'/%d\n", pDevIns, pDevIns->iInstance));
+    AssertFailed();
+    return NULL; //pDevIns->Internal.s.pGVM;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnGetVMCPU} */
+static DECLCALLBACK(PVMCPUCC) pdmR0DevHlp_GetVMCPU(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_GetVMCPU: caller='%p'/%d\n", pDevIns, pDevIns->iInstance));
+    AssertFailed();
+    return NULL; //VMMGetCpu(pDevIns->Internal.s.pGVM);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPRC,pfnGetCurrentCpuId} */
+static DECLCALLBACK(VMCPUID) pdmR0DevHlp_GetCurrentCpuId(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_GetCurrentCpuId: caller='%p'/%d for CPU %u\n", pDevIns, pDevIns->iInstance, 0 /*idCpu*/));
+    AssertFailed();
+    return 0; //idCpu;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnGetMainExecutionEngine} */
+static DECLCALLBACK(uint8_t) pdmR0DevHlp_GetMainExecutionEngine(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_GetMainExecutionEngine: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+    return VM_EXEC_ENGINE_NOT_SET;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerFromMicro} */
+static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return 0; //TMTimerFromMicro(pDevIns->Internal.s.pGVM, hTimer, cMicroSecs);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerFromMilli} */
+static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerFromMilli(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliSecs)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerFromNano} */
+static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return 0;
+}
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerGet} */
+static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerGetFreq} */
+static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerGetNano} */
+static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerIsActive} */
+static DECLCALLBACK(bool) pdmR0DevHlp_TimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return false;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerIsLockOwner} */
+static DECLCALLBACK(bool) pdmR0DevHlp_TimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return false;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerLockClock} */
+static DECLCALLBACK(VBOXSTRICTRC) pdmR0DevHlp_TimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerLockClock2} */
+static DECLCALLBACK(VBOXSTRICTRC) pdmR0DevHlp_TimerLockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer,
+                                                              PPDMCRITSECT pCritSect, int rcBusy)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerSet} */
+static DECLCALLBACK(int) pdmR0DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerSetFrequencyHint} */
+static DECLCALLBACK(int) pdmR0DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerSetMicro} */
+static DECLCALLBACK(int) pdmR0DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerSetMillies} */
+static DECLCALLBACK(int) pdmR0DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerSetNano} */
+static DECLCALLBACK(int) pdmR0DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerSetRelative} */
+static DECLCALLBACK(int) pdmR0DevHlp_TimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerStop} */
+static DECLCALLBACK(int) pdmR0DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerUnlockClock} */
+static DECLCALLBACK(void) pdmR0DevHlp_TimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTimerUnlockClock2} */
+static DECLCALLBACK(void) pdmR0DevHlp_TimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTMTimeVirtGet} */
+static DECLCALLBACK(uint64_t) pdmR0DevHlp_TMTimeVirtGet(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_TMTimeVirtGet: caller='%p'/%d\n", pDevIns, pDevIns->iInstance));
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTMTimeVirtGetFreq} */
+static DECLCALLBACK(uint64_t) pdmR0DevHlp_TMTimeVirtGetFreq(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_TMTimeVirtGetFreq: caller='%p'/%d\n", pDevIns, pDevIns->iInstance));
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTMTimeVirtGetNano} */
+static DECLCALLBACK(uint64_t) pdmR0DevHlp_TMTimeVirtGetNano(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_TMTimeVirtGetNano: caller='%p'/%d\n", pDevIns, pDevIns->iInstance));
+    AssertFailed();
+    return 0;
+}
+
+
+/** Converts a queue handle to a ring-0 queue pointer. */
+DECLINLINE(PPDMQUEUE)  pdmR0DevHlp_QueueToPtr(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return NULL;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnQueueAlloc} */
+static DECLCALLBACK(PPDMQUEUEITEMCORE) pdmR0DevHlp_QueueAlloc(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
+{
+    AssertFailed();
+    return NULL; //PDMQueueAlloc(pdmR0DevHlp_QueueToPtr(pDevIns, hQueue));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnQueueInsert} */
+static DECLCALLBACK(void) pdmR0DevHlp_QueueInsert(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem)
+{
+    AssertFailed();
+    //return PDMQueueInsert(pdmR0DevHlp_QueueToPtr(pDevIns, hQueue), pItem);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnQueueFlushIfNecessary} */
+static DECLCALLBACK(bool) pdmR0DevHlp_QueueFlushIfNecessary(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
+{
+    AssertFailed();
+    return false; //PDMQueueFlushIfNecessary(pdmR0DevHlp_QueueToPtr(pDevIns, hQueue));
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnTaskTrigger} */
+static DECLCALLBACK(int) pdmR0DevHlp_TaskTrigger(PPDMDEVINS pDevIns, PDMTASKHANDLE hTask)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_TaskTrigger: caller='%s'/%d: hTask=%RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, hTask));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //PDMTaskTrigger(pDevIns->Internal.s.pGVM, PDMTASKTYPE_DEV, pDevIns->pDevInsForR3, hTask);
+
+    LogFlow(("pdmR0DevHlp_TaskTrigger: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventSignal} */
+static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventSignal(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventSignal: caller='%s'/%d: hEvent=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEvent));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventSignal(pDevIns->Internal.s.pGVM->pSession, hEvent);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventWaitNoResume} */
+static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint32_t cMillies)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: hEvent=%p cNsTimeout=%RU32\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cMillies));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventWaitNoResume(pDevIns->Internal.s.pGVM->pSession, hEvent, cMillies);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventWaitNsAbsIntr} */
+static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t uNsTimeout)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: hEvent=%p uNsTimeout=%RU64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEvent, uNsTimeout));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventWaitNsAbsIntr(pDevIns->Internal.s.pGVM->pSession, hEvent, uNsTimeout);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventWaitNsRelIntr} */
+static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENT hEvent, uint64_t cNsTimeout)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: hEvent=%p cNsTimeout=%RU64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEvent, cNsTimeout));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventWaitNsRelIntr(pDevIns->Internal.s.pGVM->pSession, hEvent, cNsTimeout);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventGetResolution} */
+static DECLCALLBACK(uint32_t) pdmR0DevHlp_SUPSemEventGetResolution(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+    AssertFailed();
+    uint32_t cNsResolution = 0; //SUPSemEventGetResolution(pDevIns->Internal.s.pGVM->pSession);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
+    return cNsResolution;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiSignal} */
+static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventMultiSignal(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventMultiSignal(pDevIns->Internal.s.pGVM->pSession, hEventMulti);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiSignal: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiReset} */
+static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventMultiReset(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiReset: caller='%s'/%d: hEventMulti=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventMultiReset(pDevIns->Internal.s.pGVM->pSession, hEventMulti);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiWaitNoResume} */
+static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventMultiWaitNoResume(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
+                                                                  uint32_t cMillies)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: hEventMulti=%p cMillies=%RU32\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cMillies));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventMultiWaitNoResume(pDevIns->Internal.s.pGVM->pSession, hEventMulti, cMillies);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNoResume: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiWaitNsAbsIntr} */
+static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventMultiWaitNsAbsIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
+                                                                   uint64_t uNsTimeout)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: hEventMulti=%p uNsTimeout=%RU64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, uNsTimeout));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventMultiWaitNsAbsIntr(pDevIns->Internal.s.pGVM->pSession, hEventMulti, uNsTimeout);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNsAbsIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiWaitNsRelIntr} */
+static DECLCALLBACK(int) pdmR0DevHlp_SUPSemEventMultiWaitNsRelIntr(PPDMDEVINS pDevIns, SUPSEMEVENTMULTI hEventMulti,
+                                                                   uint64_t cNsTimeout)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: hEventMulti=%p cNsTimeout=%RU64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hEventMulti, cNsTimeout));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //SUPSemEventMultiWaitNsRelIntr(pDevIns->Internal.s.pGVM->pSession, hEventMulti, cNsTimeout);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiWaitNsRelIntr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSUPSemEventMultiGetResolution} */
+static DECLCALLBACK(uint32_t) pdmR0DevHlp_SUPSemEventMultiGetResolution(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+
+    AssertFailed();
+    uint32_t cNsResolution = 0; //SUPSemEventMultiGetResolution(pDevIns->Internal.s.pGVM->pSession);
+
+    LogFlow(("pdmR0DevHlp_SUPSemEventMultiGetResolution: caller='%s'/%d: returns %u\n", pDevIns->pReg->szName, pDevIns->iInstance, cNsResolution));
+    return cNsResolution;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectGetNop} */
+static DECLCALLBACK(PPDMCRITSECT) pdmR0DevHlp_CritSectGetNop(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    PPDMCRITSECT pCritSect = &pDevIns->Internal.s.pDut->CritSectNop;
+    LogFlow(("pdmR0DevHlp_CritSectGetNop: caller='%s'/%d: return %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
+    return pCritSect;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnSetDeviceCritSect} */
+static DECLCALLBACK(int) pdmR0DevHlp_SetDeviceCritSect(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
+{
+    /*
+     * Validate input.
+     *
+     * Note! We only allow the automatically created default critical section
+     *       to be replaced by this API.
+     */
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertPtrReturn(pCritSect, VERR_INVALID_POINTER);
+    LogFlow(("pdmR0DevHlp_SetDeviceCritSect: caller='%s'/%d: pCritSect=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
+    AssertReturn(RTCritSectIsInitialized(&pCritSect->s.CritSect), VERR_INVALID_PARAMETER);
+
+    pDevIns->pCritSectRoR0 = pCritSect;
+
+    LogFlow(("pdmR0DevHlp_SetDeviceCritSect: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectEnter} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectEnter(pDevIns->Internal.s.pGVM, pCritSect, rcBusy);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectEnterDebug} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectEnterDebug(pDevIns->Internal.s.pGVM, pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectTryEnter} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectTryEnter(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectTryEnter(pDevIns->Internal.s.pGVM, pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectTryEnterDebug} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectTryEnterDebug(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectTryEnterDebug(pDevIns->Internal.s.pGVM, pCritSect, uId, RT_SRC_POS_ARGS);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectLeave} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectLeave(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectLeave(pDevIns->Internal.s.pGVM, pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectIsOwner} */
+static DECLCALLBACK(bool)     pdmR0DevHlp_CritSectIsOwner(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectIsOwner(pDevIns->Internal.s.pGVM, pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectIsInitialized} */
+static DECLCALLBACK(bool)     pdmR0DevHlp_CritSectIsInitialized(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectIsInitialized(pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectHasWaiters} */
+static DECLCALLBACK(bool)     pdmR0DevHlp_CritSectHasWaiters(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectHasWaiters(pDevIns->Internal.s.pGVM, pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectGetRecursion} */
+static DECLCALLBACK(uint32_t) pdmR0DevHlp_CritSectGetRecursion(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectGetRecursion(pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectScheduleExitEvent} */
+static DECLCALLBACK(int) pdmR0DevHlp_CritSectScheduleExitEvent(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect,
+                                                               SUPSEMEVENT hEventToSignal)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMHCCritSectScheduleExitEvent(pCritSect, hEventToSignal);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwEnterShared} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectRwEnterShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectRwEnterShared(pDevIns->Internal.s.pGVM, pCritSect, rcBusy);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwEnterSharedDebug} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectRwEnterSharedDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy,
+                                                                     RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectRwEnterSharedDebug(pDevIns->Internal.s.pGVM, pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
+}
+
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwTryEnterShared} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectRwTryEnterShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectRwTryEnterShared(pDevIns->Internal.s.pGVM, pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwTryEnterSharedDebug} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectRwTryEnterSharedDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect,
+                                                                        RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectRwTryEnterSharedDebug(pDevIns->Internal.s.pGVM, pCritSect, uId, RT_SRC_POS_ARGS);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwLeaveShared} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectRwLeaveShared(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectRwLeaveShared(pDevIns->Internal.s.pGVM, pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwEnterExcl} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectRwEnterExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectRwEnterExcl(pDevIns->Internal.s.pGVM, pCritSect, rcBusy);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwEnterExclDebug} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectRwEnterExclDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, int rcBusy,
+                                                                   RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectRwEnterExclDebug(pDevIns->Internal.s.pGVM, pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwTryEnterExcl} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectRwTryEnterExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectRwTryEnterExcl(pDevIns->Internal.s.pGVM, pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwTryEnterExclDebug} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectRwTryEnterExclDebug(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect,
+                                                                      RTHCUINTPTR uId, RT_SRC_POS_DECL)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectRwTryEnterExclDebug(pDevIns->Internal.s.pGVM, pCritSect, uId, RT_SRC_POS_ARGS);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwLeaveExcl} */
+static DECLCALLBACK(int)      pdmR0DevHlp_CritSectRwLeaveExcl(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED; //PDMCritSectRwLeaveExcl(pDevIns->Internal.s.pGVM, pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwIsWriteOwner} */
+static DECLCALLBACK(bool)     pdmR0DevHlp_CritSectRwIsWriteOwner(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return false; //PDMCritSectRwIsWriteOwner(pDevIns->Internal.s.pGVM, pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwIsReadOwner} */
+static DECLCALLBACK(bool)     pdmR0DevHlp_CritSectRwIsReadOwner(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect, bool fWannaHear)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    return false; //PDMCritSectRwIsReadOwner(pDevIns->Internal.s.pGVM, pCritSect, fWannaHear);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwGetWriteRecursion} */
+static DECLCALLBACK(uint32_t) pdmR0DevHlp_CritSectRwGetWriteRecursion(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns);
+    AssertFailed();
+    return 0; //PDMCritSectRwGetWriteRecursion(pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwGetWriterReadRecursion} */
+static DECLCALLBACK(uint32_t) pdmR0DevHlp_CritSectRwGetWriterReadRecursion(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns);
+    AssertFailed();
+    return 0; //PDMCritSectRwGetWriterReadRecursion(pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwGetReadCount} */
+static DECLCALLBACK(uint32_t) pdmR0DevHlp_CritSectRwGetReadCount(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns);
+    AssertFailed();
+    return 0; //PDMCritSectRwGetReadCount(pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnCritSectRwIsInitialized} */
+static DECLCALLBACK(bool)     pdmR0DevHlp_CritSectRwIsInitialized(PPDMDEVINS pDevIns, PPDMCRITSECTRW pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns);
+    AssertFailed();
+    return false; //PDMCritSectRwIsInitialized(pCritSect);
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnDBGFTraceBuf} */
+static DECLCALLBACK(RTTRACEBUF) pdmR0DevHlp_DBGFTraceBuf(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    AssertFailed();
+    RTTRACEBUF hTraceBuf = NULL; //pDevIns->Internal.s.pGVM->hTraceBufR0;
+    LogFlow(("pdmR0DevHlp_DBGFTraceBuf: caller='%p'/%d: returns %p\n", pDevIns, pDevIns->iInstance, hTraceBuf));
+    return hTraceBuf;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnPCIBusSetUpContext} */
+static DECLCALLBACK(int) pdmR0DevHlp_PCIBusSetUpContext(PPDMDEVINS pDevIns, PPDMPCIBUSREGR0 pPciBusReg, PCPDMPCIHLPR0 *ppPciHlp)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_PCIBusSetUpContext: caller='%p'/%d: pPciBusReg=%p{.u32Version=%#x, .iBus=%#u, .pfnSetIrq=%p, u32EnvVersion=%#x} ppPciHlp=%p\n",
+             pDevIns, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->iBus, pPciBusReg->pfnSetIrq,
+             pPciBusReg->u32EndVersion, ppPciHlp));
+#if 0
+    PGVM pGVM = pDevIns->Internal.s.pGVM;
+
+    /*
+     * Validate input.
+     */
+    AssertPtrReturn(pPciBusReg, VERR_INVALID_POINTER);
+    AssertLogRelMsgReturn(pPciBusReg->u32Version == PDM_PCIBUSREGCC_VERSION,
+                          ("%#x vs %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREGCC_VERSION), VERR_VERSION_MISMATCH);
+    AssertPtrReturn(pPciBusReg->pfnSetIrq, VERR_INVALID_POINTER);
+    AssertLogRelMsgReturn(pPciBusReg->u32EndVersion == PDM_PCIBUSREGCC_VERSION,
+                          ("%#x vs %#x\n", pPciBusReg->u32EndVersion, PDM_PCIBUSREGCC_VERSION), VERR_VERSION_MISMATCH);
+
+    AssertPtrReturn(ppPciHlp, VERR_INVALID_POINTER);
+
+    VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
+    VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
+
+    /* Check the shared bus data (registered earlier from ring-3): */
+    uint32_t iBus = pPciBusReg->iBus;
+    ASMCompilerBarrier();
+    AssertLogRelMsgReturn(iBus < RT_ELEMENTS(pGVM->pdm.s.aPciBuses), ("iBus=%#x\n", iBus), VERR_OUT_OF_RANGE);
+    PPDMPCIBUS pPciBusShared = &pGVM->pdm.s.aPciBuses[iBus];
+    AssertLogRelMsgReturn(pPciBusShared->iBus == iBus, ("%u vs %u\n", pPciBusShared->iBus, iBus), VERR_INVALID_PARAMETER);
+    AssertLogRelMsgReturn(pPciBusShared->pDevInsR3 == pDevIns->pDevInsForR3,
+                          ("%p vs %p (iBus=%u)\n", pPciBusShared->pDevInsR3, pDevIns->pDevInsForR3, iBus), VERR_NOT_OWNER);
+
+    /* Check that the bus isn't already registered in ring-0: */
+    AssertCompile(RT_ELEMENTS(pGVM->pdm.s.aPciBuses) == RT_ELEMENTS(pGVM->pdmr0.s.aPciBuses));
+    PPDMPCIBUSR0 pPciBusR0 = &pGVM->pdmr0.s.aPciBuses[iBus];
+    AssertLogRelMsgReturn(pPciBusR0->pDevInsR0 == NULL,
+                          ("%p (caller pDevIns=%p, iBus=%u)\n", pPciBusR0->pDevInsR0, pDevIns, iBus),
+                          VERR_ALREADY_EXISTS);
+
+    /*
+     * Do the registering.
+     */
+    pPciBusR0->iBus        = iBus;
+    pPciBusR0->uPadding0   = 0xbeefbeef;
+    pPciBusR0->pfnSetIrqR0 = pPciBusReg->pfnSetIrq;
+    pPciBusR0->pDevInsR0   = pDevIns;
+#endif
+
+    AssertFailed();
+    *ppPciHlp = NULL; //&g_pdmR0PciHlp;
+
+    LogFlow(("pdmR0DevHlp_PCIBusSetUpContext: caller='%p'/%d: returns VINF_SUCCESS\n", pDevIns, pDevIns->iInstance));
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnIommuSetUpContext} */
+static DECLCALLBACK(int) pdmR0DevHlp_IommuSetUpContext(PPDMDEVINS pDevIns, PPDMIOMMUREGR0 pIommuReg, PCPDMIOMMUHLPR0 *ppIommuHlp)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_IommuSetUpContext: caller='%p'/%d: pIommuReg=%p{.u32Version=%#x, u32TheEnd=%#x} ppIommuHlp=%p\n",
+             pDevIns, pDevIns->iInstance, pIommuReg, pIommuReg->u32Version, pIommuReg->u32TheEnd, ppIommuHlp));
+#if 0
+    PGVM pGVM = pDevIns->Internal.s.pGVM;
+
+    /*
+     * Validate input.
+     */
+    AssertPtrReturn(pIommuReg, VERR_INVALID_POINTER);
+    AssertLogRelMsgReturn(pIommuReg->u32Version == PDM_IOMMUREGCC_VERSION,
+                          ("%#x vs %#x\n", pIommuReg->u32Version, PDM_IOMMUREGCC_VERSION), VERR_VERSION_MISMATCH);
+    AssertPtrReturn(pIommuReg->pfnMemAccess,     VERR_INVALID_POINTER);
+    AssertPtrReturn(pIommuReg->pfnMemBulkAccess, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIommuReg->pfnMsiRemap,      VERR_INVALID_POINTER);
+    AssertLogRelMsgReturn(pIommuReg->u32TheEnd == PDM_IOMMUREGCC_VERSION,
+                          ("%#x vs %#x\n", pIommuReg->u32TheEnd, PDM_IOMMUREGCC_VERSION), VERR_VERSION_MISMATCH);
+
+    AssertPtrReturn(ppIommuHlp, VERR_INVALID_POINTER);
+
+    VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
+    VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
+
+    /* Check the IOMMU shared data (registered earlier from ring-3). */
+    uint32_t const idxIommu = pIommuReg->idxIommu;
+    ASMCompilerBarrier();
+    AssertLogRelMsgReturn(idxIommu < RT_ELEMENTS(pGVM->pdm.s.aIommus), ("idxIommu=%#x\n", idxIommu), VERR_OUT_OF_RANGE);
+    PPDMIOMMUR3 pIommuShared = &pGVM->pdm.s.aIommus[idxIommu];
+    AssertLogRelMsgReturn(pIommuShared->idxIommu == idxIommu, ("%u vs %u\n", pIommuShared->idxIommu, idxIommu), VERR_INVALID_PARAMETER);
+    AssertLogRelMsgReturn(pIommuShared->pDevInsR3 == pDevIns->pDevInsForR3,
+                          ("%p vs %p (idxIommu=%u)\n", pIommuShared->pDevInsR3, pDevIns->pDevInsForR3, idxIommu), VERR_NOT_OWNER);
+
+    /* Check that the IOMMU isn't already registered in ring-0. */
+    AssertCompile(RT_ELEMENTS(pGVM->pdm.s.aIommus) == RT_ELEMENTS(pGVM->pdmr0.s.aIommus));
+    PPDMIOMMUR0 pIommuR0 = &pGVM->pdmr0.s.aIommus[idxIommu];
+    AssertLogRelMsgReturn(pIommuR0->pDevInsR0 == NULL,
+                          ("%p (caller pDevIns=%p, idxIommu=%u)\n", pIommuR0->pDevInsR0, pDevIns, idxIommu),
+                          VERR_ALREADY_EXISTS);
+
+    /*
+     * Register.
+     */
+    pIommuR0->idxIommu         = idxIommu;
+    pIommuR0->uPadding0        = 0xdeaddead;
+    pIommuR0->pDevInsR0        = pDevIns;
+    pIommuR0->pfnMemAccess     = pIommuReg->pfnMemAccess;
+    pIommuR0->pfnMemBulkAccess = pIommuReg->pfnMemBulkAccess;
+    pIommuR0->pfnMsiRemap      = pIommuReg->pfnMsiRemap;
+#endif
+
+    AssertFailed();
+    *ppIommuHlp = NULL; //&g_pdmR0IommuHlp;
+
+    LogFlow(("pdmR0DevHlp_IommuSetUpContext: caller='%p'/%d: returns VINF_SUCCESS\n", pDevIns, pDevIns->iInstance));
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnPICSetUpContext} */
+static DECLCALLBACK(int) pdmR0DevHlp_PICSetUpContext(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLP *ppPicHlp)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_PICSetUpContext: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnGetInterrupt=%p, .u32TheEnd=%#x } ppPicHlp=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrq, pPicReg->pfnGetInterrupt, pPicReg->u32TheEnd, ppPicHlp));
+#if 0
+    PGVM pGVM = pDevIns->Internal.s.pGVM;
+
+    /*
+     * Validate input.
+     */
+    AssertMsgReturn(pPicReg->u32Version == PDM_PICREG_VERSION,
+                    ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32Version, PDM_PICREG_VERSION),
+                    VERR_VERSION_MISMATCH);
+    AssertPtrReturn(pPicReg->pfnSetIrq, VERR_INVALID_POINTER);
+    AssertPtrReturn(pPicReg->pfnGetInterrupt, VERR_INVALID_POINTER);
+    AssertMsgReturn(pPicReg->u32TheEnd == PDM_PICREG_VERSION,
+                    ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pPicReg->u32TheEnd, PDM_PICREG_VERSION),
+                    VERR_VERSION_MISMATCH);
+    AssertPtrReturn(ppPicHlp, VERR_INVALID_POINTER);
+
+    VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
+    VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
+
+    /* Check that it's the same device as made the ring-3 registrations: */
+    AssertLogRelMsgReturn(pGVM->pdm.s.Pic.pDevInsR3 == pDevIns->pDevInsForR3,
+                          ("%p vs %p\n", pGVM->pdm.s.Pic.pDevInsR3, pDevIns->pDevInsForR3), VERR_NOT_OWNER);
+
+    /* Check that it isn't already registered in ring-0: */
+    AssertLogRelMsgReturn(pGVM->pdm.s.Pic.pDevInsR0 == NULL, ("%p (caller pDevIns=%p)\n", pGVM->pdm.s.Pic.pDevInsR0, pDevIns),
+                          VERR_ALREADY_EXISTS);
+
+    /*
+     * Take down the callbacks and instance.
+     */
+    pGVM->pdm.s.Pic.pDevInsR0 = pDevIns;
+    pGVM->pdm.s.Pic.pfnSetIrqR0 = pPicReg->pfnSetIrq;
+    pGVM->pdm.s.Pic.pfnGetInterruptR0 = pPicReg->pfnGetInterrupt;
+#endif
+    Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
+
+    /* set the helper pointer and return. */
+    AssertFailed();
+    *ppPicHlp = NULL; //&g_pdmR0PicHlp;
+    LogFlow(("pdmR0DevHlp_PICSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnApicSetUpContext} */
+static DECLCALLBACK(int) pdmR0DevHlp_ApicSetUpContext(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_ApicSetUpContext: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
+#if 0
+    PGVM pGVM = pDevIns->Internal.s.pGVM;
+
+    /*
+     * Validate input.
+     */
+    VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
+    VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
+
+    /* Check that it's the same device as made the ring-3 registrations: */
+    AssertLogRelMsgReturn(pGVM->pdm.s.Apic.pDevInsR3 == pDevIns->pDevInsForR3,
+                          ("%p vs %p\n", pGVM->pdm.s.Apic.pDevInsR3, pDevIns->pDevInsForR3), VERR_NOT_OWNER);
+
+    /* Check that it isn't already registered in ring-0: */
+    AssertLogRelMsgReturn(pGVM->pdm.s.Apic.pDevInsR0 == NULL, ("%p (caller pDevIns=%p)\n", pGVM->pdm.s.Apic.pDevInsR0, pDevIns),
+                          VERR_ALREADY_EXISTS);
+
+    /*
+     * Take down the instance.
+     */
+    pGVM->pdm.s.Apic.pDevInsR0 = pDevIns;
+#endif
+    Log(("PDM: Registered APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
+
+    /* set the helper pointer and return. */
+    LogFlow(("pdmR0DevHlp_ApicSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnIoApicSetUpContext} */
+static DECLCALLBACK(int) pdmR0DevHlp_IoApicSetUpContext(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLP *ppIoApicHlp)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_IoApicSetUpContext: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrq=%p, .pfnSendMsi=%p, .pfnSetEoi=%p, .u32TheEnd=%#x } ppIoApicHlp=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrq, pIoApicReg->pfnSendMsi, pIoApicReg->pfnSetEoi, pIoApicReg->u32TheEnd, ppIoApicHlp));
+#if 0
+    PGVM pGVM = pDevIns->Internal.s.pGVM;
+
+    /*
+     * Validate input.
+     */
+    AssertMsgReturn(pIoApicReg->u32Version == PDM_IOAPICREG_VERSION,
+                    ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32Version, PDM_IOAPICREG_VERSION),
+                    VERR_VERSION_MISMATCH);
+    AssertPtrReturn(pIoApicReg->pfnSetIrq, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIoApicReg->pfnSendMsi, VERR_INVALID_POINTER);
+    AssertPtrReturn(pIoApicReg->pfnSetEoi, VERR_INVALID_POINTER);
+    AssertMsgReturn(pIoApicReg->u32TheEnd == PDM_IOAPICREG_VERSION,
+                    ("%s/%d: u32TheEnd=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg->u32TheEnd, PDM_IOAPICREG_VERSION),
+                    VERR_VERSION_MISMATCH);
+    AssertPtrReturn(ppIoApicHlp, VERR_INVALID_POINTER);
+
+    VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
+    VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
+
+    /* Check that it's the same device as made the ring-3 registrations: */
+    AssertLogRelMsgReturn(pGVM->pdm.s.IoApic.pDevInsR3 == pDevIns->pDevInsForR3,
+                          ("%p vs %p\n", pGVM->pdm.s.IoApic.pDevInsR3, pDevIns->pDevInsForR3), VERR_NOT_OWNER);
+
+    /* Check that it isn't already registered in ring-0: */
+    AssertLogRelMsgReturn(pGVM->pdm.s.IoApic.pDevInsR0 == NULL, ("%p (caller pDevIns=%p)\n", pGVM->pdm.s.IoApic.pDevInsR0, pDevIns),
+                          VERR_ALREADY_EXISTS);
+
+    /*
+     * Take down the callbacks and instance.
+     */
+    pGVM->pdm.s.IoApic.pDevInsR0    = pDevIns;
+    pGVM->pdm.s.IoApic.pfnSetIrqR0  = pIoApicReg->pfnSetIrq;
+    pGVM->pdm.s.IoApic.pfnSendMsiR0 = pIoApicReg->pfnSendMsi;
+    pGVM->pdm.s.IoApic.pfnSetEoiR0  = pIoApicReg->pfnSetEoi;
+#endif
+    Log(("PDM: Registered IOAPIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
+
+    /* set the helper pointer and return. */
+    AssertFailed();
+    *ppIoApicHlp = NULL; //&g_pdmR0IoApicHlp;
+    LogFlow(("pdmR0DevHlp_IoApicSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnHpetSetUpContext} */
+static DECLCALLBACK(int) pdmR0DevHlp_HpetSetUpContext(PPDMDEVINS pDevIns, PPDMHPETREG pHpetReg, PCPDMHPETHLPR0 *ppHpetHlp)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_HpetSetUpContext: caller='%s'/%d: pHpetReg=%p:{.u32Version=%#x, } ppHpetHlp=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg, pHpetReg->u32Version, ppHpetHlp));
+#if 0
+    PGVM pGVM = pDevIns->Internal.s.pGVM;
+
+    /*
+     * Validate input.
+     */
+    AssertMsgReturn(pHpetReg->u32Version == PDM_HPETREG_VERSION,
+                    ("%s/%d: u32Version=%#x expected %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, pHpetReg->u32Version, PDM_HPETREG_VERSION),
+                    VERR_VERSION_MISMATCH);
+    AssertPtrReturn(ppHpetHlp, VERR_INVALID_POINTER);
+
+    VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_WRONG_ORDER);
+    VM_ASSERT_EMT0_RETURN(pGVM, VERR_VM_THREAD_NOT_EMT);
+
+    /* Check that it's the same device as made the ring-3 registrations: */
+    AssertLogRelMsgReturn(pGVM->pdm.s.pHpet == pDevIns->pDevInsForR3, ("%p vs %p\n", pGVM->pdm.s.pHpet, pDevIns->pDevInsForR3),
+                          VERR_NOT_OWNER);
+
+    ///* Check that it isn't already registered in ring-0: */
+    //AssertLogRelMsgReturn(pGVM->pdm.s.Hpet.pDevInsR0 == NULL, ("%p (caller pDevIns=%p)\n", pGVM->pdm.s.Hpet.pDevInsR0, pDevIns),
+    //                      VERR_ALREADY_EXISTS);
+#endif
+    /*
+     * Nothing to take down here at present.
+     */
+    Log(("PDM: Registered HPET device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
+
+    /* set the helper pointer and return. */
+    AssertFailed();
+    *ppHpetHlp = NULL; //&g_pdmR0HpetHlp;
+    LogFlow(("pdmR0DevHlp_HpetSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
+    return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnPGMHandlerPhysicalPageTempOff} */
+static DECLCALLBACK(int) pdmR0DevHlp_PGMHandlerPhysicalPageTempOff(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_PGMHandlerPhysicalPageTempOff: caller='%s'/%d: GCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //PGMHandlerPhysicalPageTempOff(pDevIns->Internal.s.pGVM, GCPhys, GCPhysPage);
+
+    Log(("pdmR0DevHlp_PGMHandlerPhysicalPageTempOff: caller='%s'/%d: returns %Rrc\n",
+         pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnMmioMapMmio2Page} */
+static DECLCALLBACK(int) pdmR0DevHlp_MmioMapMmio2Page(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS offRegion,
+                                                      uint64_t hMmio2, RTGCPHYS offMmio2, uint64_t fPageFlags)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_MmioMapMmio2Page: caller='%s'/%d: hRegion=%RX64 offRegion=%RGp hMmio2=%RX64 offMmio2=%RGp fPageFlags=%RX64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hRegion, offRegion, hMmio2, offMmio2, fPageFlags));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //IOMMmioMapMmio2Page(pDevIns->Internal.s.pGVM, pDevIns, hRegion, offRegion, hMmio2, offMmio2, fPageFlags);
+
+    Log(("pdmR0DevHlp_MmioMapMmio2Page: caller='%s'/%d: returns %Rrc\n",
+         pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnMmioResetRegion} */
+static DECLCALLBACK(int) pdmR0DevHlp_MmioResetRegion(PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_MmioResetRegion: caller='%s'/%d: hRegion=%RX64\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, hRegion));
+
+    AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED; //IOMMmioResetRegion(pDevIns->Internal.s.pGVM, pDevIns, hRegion);
+
+    Log(("pdmR0DevHlp_MmioResetRegion: caller='%s'/%d: returns %Rrc\n",
+         pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnGIMGetMmio2Regions} */
+static DECLCALLBACK(PGIMMMIO2REGION) pdmR0DevHlp_GIMGetMmio2Regions(PPDMDEVINS pDevIns, uint32_t *pcRegions)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    LogFlow(("pdmR0DevHlp_GIMGetMmio2Regions: caller='%s'/%d: pcRegions=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pcRegions));
+
+    AssertFailed();
+    PGIMMMIO2REGION pRegion = NULL; //GIMGetMmio2Regions(pDevIns->Internal.s.pGVM, pcRegions);
+
+    LogFlow(("pdmR0DevHlp_GIMGetMmio2Regions: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pRegion));
+    return pRegion;
+}
+
+
+/**
+ * The Ring-0 Device Helper Callbacks.
+ */
+const PDMDEVHLPR0 g_tstDevPdmDevHlpR0 =
+{
+    PDM_DEVHLPR0_VERSION,
+    pdmR0DevHlp_IoPortSetUpContextEx,
+    pdmR0DevHlp_MmioSetUpContextEx,
+    pdmR0DevHlp_Mmio2SetUpContext,
+    pdmR0DevHlp_PCIPhysRead,
+    pdmR0DevHlp_PCIPhysWrite,
+    pdmR0DevHlp_PCISetIrq,
+    pdmR0DevHlp_ISASetIrq,
+    pdmR0DevHlp_PhysRead,
+    pdmR0DevHlp_PhysWrite,
+    pdmR0DevHlp_A20IsEnabled,
+    pdmR0DevHlp_VMState,
+    pdmR0DevHlp_GetVM,
+    pdmR0DevHlp_GetVMCPU,
+    pdmR0DevHlp_GetCurrentCpuId,
+    pdmR0DevHlp_GetMainExecutionEngine,
+    pdmR0DevHlp_TimerFromMicro,
+    pdmR0DevHlp_TimerFromMilli,
+    pdmR0DevHlp_TimerFromNano,
+    pdmR0DevHlp_TimerGet,
+    pdmR0DevHlp_TimerGetFreq,
+    pdmR0DevHlp_TimerGetNano,
+    pdmR0DevHlp_TimerIsActive,
+    pdmR0DevHlp_TimerIsLockOwner,
+    pdmR0DevHlp_TimerLockClock,
+    pdmR0DevHlp_TimerLockClock2,
+    pdmR0DevHlp_TimerSet,
+    pdmR0DevHlp_TimerSetFrequencyHint,
+    pdmR0DevHlp_TimerSetMicro,
+    pdmR0DevHlp_TimerSetMillies,
+    pdmR0DevHlp_TimerSetNano,
+    pdmR0DevHlp_TimerSetRelative,
+    pdmR0DevHlp_TimerStop,
+    pdmR0DevHlp_TimerUnlockClock,
+    pdmR0DevHlp_TimerUnlockClock2,
+    pdmR0DevHlp_TMTimeVirtGet,
+    pdmR0DevHlp_TMTimeVirtGetFreq,
+    pdmR0DevHlp_TMTimeVirtGetNano,
+    pdmR0DevHlp_QueueAlloc,
+    pdmR0DevHlp_QueueInsert,
+    pdmR0DevHlp_QueueFlushIfNecessary,
+    pdmR0DevHlp_TaskTrigger,
+    pdmR0DevHlp_SUPSemEventSignal,
+    pdmR0DevHlp_SUPSemEventWaitNoResume,
+    pdmR0DevHlp_SUPSemEventWaitNsAbsIntr,
+    pdmR0DevHlp_SUPSemEventWaitNsRelIntr,
+    pdmR0DevHlp_SUPSemEventGetResolution,
+    pdmR0DevHlp_SUPSemEventMultiSignal,
+    pdmR0DevHlp_SUPSemEventMultiReset,
+    pdmR0DevHlp_SUPSemEventMultiWaitNoResume,
+    pdmR0DevHlp_SUPSemEventMultiWaitNsAbsIntr,
+    pdmR0DevHlp_SUPSemEventMultiWaitNsRelIntr,
+    pdmR0DevHlp_SUPSemEventMultiGetResolution,
+    pdmR0DevHlp_CritSectGetNop,
+    pdmR0DevHlp_SetDeviceCritSect,
+    pdmR0DevHlp_CritSectEnter,
+    pdmR0DevHlp_CritSectEnterDebug,
+    pdmR0DevHlp_CritSectTryEnter,
+    pdmR0DevHlp_CritSectTryEnterDebug,
+    pdmR0DevHlp_CritSectLeave,
+    pdmR0DevHlp_CritSectIsOwner,
+    pdmR0DevHlp_CritSectIsInitialized,
+    pdmR0DevHlp_CritSectHasWaiters,
+    pdmR0DevHlp_CritSectGetRecursion,
+    pdmR0DevHlp_CritSectScheduleExitEvent,
+    pdmR0DevHlp_CritSectRwEnterShared,
+    pdmR0DevHlp_CritSectRwEnterSharedDebug,
+    pdmR0DevHlp_CritSectRwTryEnterShared,
+    pdmR0DevHlp_CritSectRwTryEnterSharedDebug,
+    pdmR0DevHlp_CritSectRwLeaveShared,
+    pdmR0DevHlp_CritSectRwEnterExcl,
+    pdmR0DevHlp_CritSectRwEnterExclDebug,
+    pdmR0DevHlp_CritSectRwTryEnterExcl,
+    pdmR0DevHlp_CritSectRwTryEnterExclDebug,
+    pdmR0DevHlp_CritSectRwLeaveExcl,
+    pdmR0DevHlp_CritSectRwIsWriteOwner,
+    pdmR0DevHlp_CritSectRwIsReadOwner,
+    pdmR0DevHlp_CritSectRwGetWriteRecursion,
+    pdmR0DevHlp_CritSectRwGetWriterReadRecursion,
+    pdmR0DevHlp_CritSectRwGetReadCount,
+    pdmR0DevHlp_CritSectRwIsInitialized,
+    pdmR0DevHlp_DBGFTraceBuf,
+    pdmR0DevHlp_PCIBusSetUpContext,
+    pdmR0DevHlp_IommuSetUpContext,
+    pdmR0DevHlp_PICSetUpContext,
+    pdmR0DevHlp_ApicSetUpContext,
+    pdmR0DevHlp_IoApicSetUpContext,
+    pdmR0DevHlp_HpetSetUpContext,
+    pdmR0DevHlp_PGMHandlerPhysicalPageTempOff,
+    pdmR0DevHlp_MmioMapMmio2Page,
+    pdmR0DevHlp_MmioResetRegion,
+    pdmR0DevHlp_GIMGetMmio2Regions,
+    NULL /*pfnReserved1*/,
+    NULL /*pfnReserved2*/,
+    NULL /*pfnReserved3*/,
+    NULL /*pfnReserved4*/,
+    NULL /*pfnReserved5*/,
+    NULL /*pfnReserved6*/,
+    NULL /*pfnReserved7*/,
+    NULL /*pfnReserved8*/,
+    NULL /*pfnReserved9*/,
+    NULL /*pfnReserved10*/,
+    PDM_DEVHLPR0_VERSION
+};
diff --git a/src/VBox/Devices/testcase/tstDevicePdmThread.cpp b/src/VBox/Devices/testcase/tstDevicePdmThread.cpp
new file mode 100644
index 00000000..1e218e53
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDevicePdmThread.cpp
@@ -0,0 +1,996 @@
+/* $Id: tstDevicePdmThread.cpp $ */
+/** @file
+ * PDM Thread - Thread Management (copied from PDMThread).
+ */
+
+/*
+ * Copyright (C) 2007-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+/// @todo \#define LOG_GROUP LOG_GROUP_PDM_THREAD
+#include <VBox/err.h>
+#include <VBox/log.h>
+
+#include <iprt/asm.h>
+#include <iprt/semaphore.h>
+#include <iprt/assert.h>
+#include <iprt/mem.h>
+#include <iprt/thread.h>
+
+#include "tstDeviceInternal.h"
+
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static DECLCALLBACK(int) pdmR3ThreadMain(RTTHREAD Thread, void *pvUser);
+
+
+/**
+ * Wrapper around ASMAtomicCmpXchgSize.
+ */
+DECLINLINE(bool) pdmR3AtomicCmpXchgState(PPDMTHREAD pThread, PDMTHREADSTATE enmNewState, PDMTHREADSTATE enmOldState)
+{
+    bool fRc;
+    ASMAtomicCmpXchgSize(&pThread->enmState, enmNewState, enmOldState, fRc);
+    return fRc;
+}
+
+
+/**
+ * Does the wakeup call.
+ *
+ * @returns VBox status code. Already asserted on failure.
+ * @param   pThread     The PDM thread.
+ */
+static DECLCALLBACK(int) pdmR3ThreadWakeUp(PPDMTHREAD pThread)
+{
+    RTSemEventMultiSignal(pThread->Internal.s.SleepEvent);
+
+    int rc;
+    switch (pThread->Internal.s.enmType)
+    {
+        case PDMTHREADTYPE_DEVICE:
+            rc = pThread->u.Dev.pfnWakeUp(pThread->u.Dev.pDevIns, pThread);
+            break;
+
+        case PDMTHREADTYPE_USB:
+            rc = pThread->u.Usb.pfnWakeUp(pThread->u.Usb.pUsbIns, pThread);
+            break;
+
+        case PDMTHREADTYPE_DRIVER:
+            rc = pThread->u.Drv.pfnWakeUp(pThread->u.Drv.pDrvIns, pThread);
+            break;
+
+        case PDMTHREADTYPE_INTERNAL:
+            rc = pThread->u.Int.pfnWakeUp(NULL /*pVM*/, pThread);
+            break;
+
+        case PDMTHREADTYPE_EXTERNAL:
+            rc = pThread->u.Ext.pfnWakeUp(pThread);
+            break;
+
+        default:
+            AssertMsgFailed(("%d\n", pThread->Internal.s.enmType));
+            rc = VERR_PDM_THREAD_IPE_1;
+            break;
+    }
+    AssertRC(rc);
+    return rc;
+}
+
+
+/**
+ * Allocates new thread instance.
+ *
+ * @returns VBox status code.
+ * @param   pDut        The device under test.
+ * @param   ppThread    Where to store the pointer to the instance.
+ */
+static int pdmR3ThreadNew(PTSTDEVDUTINT pDut, PPPDMTHREAD ppThread)
+{
+    PPDMTHREAD pThread = (PPDMTHREAD)RTMemAllocZ(sizeof(*pThread));
+    if (!pThread)
+        return VERR_NO_MEMORY;
+
+    pThread->u32Version      = PDMTHREAD_VERSION;
+    pThread->enmState        = PDMTHREADSTATE_INITIALIZING;
+    pThread->Thread          = NIL_RTTHREAD;
+    pThread->Internal.s.pDut = pDut;
+
+    *ppThread = pThread;
+    return VINF_SUCCESS;
+}
+
+
+
+/**
+ * Initialize a new thread, this actually creates the thread.
+ *
+ * @returns VBox status code.
+ * @param   pDut        The device under test.
+ * @param   ppThread    Where the thread instance data handle is.
+ * @param   cbStack     The stack size, see RTThreadCreate().
+ * @param   enmType     The thread type, see RTThreadCreate().
+ * @param   pszName     The thread name, see RTThreadCreate().
+ */
+static int pdmR3ThreadInit(PTSTDEVDUTINT pDut, PPPDMTHREAD ppThread, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
+{
+    PPDMTHREAD  pThread = *ppThread;
+
+    int rc = RTSemEventMultiCreate(&pThread->Internal.s.BlockEvent);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTSemEventMultiCreate(&pThread->Internal.s.SleepEvent);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Create the thread and wait for it to initialize.
+             * The newly created thread will set the PDMTHREAD::Thread member.
+             */
+            RTTHREAD Thread;
+            rc = RTThreadCreate(&Thread, pdmR3ThreadMain, pThread, cbStack, enmType, RTTHREADFLAGS_WAITABLE, pszName);
+            if (RT_SUCCESS(rc))
+            {
+                rc = RTThreadUserWait(Thread, 60*1000);
+                if (    RT_SUCCESS(rc)
+                    &&  pThread->enmState != PDMTHREADSTATE_SUSPENDED)
+                    rc = VERR_PDM_THREAD_IPE_2;
+                if (RT_SUCCESS(rc))
+                {
+                    /*
+                     * Insert it into the thread list.
+                     */
+                    tstDevDutLockExcl(pDut);
+                    RTListAppend(&pDut->LstPdmThreads, &pThread->Internal.s.NdPdmThrds);
+                    tstDevDutUnlockExcl(pDut);
+
+                    rc = RTThreadUserReset(Thread);
+                    AssertRC(rc);
+                    return rc;
+                }
+
+                /* bailout */
+                RTThreadWait(Thread, 60*1000, NULL);
+            }
+            RTSemEventMultiDestroy(pThread->Internal.s.SleepEvent);
+            pThread->Internal.s.SleepEvent = NIL_RTSEMEVENTMULTI;
+        }
+        RTSemEventMultiDestroy(pThread->Internal.s.BlockEvent);
+        pThread->Internal.s.BlockEvent = NIL_RTSEMEVENTMULTI;
+    }
+    RTMemFree(pThread);
+    *ppThread = NULL;
+
+    return rc;
+}
+
+
+/**
+ * Device Helper for creating a thread associated with a device.
+ *
+ * @returns VBox status code.
+ * @param   pDut        The device under test.
+ * @param   pDevIns     The device instance.
+ * @param   ppThread    Where to store the thread 'handle'.
+ * @param   pvUser      The user argument to the thread function.
+ * @param   pfnThread   The thread function.
+ * @param   pfnWakeUp   The wakup callback. This is called on the EMT thread when
+ *                      a state change is pending.
+ * @param   cbStack     See RTThreadCreate.
+ * @param   enmType     See RTThreadCreate.
+ * @param   pszName     See RTThreadCreate.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadCreateDevice(PTSTDEVDUTINT pDut, PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
+                                              PFNPDMTHREADWAKEUPDEV pfnWakeUp, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
+{
+    int rc = pdmR3ThreadNew(pDut, ppThread);
+    if (RT_SUCCESS(rc))
+    {
+        PPDMTHREAD pThread = *ppThread;
+        pThread->pvUser = pvUser;
+        pThread->Internal.s.enmType = PDMTHREADTYPE_DEVICE;
+        pThread->u.Dev.pDevIns = pDevIns;
+        pThread->u.Dev.pfnThread = pfnThread;
+        pThread->u.Dev.pfnWakeUp = pfnWakeUp;
+        rc = pdmR3ThreadInit(pDut, ppThread, cbStack, enmType, pszName);
+    }
+    return rc;
+}
+
+
+/**
+ * USB Device Helper for creating a thread associated with an USB device.
+ *
+ * @returns VBox status code.
+ * @param   pDut        The device under test.
+ * @param   pUsbIns     The USB device instance.
+ * @param   ppThread    Where to store the thread 'handle'.
+ * @param   pvUser      The user argument to the thread function.
+ * @param   pfnThread   The thread function.
+ * @param   pfnWakeUp   The wakup callback. This is called on the EMT thread when
+ *                      a state change is pending.
+ * @param   cbStack     See RTThreadCreate.
+ * @param   enmType     See RTThreadCreate.
+ * @param   pszName     See RTThreadCreate.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadCreateUsb(PTSTDEVDUTINT pDut, PPDMUSBINS pUsbIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADUSB pfnThread,
+                                           PFNPDMTHREADWAKEUPUSB pfnWakeUp, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
+{
+    int rc = pdmR3ThreadNew(pDut, ppThread);
+    if (RT_SUCCESS(rc))
+    {
+        PPDMTHREAD pThread = *ppThread;
+        pThread->pvUser = pvUser;
+        pThread->Internal.s.enmType = PDMTHREADTYPE_USB;
+        pThread->u.Usb.pUsbIns = pUsbIns;
+        pThread->u.Usb.pfnThread = pfnThread;
+        pThread->u.Usb.pfnWakeUp = pfnWakeUp;
+        rc = pdmR3ThreadInit(pDut, ppThread, cbStack, enmType, pszName);
+    }
+    return rc;
+}
+
+
+/**
+ * Driver Helper for creating a thread associated with a driver.
+ *
+ * @returns VBox status code.
+ * @param   pDut        The device under test.
+ * @param   pDrvIns     The driver instance.
+ * @param   ppThread    Where to store the thread 'handle'.
+ * @param   pvUser      The user argument to the thread function.
+ * @param   pfnThread   The thread function.
+ * @param   pfnWakeUp   The wakup callback. This is called on the EMT thread when
+ *                      a state change is pending.
+ * @param   cbStack     See RTThreadCreate.
+ * @param   enmType     See RTThreadCreate.
+ * @param   pszName     See RTThreadCreate.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadCreateDriver(PTSTDEVDUTINT pDut, PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
+                                              PFNPDMTHREADWAKEUPDRV pfnWakeUp, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
+{
+    int rc = pdmR3ThreadNew(pDut, ppThread);
+    if (RT_SUCCESS(rc))
+    {
+        PPDMTHREAD pThread = *ppThread;
+        pThread->pvUser = pvUser;
+        pThread->Internal.s.enmType = PDMTHREADTYPE_DRIVER;
+        pThread->u.Drv.pDrvIns = pDrvIns;
+        pThread->u.Drv.pfnThread = pfnThread;
+        pThread->u.Drv.pfnWakeUp = pfnWakeUp;
+        rc = pdmR3ThreadInit(pDut, ppThread, cbStack, enmType, pszName);
+    }
+    return rc;
+}
+
+
+/**
+ * Creates a PDM thread for internal use in the VM.
+ *
+ * @returns VBox status code.
+ * @param   pDut        The device under test.
+ * @param   ppThread    Where to store the thread 'handle'.
+ * @param   pvUser      The user argument to the thread function.
+ * @param   pfnThread   The thread function.
+ * @param   pfnWakeUp   The wakup callback. This is called on the EMT thread when
+ *                      a state change is pending.
+ * @param   cbStack     See RTThreadCreate.
+ * @param   enmType     See RTThreadCreate.
+ * @param   pszName     See RTThreadCreate.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadCreate(PTSTDEVDUTINT pDut, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADINT pfnThread,
+                                        PFNPDMTHREADWAKEUPINT pfnWakeUp, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
+{
+    int rc = pdmR3ThreadNew(pDut, ppThread);
+    if (RT_SUCCESS(rc))
+    {
+        PPDMTHREAD pThread = *ppThread;
+        pThread->pvUser = pvUser;
+        pThread->Internal.s.enmType = PDMTHREADTYPE_INTERNAL;
+        pThread->u.Int.pfnThread = pfnThread;
+        pThread->u.Int.pfnWakeUp = pfnWakeUp;
+        rc = pdmR3ThreadInit(pDut, ppThread, cbStack, enmType, pszName);
+    }
+    return rc;
+}
+
+
+/**
+ * Creates a PDM thread for VM use by some external party.
+ *
+ * @returns VBox status code.
+ * @param   pDut        The device under test.
+ * @param   ppThread    Where to store the thread 'handle'.
+ * @param   pvUser      The user argument to the thread function.
+ * @param   pfnThread   The thread function.
+ * @param   pfnWakeUp   The wakup callback. This is called on the EMT thread when
+ *                      a state change is pending.
+ * @param   cbStack     See RTThreadCreate.
+ * @param   enmType     See RTThreadCreate.
+ * @param   pszName     See RTThreadCreate.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadCreateExternal(PTSTDEVDUTINT pDut, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADEXT pfnThread,
+                                                PFNPDMTHREADWAKEUPEXT pfnWakeUp, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
+{
+    int rc = pdmR3ThreadNew(pDut, ppThread);
+    if (RT_SUCCESS(rc))
+    {
+        PPDMTHREAD pThread = *ppThread;
+        pThread->pvUser = pvUser;
+        pThread->Internal.s.enmType = PDMTHREADTYPE_EXTERNAL;
+        pThread->u.Ext.pfnThread = pfnThread;
+        pThread->u.Ext.pfnWakeUp = pfnWakeUp;
+        rc = pdmR3ThreadInit(pDut, ppThread, cbStack, enmType, pszName);
+    }
+    return rc;
+}
+
+
+/**
+ * Destroys a PDM thread.
+ *
+ * This will wakeup the thread, tell it to terminate, and wait for it terminate.
+ *
+ * @returns VBox status code.
+ *          This reflects the success off destroying the thread and not the exit code
+ *          of the thread as this is stored in *pRcThread.
+ * @param   pThread         The thread to destroy.
+ * @param   pRcThread       Where to store the thread exit code. Optional.
+ * @thread  The emulation thread (EMT).
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadDestroy(PPDMTHREAD pThread, int *pRcThread)
+{
+    /*
+     * Assert sanity.
+     */
+    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+    AssertReturn(pThread->u32Version == PDMTHREAD_VERSION, VERR_INVALID_MAGIC);
+    Assert(pThread->Thread != RTThreadSelf());
+    AssertPtrNullReturn(pRcThread, VERR_INVALID_POINTER);
+
+    PTSTDEVDUTINT pDut = pThread->Internal.s.pDut;
+
+    /*
+     * Advance the thread to the terminating state.
+     */
+    int rc = VINF_SUCCESS;
+    if (pThread->enmState <= PDMTHREADSTATE_TERMINATING)
+    {
+        for (;;)
+        {
+            PDMTHREADSTATE enmState = pThread->enmState;
+            switch (enmState)
+            {
+                case PDMTHREADSTATE_RUNNING:
+                    if (!pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_TERMINATING, enmState))
+                        continue;
+                    rc = pdmR3ThreadWakeUp(pThread);
+                    break;
+
+                case PDMTHREADSTATE_SUSPENDED:
+                case PDMTHREADSTATE_SUSPENDING:
+                case PDMTHREADSTATE_RESUMING:
+                case PDMTHREADSTATE_INITIALIZING:
+                    if (!pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_TERMINATING, enmState))
+                        continue;
+                    break;
+
+                case PDMTHREADSTATE_TERMINATING:
+                case PDMTHREADSTATE_TERMINATED:
+                    break;
+
+                default:
+                    AssertMsgFailed(("enmState=%d\n", enmState));
+                    rc = VERR_PDM_THREAD_IPE_2;
+                    break;
+            }
+            break;
+        }
+    }
+    int rc2 = RTSemEventMultiSignal(pThread->Internal.s.BlockEvent);
+    AssertRC(rc2);
+
+    /*
+     * Wait for it to terminate and the do cleanups.
+     */
+    rc2 = RTThreadWait(pThread->Thread, RT_SUCCESS(rc) ? 60*1000 : 150, pRcThread);
+    if (RT_SUCCESS(rc2))
+    {
+        /* make it invalid. */
+        pThread->u32Version = 0xffffffff;
+        pThread->enmState = PDMTHREADSTATE_INVALID;
+        pThread->Thread = NIL_RTTHREAD;
+
+        /* unlink */
+        tstDevDutLockExcl(pDut);
+        RTListNodeRemove(&pThread->Internal.s.NdPdmThrds);
+        tstDevDutUnlockExcl(pDut);
+
+        /* free the resources */
+        RTSemEventMultiDestroy(pThread->Internal.s.BlockEvent);
+        pThread->Internal.s.BlockEvent = NIL_RTSEMEVENTMULTI;
+
+        RTSemEventMultiDestroy(pThread->Internal.s.SleepEvent);
+        pThread->Internal.s.SleepEvent = NIL_RTSEMEVENTMULTI;
+
+        RTMemFree(pThread);
+    }
+    else if (RT_SUCCESS(rc))
+        rc = rc2;
+
+    return rc;
+}
+
+
+/**
+ * Destroys all threads associated with a device.
+ *
+ * This function is called by PDMDevice when a device is
+ * destroyed (not currently implemented).
+ *
+ * @returns VBox status code of the first failure.
+ * @param   pDut        The device under test.
+ * @param   pDevIns     the device instance.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadDestroyDevice(PTSTDEVDUTINT pDut, PPDMDEVINS pDevIns)
+{
+    int rc = VINF_SUCCESS;
+
+    AssertPtr(pDevIns);
+
+    tstDevDutLockExcl(pDut);
+#if 0
+    PPDMTHREAD pThread = pUVM->pdm.s.pThreads;
+    while (pThread)
+    {
+        PPDMTHREAD pNext = pThread->Internal.s.pNext;
+        if (    pThread->Internal.s.enmType == PDMTHREADTYPE_DEVICE
+            &&  pThread->u.Dev.pDevIns == pDevIns)
+        {
+            int rc2 = PDMR3ThreadDestroy(pThread, NULL);
+            if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
+                rc = rc2;
+        }
+        pThread = pNext;
+    }
+#endif
+    tstDevDutUnlockExcl(pDut);
+    return rc;
+}
+
+
+/**
+ * Destroys all threads associated with an USB device.
+ *
+ * This function is called by PDMUsb when a device is destroyed.
+ *
+ * @returns VBox status code of the first failure.
+ * @param   pDut        The device under test.
+ * @param   pUsbIns     The USB device instance.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadDestroyUsb(PTSTDEVDUTINT pDut, PPDMUSBINS pUsbIns)
+{
+    int rc = VINF_SUCCESS;
+
+    AssertPtr(pUsbIns);
+
+    tstDevDutLockExcl(pDut);
+#if 0
+    PPDMTHREAD pThread = pUVM->pdm.s.pThreads;
+    while (pThread)
+    {
+        PPDMTHREAD pNext = pThread->Internal.s.pNext;
+        if (    pThread->Internal.s.enmType == PDMTHREADTYPE_DEVICE
+            &&  pThread->u.Usb.pUsbIns == pUsbIns)
+        {
+            int rc2 = PDMR3ThreadDestroy(pThread, NULL);
+            if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
+                rc = rc2;
+        }
+        pThread = pNext;
+    }
+#endif
+    tstDevDutUnlockExcl(pDut);
+    return rc;
+}
+
+
+/**
+ * Destroys all threads associated with a driver.
+ *
+ * This function is called by PDMDriver when a driver is destroyed.
+ *
+ * @returns VBox status code of the first failure.
+ * @param   pDut        The device under test.
+ * @param   pDrvIns     The driver instance.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadDestroyDriver(PTSTDEVDUTINT pDut, PPDMDRVINS pDrvIns)
+{
+    int rc = VINF_SUCCESS;
+
+    AssertPtr(pDrvIns);
+
+    tstDevDutLockExcl(pDut);
+#if 0
+    PPDMTHREAD pThread = pUVM->pdm.s.pThreads;
+    while (pThread)
+    {
+        PPDMTHREAD pNext = pThread->Internal.s.pNext;
+        if (    pThread->Internal.s.enmType == PDMTHREADTYPE_DRIVER
+            &&  pThread->u.Drv.pDrvIns == pDrvIns)
+        {
+            int rc2 = PDMR3ThreadDestroy(pThread, NULL);
+            if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
+                rc = rc2;
+        }
+        pThread = pNext;
+    }
+#endif
+    tstDevDutUnlockExcl(pDut);
+    return rc;
+}
+
+
+/**
+ * Called For VM power off.
+ *
+ * @param   pDut        The device under test.
+ */
+DECLHIDDEN(void) tstDevPdmR3ThreadDestroyAll(PTSTDEVDUTINT pDut)
+{
+    tstDevDutLockExcl(pDut);
+#if 0
+    PPDMTHREAD pThread = pUVM->pdm.s.pThreads;
+    while (pThread)
+    {
+        PPDMTHREAD pNext = pThread->Internal.s.pNext;
+        int rc2 = PDMR3ThreadDestroy(pThread, NULL);
+        AssertRC(rc2);
+        pThread = pNext;
+    }
+    Assert(!pUVM->pdm.s.pThreads && !pUVM->pdm.s.pThreadsTail);
+#endif
+    tstDevDutUnlockExcl(pDut);
+}
+
+
+/**
+ * Initiate termination of the thread (self) because something failed in a bad way.
+ *
+ * @param   pThread         The PDM thread.
+ */
+static void pdmR3ThreadBailMeOut(PPDMTHREAD pThread)
+{
+    for (;;)
+    {
+        PDMTHREADSTATE enmState = pThread->enmState;
+        switch (enmState)
+        {
+            case PDMTHREADSTATE_SUSPENDING:
+            case PDMTHREADSTATE_SUSPENDED:
+            case PDMTHREADSTATE_RESUMING:
+            case PDMTHREADSTATE_RUNNING:
+                if (!pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_TERMINATING, enmState))
+                    continue;
+                break;
+
+            case PDMTHREADSTATE_TERMINATING:
+            case PDMTHREADSTATE_TERMINATED:
+                break;
+
+            case PDMTHREADSTATE_INITIALIZING:
+            default:
+                AssertMsgFailed(("enmState=%d\n", enmState));
+                break;
+        }
+        break;
+    }
+}
+
+
+/**
+ * Called by the PDM thread in response to a wakeup call with
+ * suspending as the new state.
+ *
+ * The thread will block in side this call until the state is changed in
+ * response to a VM state change or to the device/driver/whatever calling the
+ * PDMR3ThreadResume API.
+ *
+ * @returns VBox status code.
+ *          On failure, terminate the thread.
+ * @param   pThread     The PDM thread.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadIAmSuspending(PPDMTHREAD pThread)
+{
+    /*
+     * Assert sanity.
+     */
+    AssertPtr(pThread);
+    AssertReturn(pThread->u32Version == PDMTHREAD_VERSION, VERR_INVALID_MAGIC);
+    Assert(pThread->Thread == RTThreadSelf() || pThread->enmState == PDMTHREADSTATE_INITIALIZING);
+    PDMTHREADSTATE enmState = pThread->enmState;
+    Assert(     enmState == PDMTHREADSTATE_SUSPENDING
+           ||   enmState == PDMTHREADSTATE_INITIALIZING);
+
+    /*
+     * Update the state, notify the control thread (the API caller) and go to sleep.
+     */
+    int rc = VERR_WRONG_ORDER;
+    if (pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_SUSPENDED, enmState))
+    {
+        rc = RTThreadUserSignal(pThread->Thread);
+        if (RT_SUCCESS(rc))
+        {
+            rc = RTSemEventMultiWait(pThread->Internal.s.BlockEvent, RT_INDEFINITE_WAIT);
+            if (    RT_SUCCESS(rc)
+                &&  pThread->enmState != PDMTHREADSTATE_SUSPENDED)
+                return rc;
+
+            if (RT_SUCCESS(rc))
+                rc = VERR_PDM_THREAD_IPE_2;
+        }
+    }
+
+    AssertMsgFailed(("rc=%d enmState=%d\n", rc, pThread->enmState));
+    pdmR3ThreadBailMeOut(pThread);
+    return rc;
+}
+
+
+/**
+ * Called by the PDM thread in response to a resuming state.
+ *
+ * The purpose of this API is to tell the PDMR3ThreadResume caller that
+ * the PDM thread has successfully resumed. It will also do the
+ * state transition from the resuming to the running state.
+ *
+ * @returns VBox status code.
+ *          On failure, terminate the thread.
+ * @param   pThread     The PDM thread.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadIAmRunning(PPDMTHREAD pThread)
+{
+    /*
+     * Assert sanity.
+     */
+    Assert(pThread->enmState == PDMTHREADSTATE_RESUMING);
+    Assert(pThread->Thread == RTThreadSelf());
+
+    /*
+     * Update the state and tell the control thread (the guy calling the resume API).
+     */
+    int rc = VERR_WRONG_ORDER;
+    if (pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_RUNNING, PDMTHREADSTATE_RESUMING))
+    {
+        rc = RTThreadUserSignal(pThread->Thread);
+        if (RT_SUCCESS(rc))
+            return rc;
+    }
+
+    AssertMsgFailed(("rc=%d enmState=%d\n", rc, pThread->enmState));
+    pdmR3ThreadBailMeOut(pThread);
+    return rc;
+}
+
+
+/**
+ * Called by the PDM thread instead of RTThreadSleep.
+ *
+ * The difference is that the sleep will be interrupted on state change. The
+ * thread must be in the running state, otherwise it will return immediately.
+ *
+ * @returns VBox status code.
+ * @retval  VINF_SUCCESS on success or state change.
+ * @retval  VERR_INTERRUPTED on signal or APC.
+ *
+ * @param   pThread     The PDM thread.
+ * @param   cMillies    The number of milliseconds to sleep.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadSleep(PPDMTHREAD pThread, RTMSINTERVAL cMillies)
+{
+    /*
+     * Assert sanity.
+     */
+    AssertReturn(pThread->enmState > PDMTHREADSTATE_INVALID && pThread->enmState < PDMTHREADSTATE_TERMINATED, VERR_PDM_THREAD_IPE_2);
+    AssertReturn(pThread->Thread == RTThreadSelf(), VERR_PDM_THREAD_INVALID_CALLER);
+
+    /*
+     * Reset the event semaphore, check the state and sleep.
+     */
+    RTSemEventMultiReset(pThread->Internal.s.SleepEvent);
+    if (pThread->enmState != PDMTHREADSTATE_RUNNING)
+        return VINF_SUCCESS;
+    return RTSemEventMultiWaitNoResume(pThread->Internal.s.SleepEvent, cMillies);
+}
+
+
+/**
+ * The PDM thread function.
+ *
+ * @returns return from pfnThread.
+ *
+ * @param   Thread  The thread handle.
+ * @param   pvUser  Pointer to the PDMTHREAD structure.
+ */
+static DECLCALLBACK(int) pdmR3ThreadMain(RTTHREAD Thread, void *pvUser)
+{
+    PPDMTHREAD pThread = (PPDMTHREAD)pvUser;
+    Log(("PDMThread: Initializing thread %RTthrd / %p / '%s'...\n", Thread, pThread, RTThreadGetName(Thread)));
+    pThread->Thread = Thread;
+
+    /*
+     * The run loop.
+     *
+     * It handles simple thread functions which returns when they see a suspending
+     * request and leaves the PDMR3ThreadIAmSuspending and PDMR3ThreadIAmRunning
+     * parts to us.
+     */
+    int rc;
+    for (;;)
+    {
+        switch (pThread->Internal.s.enmType)
+        {
+            case PDMTHREADTYPE_DEVICE:
+                rc = pThread->u.Dev.pfnThread(pThread->u.Dev.pDevIns, pThread);
+                break;
+
+            case PDMTHREADTYPE_USB:
+                rc = pThread->u.Usb.pfnThread(pThread->u.Usb.pUsbIns, pThread);
+                break;
+
+            case PDMTHREADTYPE_DRIVER:
+                rc = pThread->u.Drv.pfnThread(pThread->u.Drv.pDrvIns, pThread);
+                break;
+
+            case PDMTHREADTYPE_INTERNAL:
+                rc = pThread->u.Int.pfnThread(NULL /*pVM*/, pThread);
+                break;
+
+            case PDMTHREADTYPE_EXTERNAL:
+                rc = pThread->u.Ext.pfnThread(pThread);
+                break;
+
+            default:
+                AssertMsgFailed(("%d\n", pThread->Internal.s.enmType));
+                rc = VERR_PDM_THREAD_IPE_1;
+                break;
+        }
+        if (RT_FAILURE(rc))
+            break;
+
+        /*
+         * If this is a simple thread function, the state will be suspending
+         * or initializing now. If it isn't we're supposed to terminate.
+         */
+        if (    pThread->enmState != PDMTHREADSTATE_SUSPENDING
+            &&  pThread->enmState != PDMTHREADSTATE_INITIALIZING)
+        {
+            Assert(pThread->enmState == PDMTHREADSTATE_TERMINATING);
+            break;
+        }
+        rc = tstDevPdmR3ThreadIAmSuspending(pThread);
+        if (RT_FAILURE(rc))
+            break;
+        if (pThread->enmState != PDMTHREADSTATE_RESUMING)
+        {
+            Assert(pThread->enmState == PDMTHREADSTATE_TERMINATING);
+            break;
+        }
+
+        rc = tstDevPdmR3ThreadIAmRunning(pThread);
+        if (RT_FAILURE(rc))
+            break;
+    }
+
+    if (RT_FAILURE(rc))
+        LogRel(("PDMThread: Thread '%s' (%RTthrd) quit unexpectedly with rc=%Rrc.\n", RTThreadGetName(Thread), Thread, rc));
+
+    /*
+     * Advance the state to terminating and then on to terminated.
+     */
+    for (;;)
+    {
+        PDMTHREADSTATE enmState = pThread->enmState;
+        if (    enmState == PDMTHREADSTATE_TERMINATING
+            ||  pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_TERMINATING, enmState))
+            break;
+    }
+
+    ASMAtomicXchgSize(&pThread->enmState, PDMTHREADSTATE_TERMINATED);
+    int rc2 = RTThreadUserSignal(Thread); AssertRC(rc2);
+
+    Log(("PDMThread: Terminating thread %RTthrd / %p / '%s': %Rrc\n", Thread, pThread, RTThreadGetName(Thread), rc));
+    return rc;
+}
+
+
+/**
+ * Initiate termination of the thread because something failed in a bad way.
+ *
+ * @param   pThread         The PDM thread.
+ */
+static void pdmR3ThreadBailOut(PPDMTHREAD pThread)
+{
+    for (;;)
+    {
+        PDMTHREADSTATE enmState = pThread->enmState;
+        switch (enmState)
+        {
+            case PDMTHREADSTATE_SUSPENDING:
+            case PDMTHREADSTATE_SUSPENDED:
+                if (!pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_TERMINATING, enmState))
+                    continue;
+                RTSemEventMultiSignal(pThread->Internal.s.BlockEvent);
+                break;
+
+            case PDMTHREADSTATE_RESUMING:
+                if (!pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_TERMINATING, enmState))
+                    continue;
+                break;
+
+            case PDMTHREADSTATE_RUNNING:
+                if (!pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_TERMINATING, enmState))
+                    continue;
+                pdmR3ThreadWakeUp(pThread);
+                break;
+
+            case PDMTHREADSTATE_TERMINATING:
+            case PDMTHREADSTATE_TERMINATED:
+                break;
+
+            case PDMTHREADSTATE_INITIALIZING:
+            default:
+                AssertMsgFailed(("enmState=%d\n", enmState));
+                break;
+        }
+        break;
+    }
+}
+
+
+/**
+ * Suspends the thread.
+ *
+ * This can be called at the power off / suspend notifications to suspend the
+ * PDM thread a bit early. The thread will be automatically suspend upon
+ * completion of the device/driver notification cycle.
+ *
+ * The caller is responsible for serializing the control operations on the
+ * thread. That basically means, always do these calls from the EMT.
+ *
+ * @returns VBox status code.
+ * @param   pThread     The PDM thread.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadSuspend(PPDMTHREAD pThread)
+{
+    /*
+     * Assert sanity.
+     */
+    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+    AssertReturn(pThread->u32Version == PDMTHREAD_VERSION, VERR_INVALID_MAGIC);
+    Assert(pThread->Thread != RTThreadSelf());
+
+    /*
+     * This is a noop if the thread is already suspended.
+     */
+    if (pThread->enmState == PDMTHREADSTATE_SUSPENDED)
+        return VINF_SUCCESS;
+
+    /*
+     * Change the state to resuming and kick the thread.
+     */
+    int rc = RTSemEventMultiReset(pThread->Internal.s.BlockEvent);
+    if (RT_SUCCESS(rc))
+    {
+        rc = RTThreadUserReset(pThread->Thread);
+        if (RT_SUCCESS(rc))
+        {
+            rc = VERR_WRONG_ORDER;
+            if (pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_SUSPENDING, PDMTHREADSTATE_RUNNING))
+            {
+                rc = pdmR3ThreadWakeUp(pThread);
+                if (RT_SUCCESS(rc))
+                {
+                    /*
+                     * Wait for the thread to reach the suspended state.
+                     */
+                    if (pThread->enmState != PDMTHREADSTATE_SUSPENDED)
+                        rc = RTThreadUserWait(pThread->Thread, 60*1000);
+                    if (    RT_SUCCESS(rc)
+                        &&  pThread->enmState != PDMTHREADSTATE_SUSPENDED)
+                        rc = VERR_PDM_THREAD_IPE_2;
+                    if (RT_SUCCESS(rc))
+                        return rc;
+                }
+            }
+        }
+    }
+
+    /*
+     * Something failed, initialize termination.
+     */
+    AssertMsgFailed(("PDMR3ThreadSuspend -> rc=%Rrc enmState=%d suspending '%s'\n",
+                     rc, pThread->enmState, RTThreadGetName(pThread->Thread)));
+    pdmR3ThreadBailOut(pThread);
+    return rc;
+}
+
+
+/**
+ * Resumes the thread.
+ *
+ * This can be called the power on / resume notifications to resume the
+ * PDM thread a bit early. The thread will be automatically resumed upon
+ * return from these two notification callbacks (devices/drivers).
+ *
+ * The caller is responsible for serializing the control operations on the
+ * thread. That basically means, always do these calls from the EMT.
+ *
+ * @returns VBox status code.
+ * @param   pThread     The PDM thread.
+ */
+DECLHIDDEN(int) tstDevPdmR3ThreadResume(PPDMTHREAD pThread)
+{
+    /*
+     * Assert sanity.
+     */
+    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+    AssertReturn(pThread->u32Version == PDMTHREAD_VERSION, VERR_INVALID_MAGIC);
+    Assert(pThread->Thread != RTThreadSelf());
+
+    /*
+     * Change the state to resuming and kick the thread.
+     */
+    int rc = RTThreadUserReset(pThread->Thread);
+    if (RT_SUCCESS(rc))
+    {
+        rc = VERR_WRONG_ORDER;
+        if (pdmR3AtomicCmpXchgState(pThread, PDMTHREADSTATE_RESUMING, PDMTHREADSTATE_SUSPENDED))
+        {
+            rc = RTSemEventMultiSignal(pThread->Internal.s.BlockEvent);
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * Wait for the thread to reach the running state.
+                 */
+                rc = RTThreadUserWait(pThread->Thread, 60*1000);
+                if (    RT_SUCCESS(rc)
+                    &&  pThread->enmState != PDMTHREADSTATE_RUNNING)
+                    rc = VERR_PDM_THREAD_IPE_2;
+                if (RT_SUCCESS(rc))
+                    return rc;
+            }
+        }
+    }
+
+    /*
+     * Something failed, initialize termination.
+     */
+    AssertMsgFailed(("PDMR3ThreadResume -> rc=%Rrc enmState=%d\n", rc, pThread->enmState));
+    pdmR3ThreadBailOut(pThread);
+    return rc;
+}
+
diff --git a/src/VBox/Devices/testcase/tstDevicePlugin.h b/src/VBox/Devices/testcase/tstDevicePlugin.h
new file mode 100644
index 00000000..a125f1cd
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDevicePlugin.h
@@ -0,0 +1,100 @@
+/** @file
+ * tstDevice: Plugin API.
+ */
+
+/*
+ * Copyright (C) 2017-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#ifndef VBOX_INCLUDED_SRC_testcase_tstDevicePlugin_h
+#define VBOX_INCLUDED_SRC_testcase_tstDevicePlugin_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/types.h>
+
+#include "tstDeviceCfg.h"
+
+
+/** Device under test handle. */
+typedef struct TSTDEVDUTINT *TSTDEVDUT;
+
+/**
+ * Testcase registration structure.
+ */
+typedef struct TSTDEVTESTCASEREG
+{
+    /** Testcase name. */
+    char                szName[16];
+    /** Testcase description. */
+    const char          *pszDesc;
+    /** Flags for this testcase. */
+    uint32_t            fFlags;
+
+    /**
+     * Testcase entry point.
+     *
+     * @returns VBox status code.
+     * @param   hDut      Handle of the device under test.
+     * @param   paCfg     Pointer to the testcase config.
+     * @param   cCfgItems Number of config items.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnTestEntry, (TSTDEVDUT hDut, PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems));
+} TSTDEVTESTCASEREG;
+/** Pointer to a testcase registration structure. */
+typedef TSTDEVTESTCASEREG *PTSTDEVTESTCASEREG;
+/** Pointer to a constant testcase registration structure. */
+typedef const TSTDEVTESTCASEREG *PCTSTDEVTESTCASEREG;
+
+
+/**
+ * Testcase register callbacks structure.
+ */
+typedef struct TSTDEVPLUGINREGISTER
+{
+    /**
+     * Registers a new testcase.
+     *
+     * @returns VBox status code.
+     * @param   pvUser       Opaque user data given in the plugin load callback.
+     * @param   pTestcaseReg The testcase descriptor to register.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnRegisterTestcase, (void *pvUser, PCTSTDEVTESTCASEREG pTestcaseReg));
+
+} TSTDEVPLUGINREGISTER;
+/** Pointer to a backend register callbacks structure. */
+typedef TSTDEVPLUGINREGISTER *PTSTDEVPLUGINREGISTER;
+
+
+/**
+ * Initialization entry point called by the device test framework when
+ * a plugin is loaded.
+ *
+ * @returns VBox status code.
+ * @param   pvUser             Opaque user data passed in the register callbacks.
+ * @param   pRegisterCallbacks Pointer to the register callbacks structure.
+ */
+typedef DECLCALLBACKTYPE(int, FNTSTDEVPLUGINLOAD,(void *pvUser, PTSTDEVPLUGINREGISTER pRegisterCallbacks));
+typedef FNTSTDEVPLUGINLOAD *PFNTSTDEVPLUGINLOAD;
+#define TSTDEV_PLUGIN_LOAD_NAME "TSTDevPluginLoad"
+
+#endif /* !VBOX_INCLUDED_SRC_testcase_tstDevicePlugin_h */
diff --git a/src/VBox/Devices/testcase/tstDeviceR0.cpp b/src/VBox/Devices/testcase/tstDeviceR0.cpp
new file mode 100644
index 00000000..4912c575
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDeviceR0.cpp
@@ -0,0 +1,163 @@
+/* $Id: tstDeviceR0.cpp $ */
+/** @file
+ * tstDevice - Test framework for PDM devices/drivers
+ */
+
+/*
+ * Copyright (C) 2017-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
+#undef IN_RING3
+#undef IN_SUP_R3
+//#undef CTX_SUFF
+//#undef R0PTRTYPE
+//#undef R3PTRTYPE
+#define IN_RING0
+#define IN_SUP_R0
+#define LINUX_VERSION_CODE 0
+#define KERNEL_VERSION(a,b,c) 1
+//#define CTX_SUFF(a_Name) a_Name##R0
+//#define R3PTRTYPE(a_R3Type)     RTHCUINTPTR
+//#define R0PTRTYPE(a_R0Type)     a_R0Type
+#include <VBox/types.h>
+
+#include <VBox/sup.h>
+#include <VBox/version.h>
+#include <iprt/assert.h>
+#include <iprt/getopt.h>
+#include <iprt/log.h>
+#include <iprt/list.h>
+#include <iprt/mem.h>
+
+#include "tstDeviceInternal.h"
+#include "tstDeviceCfg.h"
+#include "tstDeviceBuiltin.h"
+
+
+
+/**
+ * Create a new PDM device with default config.
+ *
+ * @returns VBox status code.
+ * @param   pszName                 Name of the device to create.
+ * @param   fRCEnabled              Flag whether RC support should be enabled for this device.
+ * @param   pDut                    The device under test structure the created PDM device instance is exercised under.
+ */
+DECLHIDDEN(int) tstDevPdmDevR0R3Create(const char *pszName, bool fRCEnabled, PTSTDEVDUTINT pDut)
+{
+    int rc = VINF_SUCCESS;
+    PCPDMDEVREGR0 pPdmDevR0 = NULL;
+    PCTSTDEVPDMDEV pPdmDev = tstDevPdmDeviceFind(pszName, &pPdmDevR0);
+    if (RT_LIKELY(pPdmDev))
+    {
+        uint32_t const cbRing0     = RT_ALIGN_32(RT_UOFFSETOF(PDMDEVINSR0, achInstanceData) + pPdmDevR0->cbInstanceCC,
+                                                 HOST_PAGE_SIZE);
+        uint32_t const cbRing3     = RT_ALIGN_32(RT_UOFFSETOF(PDMDEVINSR3, achInstanceData) + pPdmDev->pReg->cbInstanceCC,
+                                                 fRCEnabled ? HOST_PAGE_SIZE : 64);
+        uint32_t const cbRC        = fRCEnabled ? 0
+                                   : RT_ALIGN_32(RT_UOFFSETOF(PDMDEVINSRC, achInstanceData) + pPdmDevR0->cbInstanceRC, 64);
+        uint32_t const cbShared    = RT_ALIGN_32(pPdmDev->pReg->cbInstanceShared, 64);
+        uint32_t const cbCritSect  = RT_ALIGN_32(sizeof(PDMCRITSECT), 64);
+        uint32_t const cbMsixState = RT_ALIGN_32(pPdmDev->pReg->cMaxMsixVectors * 16 + (pPdmDev->pReg->cMaxMsixVectors + 7) / 8, _4K);
+        uint32_t const cbPciDev    = RT_ALIGN_32(RT_UOFFSETOF_DYN(PDMPCIDEV, abMsixState[cbMsixState]), 64);
+        uint32_t const cPciDevs    = RT_MIN(pPdmDev->pReg->cMaxPciDevices, 8);
+        uint32_t const cbPciDevs   = cbPciDev * cPciDevs;
+        uint32_t const cbTotal     = RT_ALIGN_32(cbRing0 + cbRing3 + cbRC + cbShared + cbCritSect + cbPciDevs, HOST_PAGE_SIZE);
+        AssertLogRelMsgReturn(cbTotal <= PDM_MAX_DEVICE_INSTANCE_SIZE,
+                              ("Instance of '%s' is too big: cbTotal=%u, max %u\n",
+                               pPdmDev->pReg->szName, cbTotal, PDM_MAX_DEVICE_INSTANCE_SIZE),
+                              VERR_OUT_OF_RANGE);
+
+        PPDMDEVINSR0 pDevInsR0 = (PPDMDEVINSR0)RTMemAllocZ(cbTotal);
+        PDMDEVINSR3 *pDevInsR3   = (PDMDEVINSR3 *)(((uint8_t *)pDevInsR0 + cbRing0));
+
+        pDevInsR0->u32Version             = PDM_DEVINSR0_VERSION;
+        pDevInsR0->iInstance              = 0;
+        pDevInsR0->pHlpR0                 = &g_tstDevPdmDevHlpR0;
+        pDevInsR0->Internal.s.pDut        = pDut;
+        pDevInsR0->pvInstanceDataR0       = (uint8_t *)pDevInsR0 + cbRing0 + cbRing3 + cbRC;
+        pDevInsR0->pvInstanceDataForR0    = &pDevInsR0->achInstanceData[0];
+        pDevInsR0->pCritSectRoR0          = (PPDMCRITSECT)((uint8_t *)pDevInsR0->pvInstanceDataR0 + cbShared);
+        pDevInsR0->pReg                   = pPdmDevR0;
+        pDevInsR0->pDevInsForR3           = (RTHCUINTPTR)pDevInsR3;
+        pDevInsR0->pDevInsForR3R0         = pDevInsR3;
+        pDevInsR0->pvInstanceDataForR3R0  = &pDevInsR3->achInstanceData[0];
+        pDevInsR0->cbPciDev               = cbPciDev;
+        pDevInsR0->cPciDevs               = cPciDevs;
+        for (uint32_t iPciDev = 0; iPciDev < cPciDevs; iPciDev++)
+        {
+            /* Note! PDMDevice.cpp has a copy of this code.  Keep in sync. */
+            PPDMPCIDEV pPciDev = (PPDMPCIDEV)((uint8_t *)pDevInsR0->pCritSectRoR0 + cbCritSect + cbPciDev * iPciDev);
+            if (iPciDev < RT_ELEMENTS(pDevInsR0->apPciDevs))
+                pDevInsR0->apPciDevs[iPciDev] = pPciDev;
+            pPciDev->cbConfig           = _4K;
+            pPciDev->cbMsixState        = cbMsixState;
+            pPciDev->idxSubDev          = (uint16_t)iPciDev;
+            //pPciDev->Int.s.idxSubDev    = (uint16_t)iPciDev;
+            pPciDev->u32Magic           = PDMPCIDEV_MAGIC;
+        }
+
+        pDevInsR3->u32Version               = PDM_DEVINSR3_VERSION;
+        pDevInsR3->iInstance                = 0;
+        pDevInsR3->cbRing3                  = cbRing3;
+        pDevInsR3->fR0Enabled               = true;
+        pDevInsR3->fRCEnabled               = fRCEnabled;
+        pDevInsR3->pvInstanceDataR3     = pDevInsR0->pDevInsForR3 + cbRing3 + cbRC;
+        pDevInsR3->pvInstanceDataForR3  = pDevInsR0->pDevInsForR3 + RT_UOFFSETOF(PDMDEVINSR3, achInstanceData);
+        pDevInsR3->pCritSectRoR3        = pDevInsR0->pDevInsForR3 + cbRing3 + cbRC + cbShared;
+        pDevInsR3->pDevInsR0RemoveMe    = pDevInsR0;
+        pDevInsR3->pvInstanceDataR0     = pDevInsR0->pvInstanceDataR0;
+        pDevInsR3->pvInstanceDataRC     = fRCEnabled ? NIL_RTRGPTR : pDevInsR0->pDevInsForRC + RT_UOFFSETOF(PDMDEVINSRC, achInstanceData);
+        pDevInsR3->pDevInsForRC         = pDevInsR0->pDevInsForRC;
+        pDevInsR3->pDevInsForRCR3       = pDevInsR0->pDevInsForR3 + cbRing3;
+        pDevInsR3->pDevInsForRCR3       = pDevInsR3->pDevInsForRCR3 + RT_UOFFSETOF(PDMDEVINSRC, achInstanceData);
+        pDevInsR3->cbPciDev             = cbPciDev;
+        pDevInsR3->cPciDevs             = cPciDevs;
+        for (uint32_t i = 0; i < RT_MIN(cPciDevs, RT_ELEMENTS(pDevInsR3->apPciDevs)); i++)
+            pDevInsR3->apPciDevs[i] = pDevInsR3->pCritSectRoR3 + cbCritSect + cbPciDev * i;
+        RTCritSectInit(&pDevInsR0->pCritSectRoR0->s.CritSect);
+        pDut->pDevIns   = pDevInsR3;
+        pDut->pDevInsR0 = pDevInsR0;
+
+        rc = tstDevPdmDeviceR3Construct(pDut);
+        if (RT_SUCCESS(rc))
+        {
+            rc = pPdmDevR0->pfnConstruct(pDevInsR0);
+            if (RT_SUCCESS(rc))
+                return VINF_SUCCESS;
+        }
+
+        if (RT_FAILURE(rc))
+        {
+            //rc = pPdmDev->pReg->pfnDestruct(pDevIns);
+            RTMemFree(pDevInsR0);
+        }
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    return rc;
+}
diff --git a/src/VBox/Devices/testcase/tstDeviceSsmFuzz.cpp b/src/VBox/Devices/testcase/tstDeviceSsmFuzz.cpp
new file mode 100644
index 00000000..8bd2f46f
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDeviceSsmFuzz.cpp
@@ -0,0 +1,200 @@
+/* $Id: tstDeviceSsmFuzz.cpp $ */
+/** @file
+ * tstDeviceSsmFuzz - SSM fuzzing testcase.
+ */
+
+/*
+ * Copyright (C) 2020-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
+#include <VBox/types.h>
+#include <iprt/errcore.h>
+#include <iprt/mem.h>
+#include <iprt/fuzz.h>
+#include <iprt/time.h>
+#include <iprt/string.h>
+
+#include "tstDeviceBuiltin.h"
+#include "tstDeviceCfg.h"
+#include "tstDeviceInternal.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+
+static PCTSTDEVCFGITEM tstDevSsmFuzzGetCfgItem(PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems, const char *pszName)
+{
+    for (uint32_t i = 0; i < cCfgItems; i++)
+    {
+        if (!RTStrCmp(paCfg[i].pszKey, pszName))
+            return &paCfg[i];
+    }
+
+    return NULL;
+}
+
+
+static const char *tstDevSsmFuzzGetCfgString(PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems, const char *pszName)
+{
+    PCTSTDEVCFGITEM pCfgItem = tstDevSsmFuzzGetCfgItem(paCfg, cCfgItems, pszName);
+    if (   pCfgItem
+        && pCfgItem->enmType == TSTDEVCFGITEMTYPE_STRING)
+        return pCfgItem->u.psz;
+
+    return NULL;
+}
+
+
+static uint64_t tstDevSsmFuzzGetCfgU64(PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems, const char *pszName)
+{
+    PCTSTDEVCFGITEM pCfgItem = tstDevSsmFuzzGetCfgItem(paCfg, cCfgItems, pszName);
+    if (   pCfgItem
+        && pCfgItem->enmType == TSTDEVCFGITEMTYPE_INTEGER)
+        return (uint64_t)pCfgItem->u.i64;
+
+    return 0;
+}
+
+
+static uint32_t tstDevSsmFuzzGetCfgU32(PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems, const char *pszName)
+{
+    PCTSTDEVCFGITEM pCfgItem = tstDevSsmFuzzGetCfgItem(paCfg, cCfgItems, pszName);
+    if (   pCfgItem
+        && pCfgItem->enmType == TSTDEVCFGITEMTYPE_INTEGER)
+        return (uint32_t)pCfgItem->u.i64;
+
+    return 0;
+}
+
+
+/**
+ * Entry point for the SSM fuzzer.
+ *
+ * @returns VBox status code.
+ * @param   hDut                The device under test.
+ * @param   paCfg               The testcase config.
+ * @param   cCfgItems           Number of config items.
+ */
+static DECLCALLBACK(int) tstDevSsmFuzzEntry(TSTDEVDUT hDut, PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems)
+{
+    RTFUZZCTX hFuzzCtx;
+    int rc = RTFuzzCtxCreate(&hFuzzCtx, RTFUZZCTXTYPE_BLOB);
+    if (RT_SUCCESS(rc))
+    {
+        RTFUZZCFG hFuzzCfg;
+        rc = RTFuzzCfgCreateFromFile(&hFuzzCfg, tstDevSsmFuzzGetCfgString(paCfg, cCfgItems, "CorpusPath"), NULL);
+        if (RT_SUCCESS(rc))
+        {
+            rc = RTFuzzCfgImport(hFuzzCfg, hFuzzCtx, RTFUZZCFG_IMPORT_F_DEFAULT);
+            RTFuzzCfgRelease(hFuzzCfg);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Create a new SSM handle to use. */
+            PSSMHANDLE pSsm = (PSSMHANDLE)RTMemAllocZ(sizeof(*pSsm));
+            if (RT_LIKELY(pSsm))
+            {
+                pSsm->pDut          = hDut;
+                pSsm->pbSavedState  = NULL;
+                pSsm->cbSavedState  = 0;
+                pSsm->offDataBuffer = 0;
+                pSsm->uCurUnitVer   = tstDevSsmFuzzGetCfgU32(paCfg, cCfgItems, "UnitVersion");
+                pSsm->rc            = VINF_SUCCESS;
+
+                uint64_t cRuntimeMs = tstDevSsmFuzzGetCfgU64(paCfg, cCfgItems, "RuntimeSec") * RT_MS_1SEC_64;
+                uint64_t tsStart = RTTimeMilliTS();
+                uint64_t cFuzzedInputs = 0;
+                do
+                {
+                    RTFUZZINPUT hFuzzInp;
+                    rc = RTFuzzCtxInputGenerate(hFuzzCtx, &hFuzzInp);
+                    if (RT_SUCCESS(rc))
+                    {
+                        void *pvBlob = NULL;
+                        size_t cbBlob = 0;
+
+                        rc = RTFuzzInputQueryBlobData(hFuzzInp, &pvBlob, &cbBlob);
+                        if (RT_SUCCESS(rc))
+                        {
+                            pSsm->pbSavedState  = (uint8_t *)pvBlob;
+                            pSsm->cbSavedState  = cbBlob;
+                            pSsm->offDataBuffer = 0;
+                            pSsm->rc            = VINF_SUCCESS;
+
+                            /* Get the SSM handler from the device. */
+                            int rcDut = VINF_SUCCESS;
+                            PTSTDEVDUTSSM pSsmClbks = RTListGetFirst(&hDut->LstSsmHandlers, TSTDEVDUTSSM, NdSsm);
+                            if (pSsmClbks)
+                            {
+                                /* Load preparations. */
+                                if (pSsmClbks->pfnLoadPrep)
+                                    rcDut = pSsmClbks->pfnLoadPrep(hDut->pDevIns, pSsm);
+                                if (RT_SUCCESS(rcDut))
+                                    rcDut = pSsmClbks->pfnLoadExec(hDut->pDevIns, pSsm, pSsm->uCurUnitVer, SSM_PASS_FINAL);
+
+                                cFuzzedInputs++;
+                            }
+                            if (RT_SUCCESS(rcDut))
+                                RTFuzzInputAddToCtxCorpus(hFuzzInp);
+                        }
+                        RTFuzzInputRelease(hFuzzInp);
+                    }
+                } while (   RT_SUCCESS(rc)
+                         && RTTimeMilliTS() - tsStart < cRuntimeMs);
+
+                RTMemFree(pSsm);
+            }
+            else
+                rc = VERR_NO_MEMORY;
+        }
+
+        RTFuzzCtxRelease(hFuzzCtx);
+    }
+
+    return rc;
+}
+
+
+const TSTDEVTESTCASEREG g_TestcaseSsmFuzz =
+{
+    /** szName */
+    "SsmFuzz",
+    /** pszDesc */
+    "Fuzzes devices SSM state loaders",
+    /** fFlags */
+    0,
+    /** pfnTestEntry */
+    tstDevSsmFuzzEntry
+};
+
diff --git a/src/VBox/Devices/testcase/tstDeviceSsmLoadDbg.cpp b/src/VBox/Devices/testcase/tstDeviceSsmLoadDbg.cpp
new file mode 100644
index 00000000..860e1345
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDeviceSsmLoadDbg.cpp
@@ -0,0 +1,159 @@
+/* $Id: tstDeviceSsmLoadDbg.cpp $ */
+/** @file
+ * tstDeviceSsmFuzz - SSM fuzzing testcase.
+ */
+
+/*
+ * Copyright (C) 2020-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
+#include <VBox/types.h>
+#include <iprt/errcore.h>
+#include <iprt/mem.h>
+#include <iprt/file.h>
+#include <iprt/fuzz.h>
+#include <iprt/time.h>
+#include <iprt/string.h>
+
+#include "tstDeviceBuiltin.h"
+#include "tstDeviceCfg.h"
+#include "tstDeviceInternal.h"
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+
+
+/*********************************************************************************************************************************
+*   Structures and Typedefs                                                                                                      *
+*********************************************************************************************************************************/
+
+
+static PCTSTDEVCFGITEM tstDevSsmFuzzGetCfgItem(PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems, const char *pszName)
+{
+    for (uint32_t i = 0; i < cCfgItems; i++)
+    {
+        if (!RTStrCmp(paCfg[i].pszKey, pszName))
+            return &paCfg[i];
+    }
+
+    return NULL;
+}
+
+
+static const char *tstDevSsmFuzzGetCfgString(PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems, const char *pszName)
+{
+    PCTSTDEVCFGITEM pCfgItem = tstDevSsmFuzzGetCfgItem(paCfg, cCfgItems, pszName);
+    if (   pCfgItem
+        && pCfgItem->enmType == TSTDEVCFGITEMTYPE_STRING)
+        return pCfgItem->u.psz;
+
+    return NULL;
+}
+
+
+static uint32_t tstDevSsmFuzzGetCfgU32(PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems, const char *pszName)
+{
+    PCTSTDEVCFGITEM pCfgItem = tstDevSsmFuzzGetCfgItem(paCfg, cCfgItems, pszName);
+    if (   pCfgItem
+        && pCfgItem->enmType == TSTDEVCFGITEMTYPE_INTEGER)
+        return (uint32_t)pCfgItem->u.i64;
+
+    return 0;
+}
+
+
+/**
+ * Entry point for the SSM load debug.
+ *
+ * @returns VBox status code.
+ * @param   hDut                The device under test.
+ * @param   paCfg               The testcase config.
+ * @param   cCfgItems           Number of config items.
+ */
+static DECLCALLBACK(int) tstDevSsmLoadDbgEntry(TSTDEVDUT hDut, PCTSTDEVCFGITEM paCfg, uint32_t cCfgItems)
+{
+    int rc = VINF_SUCCESS;
+    const char *pszSsmUnit = tstDevSsmFuzzGetCfgString(paCfg, cCfgItems, "SsmUnit");
+    if (pszSsmUnit)
+    {
+        void *pvData = NULL;
+        size_t cbData = 0;
+
+        rc = RTFileReadAll(pszSsmUnit, &pvData, &cbData);
+        if (RT_SUCCESS(rc))
+        {
+            /* Create a new SSM handle to use. */
+            PSSMHANDLE pSsm = (PSSMHANDLE)RTMemAllocZ(sizeof(*pSsm));
+            if (RT_LIKELY(pSsm))
+            {
+                pSsm->pDut          = hDut;
+                pSsm->pbSavedState  = (uint8_t *)pvData;
+                pSsm->cbSavedState  = cbData;
+                pSsm->offDataBuffer = 0;
+                pSsm->uCurUnitVer   = tstDevSsmFuzzGetCfgU32(paCfg, cCfgItems, "UnitVersion");
+                pSsm->rc            = VINF_SUCCESS;
+
+
+                /* Get the SSM handler from the device. */
+                int rcDut = VINF_SUCCESS;
+                PTSTDEVDUTSSM pSsmClbks = RTListGetFirst(&hDut->LstSsmHandlers, TSTDEVDUTSSM, NdSsm);
+                if (pSsmClbks)
+                {
+                    /* Load preparations. */
+                    if (pSsmClbks->pfnLoadPrep)
+                        rcDut = pSsmClbks->pfnLoadPrep(hDut->pDevIns, pSsm);
+                    if (RT_SUCCESS(rcDut))
+                        rcDut = pSsmClbks->pfnLoadExec(hDut->pDevIns, pSsm, pSsm->uCurUnitVer, SSM_PASS_FINAL);
+                }
+                RTMemFree(pSsm);
+            }
+            else
+                rc = VERR_NO_MEMORY;
+
+            RTFileReadAllFree(pvData, cbData);
+        }
+    }
+    else
+        rc = VERR_NOT_FOUND;
+
+    return rc;
+}
+
+
+const TSTDEVTESTCASEREG g_TestcaseSsmLoadDbg =
+{
+    /** szName */
+    "SsmLoadDbg",
+    /** pszDesc */
+    "Load SSM states which fail to load in VBox for investigation",
+    /** fFlags */
+    0,
+    /** pfnTestEntry */
+    tstDevSsmLoadDbgEntry
+};
+
diff --git a/src/VBox/Devices/testcase/tstDeviceStructSize.cpp b/src/VBox/Devices/testcase/tstDeviceStructSize.cpp
new file mode 100644
index 00000000..27b3790e
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDeviceStructSize.cpp
@@ -0,0 +1,454 @@
+/* $Id: tstDeviceStructSize.cpp $ */
+/** @file
+ * tstDeviceStructSize - testcase for check structure sizes/alignment
+ *                       and to verify that HC and RC uses the same
+ *                       representation of the structures.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <VBox/types.h>
+#include <iprt/x86.h>
+
+#define VBOX_WITH_HGCM                  /* grumble */
+#define VBOX_DEVICE_STRUCT_TESTCASE
+
+/* Check that important preprocessor macros does not get redefined: */
+#include <VBox/cdefs.h>
+#include <VBox/log.h>
+#ifdef DEBUG
+# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_DEBUG
+#else
+# undef  VBOX_DEVICE_STRUCT_TESTCASE_CHECK_DEBUG
+#endif
+#ifdef LOG_ENABLED
+# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_LOG_ENABLED
+#else
+# undef  VBOX_DEVICE_STRUCT_TESTCASE_CHECK_LOG_ENABLED
+#endif
+#ifdef VBOX_STRICT
+# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_VBOX_STRICT
+#else
+# undef  VBOX_DEVICE_STRUCT_TESTCASE_CHECK_VBOX_STRICT
+#endif
+#ifdef RT_STRICT
+# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_RT_STRICT
+#else
+# undef  VBOX_DEVICE_STRUCT_TESTCASE_CHECK_RT_STRICT
+#endif
+
+/* The structures we're checking: */
+#undef LOG_GROUP
+#include "../Bus/DevPciInternal.h"
+#undef LOG_GROUP
+#include "../Graphics/DevVGA.cpp"
+#undef LOG_GROUP
+#include "../Input/DevPS2.h"
+#ifdef VBOX_WITH_E1000
+# undef LOG_GROUP
+# include "../Network/DevE1000.cpp"
+#endif
+#undef LOG_GROUP
+#include "../Network/DevPCNet.cpp"
+#undef LOG_GROUP
+#include "../PC/DevACPI.cpp"
+#undef LOG_GROUP
+#include "../PC/DevPIC.cpp"
+#undef LOG_GROUP
+#include "../PC/DevPit-i8254.cpp"
+#undef LOG_GROUP
+#include "../PC/DevRTC.cpp"
+# undef LOG_GROUP
+# include "../../VMM/VMMR3/APIC.cpp"
+#undef LOG_GROUP
+#include "../PC/DevIoApic.cpp"
+#undef LOG_GROUP
+#include "../PC/DevHPET.cpp"
+#undef LOG_GROUP
+#include "../PC/DevDMA.cpp"
+#undef LOG_GROUP
+#include "../EFI/DevSmc.cpp"
+#undef LOG_GROUP
+#include "../Storage/DevATA.cpp"
+#ifdef VBOX_WITH_USB
+# undef LOG_GROUP
+# include "../USB/DevOHCI.cpp"
+# ifdef VBOX_WITH_EHCI_IMPL
+#  undef LOG_GROUP
+#  include "../USB/DevEHCI.cpp"
+# endif
+# ifdef VBOX_WITH_XHCI_IMPL
+#  undef LOG_GROUP
+#  include "../USB/DevXHCI.cpp"
+# endif
+#endif
+#undef LOG_GROUP
+#include "../VMMDev/VMMDev.cpp"
+#undef LOG_GROUP
+#include "../Parallel/DevParallel.cpp"
+#undef LOG_GROUP
+#include "../Serial/DevSerial.cpp"
+#undef LOG_GROUP
+#include "../Serial/DevOxPcie958.cpp"
+#ifdef VBOX_WITH_AHCI
+# undef LOG_GROUP
+# include "../Storage/DevAHCI.cpp"
+#endif
+#ifdef VBOX_WITH_BUSLOGIC
+# undef LOG_GROUP
+# include "../Storage/DevBusLogic.cpp"
+#endif
+#ifdef VBOX_WITH_LSILOGIC
+# undef LOG_GROUP
+# include "../Storage/DevLsiLogicSCSI.cpp"
+#endif
+#ifdef VBOX_WITH_NVME_IMPL
+# undef LOG_GROUP
+# include "../Storage/DevNVMe.cpp"
+#endif
+
+#ifdef VBOX_WITH_PCI_PASSTHROUGH_IMPL
+# undef LOG_GROUP
+# include "../Bus/DevPciRaw.cpp"
+#endif
+
+#ifdef VBOX_WITH_IOMMU_AMD
+# undef LOG_GROUP
+# include "../Bus/DevIommuAmd.cpp"
+#endif
+#ifdef VBOX_WITH_IOMMU_INTEL
+# undef LOG_GROUP
+# include "../Bus/DevIommuIntel.cpp"
+#endif
+
+#include <VBox/vmm/pdmaudioifs.h>
+
+#undef LOG_GROUP
+#include "../Audio/DevIchAc97.cpp"
+#undef LOG_GROUP
+#include "../Audio/DevHda.h"
+
+
+/* Check that important preprocessor macros didn't get redefined: */
+#if defined(DEBUG)       != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_DEBUG)
+# error "DEBUG was modified!  This may throw off structure tests."
+#endif
+#if defined(LOG_ENABLED) != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_LOG_ENABLED)
+# error "LOG_ENABLED was modified!  This may throw off structure tests."
+#endif
+#if defined(RT_STRICT)   != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_RT_STRICT)
+# error "RT_STRICT was modified!  This may throw off structure tests."
+#endif
+#if defined(VBOX_STRICT) != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_VBOX_STRICT)
+# error "VBOX_STRICT was modified!  This may throw off structure tests."
+#endif
+
+
+#include <iprt/stream.h>
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/**
+ * Checks the offset of a data member.
+ * @param   type    Type.
+ * @param   off     Correct offset.
+ * @param   m       Member name.
+ */
+#define CHECK_OFF(type, off, m) \
+    do { \
+        if (off != RT_OFFSETOF(type, m)) \
+        { \
+            RTPrintf("tstDeviceStructSize: Error! %#010x %s  Member offset wrong by %d (should be %d -- but is %d)\n", \
+                     RT_OFFSETOF(type, m), #type "." #m, off - RT_OFFSETOF(type, m), off, RT_OFFSETOF(type, m)); \
+            rc++; \
+        } \
+        else  \
+            RTPrintf("%#08x (%d) %s\n", RT_OFFSETOF(type, m), RT_OFFSETOF(type, m), #type "." #m); \
+    } while (0)
+
+/**
+ * Checks the size of type.
+ * @param   type    Type.
+ * @param   size    Correct size.
+ */
+#define CHECK_SIZE(type, size) \
+    do { \
+        if (size != sizeof(type)) \
+        { \
+            RTPrintf("tstDeviceStructSize: Error! sizeof(%s): %#x (%d)  Size wrong by %d (should be %d -- but is %d)\n", \
+                     #type, (int)sizeof(type), (int)sizeof(type), (int)sizeof(type) - (int)size, (int)size, (int)sizeof(type)); \
+            rc++; \
+        } \
+        else \
+            RTPrintf("tstDeviceStructSize: info: sizeof(%s): %#x (%d)\n", #type, (int)sizeof(type), (int)sizeof(type)); \
+    } while (0)
+
+/**
+ * Checks the alignment of a struct member.
+ */
+#define CHECK_MEMBER_ALIGNMENT(strct, member, align) \
+    do \
+    { \
+        if (RT_OFFSETOF(strct, member) & ((align) - 1) ) \
+        { \
+            RTPrintf("tstDeviceStructSize: error! %s::%s offset=%#x (%u) expected alignment %#x, meaning %#x (%u) off\n", \
+                     #strct, #member, \
+                     (unsigned)RT_OFFSETOF(strct, member), \
+                     (unsigned)RT_OFFSETOF(strct, member), \
+                     (unsigned)(align), \
+                     (unsigned)(((align) - RT_OFFSETOF(strct, member)) & ((align) - 1)), \
+                     (unsigned)(((align) - RT_OFFSETOF(strct, member)) & ((align) - 1)) ); \
+            rc++; \
+        } \
+    } while (0)
+
+/**
+ * Checks that the size of a type is aligned correctly.
+ */
+#define CHECK_SIZE_ALIGNMENT(type, align) \
+    do { \
+        if (RT_ALIGN_Z(sizeof(type), (align)) != sizeof(type)) \
+        { \
+            RTPrintf("tstDeviceStructSize: error! %s size=%#x (%u), align=%#x %#x (%u) bytes off\n", \
+                     #type, \
+                     (unsigned)sizeof(type), \
+                     (unsigned)sizeof(type), \
+                     (align), \
+                     (unsigned)RT_ALIGN_Z(sizeof(type), align) - (unsigned)sizeof(type), \
+                     (unsigned)RT_ALIGN_Z(sizeof(type), align) - (unsigned)sizeof(type)); \
+            rc++; \
+        } \
+    } while (0)
+
+/**
+ * Checks that a internal struct padding is big enough.
+ */
+#define CHECK_PADDING(strct, member, align) \
+    do \
+    { \
+        strct *p = NULL; NOREF(p); \
+        if (sizeof(p->member.s) > sizeof(p->member.padding)) \
+        { \
+            RTPrintf("tstDeviceStructSize: error! padding of %s::%s is too small, padding=%d struct=%d correct=%d\n", #strct, #member, \
+                     (int)sizeof(p->member.padding), (int)sizeof(p->member.s), (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
+            rc++; \
+        } \
+        else if (RT_ALIGN_Z(sizeof(p->member.padding), (align)) != sizeof(p->member.padding)) \
+        { \
+            RTPrintf("tstDeviceStructSize: error! padding of %s::%s is misaligned, padding=%d correct=%d\n", #strct, #member, \
+                     (int)sizeof(p->member.padding), (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \
+            rc++; \
+        } \
+    } while (0)
+
+/**
+ * Checks that a internal struct padding is big enough.
+ */
+#define CHECK_PADDING2(strct) \
+    do \
+    { \
+        strct *p = NULL; NOREF(p); \
+        if (sizeof(p->s) > sizeof(p->padding)) \
+        { \
+            RTPrintf("tstDeviceStructSize: error! padding of %s is too small, padding=%d struct=%d correct=%d\n", #strct, \
+                     (int)sizeof(p->padding), (int)sizeof(p->s), (int)RT_ALIGN_Z(sizeof(p->s), 32)); \
+            rc++; \
+        } \
+    } while (0)
+
+/**
+ * Checks that a internal struct padding is big enough.
+ */
+#define CHECK_PADDING3(strct, member, pad_member) \
+    do \
+    { \
+        strct *p = NULL; NOREF(p); \
+        if (sizeof(p->member) > sizeof(p->pad_member)) \
+        { \
+            RTPrintf("tstDeviceStructSize: error! padding of %s::%s is too small, padding=%d struct=%d\n", #strct, #member, \
+                     (int)sizeof(p->pad_member), (int)sizeof(p->member)); \
+            rc++; \
+        } \
+    } while (0)
+
+/**
+ * Prints the offset of a struct member.
+ */
+#define PRINT_OFFSET(strct, member) \
+    do \
+    { \
+        RTPrintf("tstDeviceStructSize: info: %s::%s offset %d sizeof %d\n",  #strct, #member, (int)RT_OFFSETOF(strct, member), (int)RT_SIZEOFMEMB(strct, member)); \
+    } while (0)
+
+
+int main()
+{
+    int rc = 0;
+    RTPrintf("tstDeviceStructSize: TESTING\n");
+
+    /* Assert sanity */
+    CHECK_SIZE(uint128_t, 128/8);
+    CHECK_SIZE(int128_t, 128/8);
+    CHECK_SIZE(uint64_t, 64/8);
+    CHECK_SIZE(int64_t, 64/8);
+    CHECK_SIZE(uint32_t, 32/8);
+    CHECK_SIZE(int32_t, 32/8);
+    CHECK_SIZE(uint16_t, 16/8);
+    CHECK_SIZE(int16_t, 16/8);
+    CHECK_SIZE(uint8_t, 8/8);
+    CHECK_SIZE(int8_t, 8/8);
+
+    /* Basic alignment checks. */
+    CHECK_MEMBER_ALIGNMENT(PDMDEVINS, achInstanceData, 64);
+    CHECK_MEMBER_ALIGNMENT(PDMPCIDEV, Int.s, 16);
+    CHECK_MEMBER_ALIGNMENT(PDMPCIDEV, Int.s.aIORegions, 16);
+
+    /*
+     * Misc alignment checks (keep this somewhat alphabetical).
+     */
+    CHECK_MEMBER_ALIGNMENT(AC97STATE, CritSect, 8);
+
+    CHECK_MEMBER_ALIGNMENT(AHCI, lock, 8);
+    CHECK_MEMBER_ALIGNMENT(AHCI, aPorts[0], 8);
+    CHECK_MEMBER_ALIGNMENT(AHCIR3, aPorts[0], 8);
+
+    CHECK_MEMBER_ALIGNMENT(ATADEVSTATE, cTotalSectors, 8);
+    CHECK_MEMBER_ALIGNMENT(ATADEVSTATE, StatATADMA, 8);
+    CHECK_MEMBER_ALIGNMENT(ATADEVSTATE, StatReads, 8);
+    CHECK_MEMBER_ALIGNMENT(ATACONTROLLER, lock, 8);
+    CHECK_MEMBER_ALIGNMENT(ATACONTROLLER, StatAsyncOps, 8);
+    CHECK_MEMBER_ALIGNMENT(BUSLOGIC, CritSectIntr, 8);
+#ifdef VBOX_WITH_STATISTICS
+    CHECK_MEMBER_ALIGNMENT(DEVPIC, StatSetIrqRZ, 8);
+#endif
+#ifdef VBOX_WITH_E1000
+    CHECK_MEMBER_ALIGNMENT(E1KSTATE, cs, 8);
+    CHECK_MEMBER_ALIGNMENT(E1KSTATE, csRx, 8);
+    CHECK_MEMBER_ALIGNMENT(E1KSTATE, StatReceiveBytes, 8);
+#endif
+    //CHECK_MEMBER_ALIGNMENT(E1KSTATE, csTx, 8);
+#ifdef VBOX_WITH_USB
+# ifdef VBOX_WITH_EHCI_IMPL
+    CHECK_MEMBER_ALIGNMENT(EHCI, RootHub, 8);
+# endif
+# ifdef VBOX_WITH_XHCI_IMPL
+    CHECK_MEMBER_ALIGNMENT(XHCI, aPorts, 8);
+    CHECK_MEMBER_ALIGNMENT(XHCI, aInterrupters, 8);
+    CHECK_MEMBER_ALIGNMENT(XHCI, aInterrupters[0].lock, 8);
+    CHECK_MEMBER_ALIGNMENT(XHCI, aInterrupters[1].lock, 8);
+    CHECK_MEMBER_ALIGNMENT(XHCI, cmdr_dqp, 8);
+    CHECK_MEMBER_ALIGNMENT(XHCI, hMmio, 8);
+#  ifdef VBOX_WITH_STATISTICS
+    CHECK_MEMBER_ALIGNMENT(XHCI, StatErrorIsocUrbs, 8);
+    CHECK_MEMBER_ALIGNMENT(XHCI, StatIntrsCleared, 8);
+#  endif
+# endif
+#endif
+    CHECK_MEMBER_ALIGNMENT(E1KSTATE, StatReceiveBytes, 8);
+    CHECK_MEMBER_ALIGNMENT(IOAPIC, au64RedirTable, 8);
+# ifdef VBOX_WITH_STATISTICS
+    CHECK_MEMBER_ALIGNMENT(IOAPIC, StatMmioReadRZ, 8);
+# endif
+    CHECK_MEMBER_ALIGNMENT(LSILOGICSCSI, aMessage, 8);
+    CHECK_MEMBER_ALIGNMENT(LSILOGICSCSI, ReplyPostQueueCritSect, 8);
+    CHECK_MEMBER_ALIGNMENT(LSILOGICSCSI, ReplyFreeQueueCritSect, 8);
+    CHECK_MEMBER_ALIGNMENT(LSILOGICSCSI, uReplyFreeQueueNextEntryFreeWrite, 8);
+#ifdef VBOX_WITH_USB
+    CHECK_MEMBER_ALIGNMENT(OHCI, RootHub, 8);
+# ifdef VBOX_WITH_STATISTICS
+    CHECK_MEMBER_ALIGNMENT(OHCI, StatCanceledIsocUrbs, 8);
+# endif
+#endif
+    CHECK_MEMBER_ALIGNMENT(DEVPCIBUS, apDevices, 64);
+    CHECK_MEMBER_ALIGNMENT(DEVPCIROOT, auPciApicIrqLevels, 16);
+    CHECK_MEMBER_ALIGNMENT(DEVPCIROOT, Piix3.auPciLegacyIrqLevels, 16);
+    CHECK_MEMBER_ALIGNMENT(PCNETSTATE, u64LastPoll, 8);
+    CHECK_MEMBER_ALIGNMENT(PCNETSTATE, CritSect, 8);
+    CHECK_MEMBER_ALIGNMENT(PCNETSTATE, StatReceiveBytes, 8);
+#ifdef VBOX_WITH_STATISTICS
+    CHECK_MEMBER_ALIGNMENT(PCNETSTATE, StatMMIOReadRZ, 8);
+#endif
+    CHECK_MEMBER_ALIGNMENT(PITSTATE, StatPITIrq, 8);
+    CHECK_MEMBER_ALIGNMENT(DEVSERIAL, UartCore, 8);
+    CHECK_MEMBER_ALIGNMENT(UARTCORE, CritSect, 8);
+#ifdef VBOX_WITH_VMSVGA
+    CHECK_SIZE(VMSVGAState, RT_ALIGN_Z(sizeof(VMSVGAState), 8));
+    CHECK_MEMBER_ALIGNMENT(VGASTATE, svga, 8);
+    CHECK_MEMBER_ALIGNMENT(VGASTATE, svga.au32ScratchRegion, 8);
+    CHECK_MEMBER_ALIGNMENT(VGASTATE, svga.StatRegBitsPerPixelWr, 8);
+#endif
+    CHECK_MEMBER_ALIGNMENT(VGASTATE, cMonitors, 8);
+    CHECK_MEMBER_ALIGNMENT(VGASTATE, GCPhysVRAM, 8);
+    CHECK_MEMBER_ALIGNMENT(VGASTATE, CritSect, 8);
+    CHECK_MEMBER_ALIGNMENT(VGASTATE, StatRZMemoryRead, 8);
+    CHECK_MEMBER_ALIGNMENT(VGASTATE, CritSectIRQ, 8);
+    CHECK_MEMBER_ALIGNMENT(VGASTATE, bmDirtyBitmap, 8);
+    CHECK_MEMBER_ALIGNMENT(VGASTATE, pciRegions, 8);
+    CHECK_MEMBER_ALIGNMENT(VMMDEV, CritSect, 8);
+#ifdef VBOX_WITH_PCI_PASSTHROUGH_IMPL
+    CHECK_MEMBER_ALIGNMENT(PCIRAWSENDREQ, u.aGetRegionInfo.u64RegionSize, 8);
+#endif
+#ifdef VBOX_WITH_IOMMU_AMD
+    CHECK_MEMBER_ALIGNMENT(IOMMU, IommuBar, 8);
+    CHECK_MEMBER_ALIGNMENT(IOMMU, aDevTabBaseAddrs, 8);
+    CHECK_MEMBER_ALIGNMENT(IOMMU, CmdBufHeadPtr, 8);
+    CHECK_MEMBER_ALIGNMENT(IOMMU, Status, 8);
+# ifdef VBOX_WITH_STATISTICS
+    CHECK_MEMBER_ALIGNMENT(IOMMU, StatMmioReadR3, 8);
+# endif
+#endif
+#ifdef VBOX_WITH_IOMMU_INTEL
+    CHECK_MEMBER_ALIGNMENT(DMAR, abRegs0, 8);
+    CHECK_MEMBER_ALIGNMENT(DMAR, abRegs1, 8);
+    CHECK_MEMBER_ALIGNMENT(DMAR, uIrtaReg, 8);
+    CHECK_MEMBER_ALIGNMENT(DMAR, uRtaddrReg, 8);
+    CHECK_MEMBER_ALIGNMENT(DMAR, hEvtInvQueue, 8);
+# ifdef VBOX_WITH_STATISTICS
+    CHECK_MEMBER_ALIGNMENT(DMAR, StatMmioReadR3, 8);
+    CHECK_MEMBER_ALIGNMENT(DMAR, StatPasidDevtlbInvDsc, 8);
+# endif
+#endif
+
+#ifdef VBOX_WITH_RAW_MODE
+    /*
+     * Compare HC and RC.
+     */
+    RTPrintf("tstDeviceStructSize: Comparing HC and RC...\n");
+# include "tstDeviceStructSizeRC.h"
+#endif
+
+    /*
+     * Report result.
+     */
+    if (rc)
+        RTPrintf("tstDeviceStructSize: FAILURE - %d errors\n", rc);
+    else
+        RTPrintf("tstDeviceStructSize: SUCCESS\n");
+    return rc;
+}
diff --git a/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp b/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp
new file mode 100644
index 00000000..70e3d588
--- /dev/null
+++ b/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp
@@ -0,0 +1,2264 @@
+/* $Id: tstDeviceStructSizeRC.cpp $ */
+/** @file
+ * tstDeviceStructSizeGC - Generate structure member and size checks from the RC perspective.
+ *
+ * This is built using the VBoxRc template but linked into a host
+ * ring-3 executable, rather hacky.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*
+ * Sanity checks.
+ */
+#ifndef IN_RC
+# error Incorrect template!
+#endif
+#if defined(IN_RING3) || defined(IN_RING0)
+# error Incorrect template!
+#endif
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define VBOX_DEVICE_STRUCT_TESTCASE
+#define VBOX_WITH_HGCM                  /* grumble */
+
+/* Check that important preprocessor macros does not get redefined: */
+#include <VBox/cdefs.h>
+#include <VBox/log.h>
+#ifdef DEBUG
+# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_DEBUG
+#else
+# undef  VBOX_DEVICE_STRUCT_TESTCASE_CHECK_DEBUG
+#endif
+#ifdef LOG_ENABLED
+# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_LOG_ENABLED
+#else
+# undef  VBOX_DEVICE_STRUCT_TESTCASE_CHECK_LOG_ENABLED
+#endif
+#ifdef VBOX_STRICT
+# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_VBOX_STRICT
+#else
+# undef  VBOX_DEVICE_STRUCT_TESTCASE_CHECK_VBOX_STRICT
+#endif
+#ifdef RT_STRICT
+# define VBOX_DEVICE_STRUCT_TESTCASE_CHECK_RT_STRICT
+#else
+# undef  VBOX_DEVICE_STRUCT_TESTCASE_CHECK_RT_STRICT
+#endif
+
+/* The structures we're checking: */
+#undef LOG_GROUP
+#include "../Bus/DevPciInternal.h"
+#undef LOG_GROUP
+#include "../EFI/DevSmc.cpp"
+#undef LOG_GROUP
+#include "../Graphics/DevVGA.cpp"
+#undef LOG_GROUP
+#include "../Input/DevPS2.cpp"
+#undef LOG_GROUP
+#include "../Input/PS2K.cpp"
+#undef LOG_GROUP
+#include "../Input/PS2M.cpp"
+#undef LOG_GROUP
+#include "../Network/DevPCNet.cpp"
+#undef LOG_GROUP
+#include "../PC/DevACPI.cpp"
+#undef LOG_GROUP
+#include "../PC/DevPIC.cpp"
+#undef LOG_GROUP
+#include "../PC/DevPit-i8254.cpp"
+#undef LOG_GROUP
+#include "../PC/DevRTC.cpp"
+# undef LOG_GROUP
+# include "../../VMM/VMMR3/APIC.cpp"
+#undef LOG_GROUP
+#include "../PC/DevIoApic.cpp"
+#undef LOG_GROUP
+#include "../PC/DevDMA.cpp"
+#undef LOG_GROUP
+#include "../Storage/DevATA.cpp"
+#ifdef VBOX_WITH_USB
+# undef LOG_GROUP
+# include "../USB/DevOHCI.cpp"
+# ifdef VBOX_WITH_EHCI_IMPL
+#  undef LOG_GROUP
+#  include "../USB/DevEHCI.cpp"
+# endif
+# ifdef VBOX_WITH_XHCI_IMPL
+#  undef LOG_GROUP
+#  include "../USB/DevXHCI.cpp"
+# endif
+#endif
+#undef LOG_GROUP
+#include "../VMMDev/VMMDev.cpp"
+#undef LOG_GROUP
+#include "../Parallel/DevParallel.cpp"
+#undef LOG_GROUP
+#include "../Serial/DevSerial.cpp"
+#undef LOG_GROUP
+#include "../Serial/DevOxPcie958.cpp"
+#undef LOG_GROUP
+#include "../Serial/UartCore.h"
+#ifdef VBOX_WITH_AHCI
+# undef LOG_GROUP
+# include "../Storage/DevAHCI.cpp"
+#endif
+#ifdef VBOX_WITH_E1000
+# undef LOG_GROUP
+# include "../Network/DevE1000.cpp"
+#endif
+#ifdef VBOX_WITH_BUSLOGIC
+# undef LOG_GROUP
+# include "../Storage/DevBusLogic.cpp"
+#endif
+#ifdef VBOX_WITH_LSILOGIC
+# undef LOG_GROUP
+# include "../Storage/DevLsiLogicSCSI.cpp"
+#endif
+#undef LOG_GROUP
+#include "../PC/DevHPET.cpp"
+#undef LOG_GROUP
+#include "../Audio/DevIchAc97.cpp"
+#undef LOG_GROUP
+#include "../Audio/DevHDA.cpp"
+#ifdef VBOX_WITH_NVME_IMPL
+# undef LOG_GROUP
+# include "../Storage/DevNVMe.cpp"
+#endif
+#ifdef VBOX_WITH_IOMMU_AMD
+# undef LOG_GROUP
+# include "../Bus/DevIommuAmd.cpp"
+#endif
+#ifdef VBOX_WITH_IOMMU_INTEL
+# undef LOG_GROUP
+# include "../Bus/DevIommuIntel.cpp"
+#endif
+
+/* Check that important preprocessor macros didn't get redefined: */
+#if defined(DEBUG)       != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_DEBUG)
+# error "DEBUG was modified!  This may throw off structure tests."
+#endif
+#if defined(LOG_ENABLED) != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_LOG_ENABLED)
+# error "LOG_ENABLED was modified!  This may throw off structure tests."
+#endif
+#if defined(RT_STRICT)   != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_RT_STRICT)
+# error "RT_STRICT was modified!  This may throw off structure tests."
+#endif
+#if defined(VBOX_STRICT) != defined(VBOX_DEVICE_STRUCT_TESTCASE_CHECK_VBOX_STRICT)
+# error "VBOX_STRICT was modified!  This may throw off structure tests."
+#endif
+
+
+/* we don't use iprt here because we're pretending to be in GC! */
+#include <stdio.h>
+
+#define GEN_CHECK_SIZE(s)           printf("    CHECK_SIZE(%s, %d);\n", #s, (int)sizeof(s))
+#define GEN_CHECK_OFF(s, m)         printf("    CHECK_OFF(%s, %d, %s);\n", #s, (int)RT_OFFSETOF(s, m), #m)
+#define GEN_CHECK_PADDING(s, m, a)  printf("    CHECK_PADDING(%s, %s, %u);\n", #s, #m, (a))
+
+int main()
+{
+    /* misc */
+    GEN_CHECK_SIZE(PDMDEVINS);
+    GEN_CHECK_OFF(PDMDEVINS, Internal);
+    GEN_CHECK_OFF(PDMDEVINS, pReg);
+    GEN_CHECK_OFF(PDMDEVINS, pCfg);
+    GEN_CHECK_OFF(PDMDEVINS, iInstance);
+    GEN_CHECK_OFF(PDMDEVINS, IBase);
+    GEN_CHECK_OFF(PDMDEVINS, pHlpR3);
+    GEN_CHECK_OFF(PDMDEVINS, pHlpR0);
+    GEN_CHECK_OFF(PDMDEVINS, pHlpRC);
+    GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataR3);
+    GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataR0);
+    GEN_CHECK_OFF(PDMDEVINS, pvInstanceDataRC);
+    GEN_CHECK_OFF(PDMDEVINS, achInstanceData);
+
+    /* PDMPCIDEV */
+    GEN_CHECK_SIZE(PDMPCIDEV);
+    GEN_CHECK_SIZE(PDMPCIDEVINT);
+    GEN_CHECK_SIZE(PCIIOREGION); /** @todo fix name of PCIIOREGION */
+    GEN_CHECK_OFF(PDMPCIDEV, abConfig);
+    GEN_CHECK_OFF(PDMPCIDEV, uDevFn);
+    GEN_CHECK_OFF(PDMPCIDEV, pszNameR3);
+    GEN_CHECK_OFF(PDMPCIDEV, pfnRegionLoadChangeHookR3);
+    GEN_CHECK_OFF(PDMPCIDEV, Int);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[1]);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[VBOX_PCI_NUM_REGIONS - 1]);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[0].addr);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[0].size);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[0].type);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.aIORegions[0].padding);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.pBusR3);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.pBusR0);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.pBusRC);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.pfnConfigRead);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.pfnConfigWrite);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.fFlags);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.uIrqPinState);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.pfnBridgeConfigRead);
+    GEN_CHECK_OFF(PDMPCIDEV, Int.s.pfnBridgeConfigWrite);
+    GEN_CHECK_PADDING(PDMPCIDEV, Int, 8);
+
+    /* DevPciInternal.h */
+    GEN_CHECK_SIZE(DEVPCIBUS);
+    GEN_CHECK_OFF(DEVPCIBUS, iBus);
+    GEN_CHECK_OFF(DEVPCIBUS, iDevSearch);
+    GEN_CHECK_OFF(DEVPCIBUS, cBridges);
+    GEN_CHECK_OFF(DEVPCIBUS, apDevices);
+    GEN_CHECK_OFF(DEVPCIBUS, apDevices[1]);
+    GEN_CHECK_OFF(DEVPCIBUS, papBridgesR3);
+    GEN_CHECK_OFF(DEVPCIBUS, PciDev);
+    GEN_CHECK_SIZE(PIIX3ISABRIDGE);
+    GEN_CHECK_SIZE(DEVPCIROOT);
+    GEN_CHECK_OFF(DEVPCIROOT, PciBus);
+    GEN_CHECK_OFF(DEVPCIROOT, fUseIoApic);
+    GEN_CHECK_OFF(DEVPCIROOT, u64PciConfigMMioAddress);
+    GEN_CHECK_OFF(DEVPCIROOT, u64PciConfigMMioLength);
+    GEN_CHECK_OFF(DEVPCIROOT, auPciApicIrqLevels);
+    GEN_CHECK_OFF(DEVPCIROOT, auPciApicIrqLevels[1]);
+    GEN_CHECK_OFF(DEVPCIROOT, uConfigReg);
+    GEN_CHECK_OFF(DEVPCIROOT, Piix3.iAcpiIrqLevel);
+    GEN_CHECK_OFF(DEVPCIROOT, Piix3.iAcpiIrq);
+    GEN_CHECK_OFF(DEVPCIROOT, Piix3.auPciLegacyIrqLevels);
+    GEN_CHECK_OFF(DEVPCIROOT, Piix3.auPciLegacyIrqLevels[1]);
+    GEN_CHECK_OFF(DEVPCIROOT, Piix3.PIIX3State);
+    GEN_CHECK_OFF(DEVPCIROOT, uPciBiosBus);
+    GEN_CHECK_OFF(DEVPCIROOT, uPciBiosIo);
+    GEN_CHECK_OFF(DEVPCIROOT, uPciBiosMmio);
+    GEN_CHECK_OFF(DEVPCIROOT, uPciBiosMmio64);
+
+    /* EFI/DevSMC.cpp */
+    GEN_CHECK_SIZE(DEVSMC);
+    GEN_CHECK_OFF(DEVSMC, bCmd);
+    GEN_CHECK_OFF(DEVSMC, offKey);
+    GEN_CHECK_OFF(DEVSMC, offValue);
+    GEN_CHECK_OFF(DEVSMC, cKeys);
+    GEN_CHECK_OFF(DEVSMC, CurKey);
+    GEN_CHECK_OFF(DEVSMC, u);
+    GEN_CHECK_OFF(DEVSMC, u.s);
+    GEN_CHECK_OFF(DEVSMC, u.s.bState);
+    GEN_CHECK_OFF(DEVSMC, u.s.bStatusCode);
+    GEN_CHECK_OFF(DEVSMC, u.s.bStatusCode);
+    GEN_CHECK_OFF(DEVSMC, szOsk0And1);
+    GEN_CHECK_OFF(DEVSMC, bDollaryNumber);
+    GEN_CHECK_OFF(DEVSMC, bShutdownReason);
+    GEN_CHECK_OFF(DEVSMC, bNinjaActionTimerJob);
+
+    /* DevVGA.cpp */
+    GEN_CHECK_SIZE(VGASTATE);
+    GEN_CHECK_OFF(VGASTATE, vram_ptrR3);
+    GEN_CHECK_OFF(VGASTATE, get_bpp);
+    GEN_CHECK_OFF(VGASTATE, get_offsets);
+    GEN_CHECK_OFF(VGASTATE, get_resolution);
+    GEN_CHECK_OFF(VGASTATE, rgb_to_pixel);
+    GEN_CHECK_OFF(VGASTATE, cursor_invalidate);
+    GEN_CHECK_OFF(VGASTATE, cursor_draw_line);
+    GEN_CHECK_OFF(VGASTATE, vram_size);
+    GEN_CHECK_OFF(VGASTATE, latch);
+    GEN_CHECK_OFF(VGASTATE, sr_index);
+    GEN_CHECK_OFF(VGASTATE, sr);
+    GEN_CHECK_OFF(VGASTATE, sr[1]);
+    GEN_CHECK_OFF(VGASTATE, gr_index);
+    GEN_CHECK_OFF(VGASTATE, gr);
+    GEN_CHECK_OFF(VGASTATE, gr[1]);
+    GEN_CHECK_OFF(VGASTATE, ar_index);
+    GEN_CHECK_OFF(VGASTATE, ar);
+    GEN_CHECK_OFF(VGASTATE, ar[1]);
+    GEN_CHECK_OFF(VGASTATE, ar_flip_flop);
+    GEN_CHECK_OFF(VGASTATE, cr_index);
+    GEN_CHECK_OFF(VGASTATE, cr);
+    GEN_CHECK_OFF(VGASTATE, cr[1]);
+    GEN_CHECK_OFF(VGASTATE, msr);
+    GEN_CHECK_OFF(VGASTATE, msr);
+    GEN_CHECK_OFF(VGASTATE, fcr);
+    GEN_CHECK_OFF(VGASTATE, st00);
+    GEN_CHECK_OFF(VGASTATE, st01);
+    GEN_CHECK_OFF(VGASTATE, dac_state);
+    GEN_CHECK_OFF(VGASTATE, dac_sub_index);
+    GEN_CHECK_OFF(VGASTATE, dac_read_index);
+    GEN_CHECK_OFF(VGASTATE, dac_write_index);
+    GEN_CHECK_OFF(VGASTATE, dac_cache);
+    GEN_CHECK_OFF(VGASTATE, dac_cache[1]);
+    GEN_CHECK_OFF(VGASTATE, palette);
+    GEN_CHECK_OFF(VGASTATE, palette[1]);
+    GEN_CHECK_OFF(VGASTATE, bank_offset);
+#ifdef CONFIG_BOCHS_VBE
+    GEN_CHECK_OFF(VGASTATE, vbe_index);
+    GEN_CHECK_OFF(VGASTATE, vbe_regs);
+    GEN_CHECK_OFF(VGASTATE, vbe_regs[1]);
+    GEN_CHECK_OFF(VGASTATE, vbe_regs[VBE_DISPI_INDEX_NB - 1]);
+    GEN_CHECK_OFF(VGASTATE, vbe_start_addr);
+    GEN_CHECK_OFF(VGASTATE, vbe_line_offset);
+    GEN_CHECK_OFF(VGASTATE, vbe_bank_max);
+#endif
+    GEN_CHECK_OFF(VGASTATE, font_offsets);
+    GEN_CHECK_OFF(VGASTATE, font_offsets[1]);
+    GEN_CHECK_OFF(VGASTATE, graphic_mode);
+    GEN_CHECK_OFF(VGASTATE, shift_control);
+    GEN_CHECK_OFF(VGASTATE, double_scan);
+    GEN_CHECK_OFF(VGASTATE, line_offset);
+    GEN_CHECK_OFF(VGASTATE, line_compare);
+    GEN_CHECK_OFF(VGASTATE, start_addr);
+    GEN_CHECK_OFF(VGASTATE, plane_updated);
+    GEN_CHECK_OFF(VGASTATE, last_cw);
+    GEN_CHECK_OFF(VGASTATE, last_ch);
+    GEN_CHECK_OFF(VGASTATE, last_width);
+    GEN_CHECK_OFF(VGASTATE, last_height);
+    GEN_CHECK_OFF(VGASTATE, last_scr_width);
+    GEN_CHECK_OFF(VGASTATE, last_scr_height);
+    GEN_CHECK_OFF(VGASTATE, last_bpp);
+    GEN_CHECK_OFF(VGASTATE, cursor_start);
+    GEN_CHECK_OFF(VGASTATE, cursor_end);
+    GEN_CHECK_OFF(VGASTATE, cursor_offset);
+    GEN_CHECK_OFF(VGASTATE, invalidated_y_table);
+    GEN_CHECK_OFF(VGASTATE, invalidated_y_table[1]);
+    GEN_CHECK_OFF(VGASTATE, invalidated_y_table[(VGA_MAX_HEIGHT / 32) - 1]);
+    GEN_CHECK_OFF(VGASTATE, last_palette);
+    GEN_CHECK_OFF(VGASTATE, last_palette[1]);
+    GEN_CHECK_OFF(VGASTATE, last_ch_attr);
+    GEN_CHECK_OFF(VGASTATE, last_ch_attr[CH_ATTR_SIZE - 1]);
+    GEN_CHECK_OFF(VGASTATE, u32Marker);
+    GEN_CHECK_OFF(VGASTATE, pDevInsRC);
+    GEN_CHECK_OFF(VGASTATE, vram_ptrRC);
+    GEN_CHECK_OFF(VGASTATE, pDevInsR3);
+#ifdef VBOX_WITH_HGSMI
+    GEN_CHECK_OFF(VGASTATE, pHGSMI);
+#endif
+#ifdef VBOX_WITH_VDMA
+    GEN_CHECK_OFF(VGASTATE, pVdma);
+#endif
+    GEN_CHECK_OFF(VGASTATE, IBase);
+    GEN_CHECK_OFF(VGASTATE, IPort);
+#if defined(VBOX_WITH_HGSMI) && defined(VBOX_WITH_VIDEOHWACCEL)
+    GEN_CHECK_OFF(VGASTATE, IVBVACallbacks);
+#endif
+    GEN_CHECK_OFF(VGASTATE, pDrvBase);
+    GEN_CHECK_OFF(VGASTATE, pDrv);
+    GEN_CHECK_OFF(VGASTATE, RefreshTimer);
+    GEN_CHECK_OFF(VGASTATE, pDevInsR0);
+#ifdef VBOX_WITH_VMSVGA
+    GEN_CHECK_OFF(VGASTATE, svga.pFIFOR3);
+    GEN_CHECK_OFF(VGASTATE, svga.pFIFOR0);
+    GEN_CHECK_OFF(VGASTATE, svga.pSvgaR3State);
+    GEN_CHECK_OFF(VGASTATE, svga.p3dState);
+    GEN_CHECK_OFF(VGASTATE, svga.pbVgaFrameBufferR3);
+    GEN_CHECK_OFF(VGASTATE, svga.GCPhysFIFO);
+    GEN_CHECK_OFF(VGASTATE, svga.cbFIFO);
+    GEN_CHECK_OFF(VGASTATE, svga.cbFIFOConfig);
+    GEN_CHECK_OFF(VGASTATE, svga.u32SVGAId);
+    GEN_CHECK_OFF(VGASTATE, svga.fConfigured);
+    GEN_CHECK_OFF(VGASTATE, svga.fBusy);
+    GEN_CHECK_OFF(VGASTATE, svga.fTraces);
+    GEN_CHECK_OFF(VGASTATE, svga.u32GuestId);
+    GEN_CHECK_OFF(VGASTATE, svga.cScratchRegion);
+    GEN_CHECK_OFF(VGASTATE, svga.u32IrqStatus);
+    GEN_CHECK_OFF(VGASTATE, svga.u32IrqMask);
+    GEN_CHECK_OFF(VGASTATE, svga.u32PitchLock);
+    GEN_CHECK_OFF(VGASTATE, svga.u32CurrentGMRId);
+    GEN_CHECK_OFF(VGASTATE, svga.u32RegCaps);
+    GEN_CHECK_OFF(VGASTATE, svga.u32IndexReg);
+    GEN_CHECK_OFF(VGASTATE, svga.hFIFORequestSem);
+    GEN_CHECK_OFF(VGASTATE, svga.hFIFOExtCmdSem);
+    GEN_CHECK_OFF(VGASTATE, svga.pFIFOIOThread);
+    GEN_CHECK_OFF(VGASTATE, svga.uWidth);
+    GEN_CHECK_OFF(VGASTATE, svga.uHeight);
+    GEN_CHECK_OFF(VGASTATE, svga.uBpp);
+    GEN_CHECK_OFF(VGASTATE, svga.cbScanline);
+    GEN_CHECK_OFF(VGASTATE, svga.u32MaxWidth);
+    GEN_CHECK_OFF(VGASTATE, svga.u32MaxHeight);
+    GEN_CHECK_OFF(VGASTATE, svga.viewport);
+    GEN_CHECK_OFF(VGASTATE, svga.u32ActionFlags);
+    GEN_CHECK_OFF(VGASTATE, svga.f3DEnabled);
+    GEN_CHECK_OFF(VGASTATE, svga.fVRAMTracking);
+    GEN_CHECK_OFF(VGASTATE, svga.u8FIFOExtCommand);
+    GEN_CHECK_OFF(VGASTATE, svga.fFifoExtCommandWakeup);
+    GEN_CHECK_OFF(VGASTATE, svga.au32ScratchRegion);
+    GEN_CHECK_OFF(VGASTATE, svga.StatRegBitsPerPixelWr);
+    GEN_CHECK_OFF(VGASTATE, svga.StatRegWriteOnlyRd);
+#endif
+    GEN_CHECK_OFF(VGASTATE, cMonitors);
+    GEN_CHECK_OFF(VGASTATE, cMilliesRefreshInterval);
+    GEN_CHECK_OFF(VGASTATE, au32DirtyBitmap);
+    GEN_CHECK_OFF(VGASTATE, au32DirtyBitmap[1]);
+    GEN_CHECK_OFF(VGASTATE, au32DirtyBitmap[(VGA_VRAM_MAX / GUEST_PAGE_SIZE / 32) - 1]);
+    GEN_CHECK_OFF(VGASTATE, fHasDirtyBits);
+    GEN_CHECK_OFF(VGASTATE, fLFBUpdated);
+    GEN_CHECK_OFF(VGASTATE, fGCEnabled);
+    GEN_CHECK_OFF(VGASTATE, fR0Enabled);
+    GEN_CHECK_OFF(VGASTATE, fRemappedVGA);
+    GEN_CHECK_OFF(VGASTATE, fRenderVRAM);
+    GEN_CHECK_OFF(VGASTATE, GCPhysVRAM);
+    GEN_CHECK_OFF(VGASTATE, CritSect);
+    GEN_CHECK_OFF(VGASTATE, Dev);
+    GEN_CHECK_OFF(VGASTATE, StatRZMemoryRead);
+    GEN_CHECK_OFF(VGASTATE, StatR3MemoryRead);
+    GEN_CHECK_OFF(VGASTATE, StatRZMemoryWrite);
+    GEN_CHECK_OFF(VGASTATE, StatR3MemoryWrite);
+#ifdef VBE_BYTEWISE_IO
+    GEN_CHECK_OFF(VGASTATE, fReadVBEData);
+    GEN_CHECK_OFF(VGASTATE, fWriteVBEData);
+    GEN_CHECK_OFF(VGASTATE, fReadVBEIndex);
+    GEN_CHECK_OFF(VGASTATE, fWriteVBEIndex);
+    GEN_CHECK_OFF(VGASTATE, cbWriteVBEData);
+    GEN_CHECK_OFF(VGASTATE, cbWriteVBEIndex);
+# ifdef VBE_NEW_DYN_LIST
+    GEN_CHECK_OFF(VGASTATE, cbWriteVBEExtraAddress);
+# endif
+#endif
+#ifdef VBE_NEW_DYN_LIST
+    GEN_CHECK_OFF(VGASTATE, pbVBEExtraData);
+    GEN_CHECK_OFF(VGASTATE, cbVBEExtraData);
+    GEN_CHECK_OFF(VGASTATE, u16VBEExtraAddress);
+#endif
+    GEN_CHECK_OFF(VGASTATE, pbLogo);
+    GEN_CHECK_OFF(VGASTATE, pszLogoFile);
+    GEN_CHECK_OFF(VGASTATE, pbLogoBitmap);
+    GEN_CHECK_OFF(VGASTATE, offLogoData);
+    GEN_CHECK_OFF(VGASTATE, cbLogo);
+    GEN_CHECK_OFF(VGASTATE, LogoCommand);
+    GEN_CHECK_OFF(VGASTATE, cxLogo);
+    GEN_CHECK_OFF(VGASTATE, cyLogo);
+    GEN_CHECK_OFF(VGASTATE, cLogoPlanes);
+    GEN_CHECK_OFF(VGASTATE, cLogoBits);
+    GEN_CHECK_OFF(VGASTATE, LogoCompression);
+    GEN_CHECK_OFF(VGASTATE, cLogoUsedColors);
+    GEN_CHECK_OFF(VGASTATE, cLogoPalEntries);
+    GEN_CHECK_OFF(VGASTATE, fLogoClearScreen);
+    GEN_CHECK_OFF(VGASTATE, au32LogoPalette);
+    GEN_CHECK_OFF(VGASTATE, pbVgaBios);
+    GEN_CHECK_OFF(VGASTATE, cbVgaBios);
+    GEN_CHECK_OFF(VGASTATE, pszVgaBiosFile);
+#ifdef VBOX_WITH_HGSMI
+    GEN_CHECK_OFF(VGASTATE, IOPortBase);
+#endif
+#ifdef VBOX_WITH_WDDM
+    GEN_CHECK_OFF(VGASTATE, fGuestCaps);
+#endif
+
+    /* Input/pckbd.c */
+    GEN_CHECK_SIZE(KBDSTATE);
+    GEN_CHECK_OFF(KBDSTATE, write_cmd);
+    GEN_CHECK_OFF(KBDSTATE, status);
+    GEN_CHECK_OFF(KBDSTATE, mode);
+    GEN_CHECK_OFF(KBDSTATE, pDevInsR3);
+    GEN_CHECK_OFF(KBDSTATE, pDevInsR0);
+    GEN_CHECK_OFF(KBDSTATE, pDevInsRC);
+    GEN_CHECK_SIZE(KbdKeyQ);
+    GEN_CHECK_OFF(KbdCmdQ, rpos);
+    GEN_CHECK_OFF(KbdCmdQ, wpos);
+    GEN_CHECK_OFF(KbdCmdQ, cUsed);
+    GEN_CHECK_OFF(KbdCmdQ, cSize);
+    GEN_CHECK_OFF(KbdCmdQ, abQueue);
+    GEN_CHECK_SIZE(KbdCmdQ);
+    /* Input/PS2K.c */
+    GEN_CHECK_SIZE(PS2K);
+    GEN_CHECK_OFF(PS2K, fScanning);
+    GEN_CHECK_OFF(PS2K, fNumLockOn);
+    GEN_CHECK_OFF(PS2K, u8ScanSet);
+    GEN_CHECK_OFF(PS2K, u8TypematicCfg);
+    GEN_CHECK_OFF(PS2K, enmTypematicState);
+    GEN_CHECK_OFF(PS2K, keyQ);
+    GEN_CHECK_OFF(PS2K, cmdQ);
+    GEN_CHECK_OFF(PS2K, uTypematicDelay);
+    GEN_CHECK_OFF(PS2K, fThrottleActive);
+    GEN_CHECK_OFF(PS2K, pKbdDelayTimerRC);
+    GEN_CHECK_OFF(PS2K, pKbdDelayTimerR3);
+    GEN_CHECK_OFF(PS2K, pKbdDelayTimerR0);
+    GEN_CHECK_OFF(PS2K, pKbdTypematicTimerRC);
+    GEN_CHECK_OFF(PS2K, pKbdTypematicTimerR3);
+    GEN_CHECK_OFF(PS2K, pKbdTypematicTimerR0);
+    GEN_CHECK_OFF(PS2K, pThrottleTimerRC);
+    GEN_CHECK_OFF(PS2K, pThrottleTimerR3);
+    GEN_CHECK_OFF(PS2K, pThrottleTimerR0);
+    GEN_CHECK_OFF(PS2K, pCritSectR3);
+    GEN_CHECK_OFF(PS2K, Keyboard.IBase);
+    GEN_CHECK_OFF(PS2K, Keyboard.IPort);
+    GEN_CHECK_OFF(PS2K, Keyboard.pDrvBase);
+    GEN_CHECK_OFF(PS2K, Keyboard.pDrv);
+    /* Input/PS2M.c */
+    GEN_CHECK_SIZE(PS2M);
+    GEN_CHECK_OFF(PS2M, u8State);
+    GEN_CHECK_OFF(PS2M, u8SampleRate);
+    GEN_CHECK_OFF(PS2M, u8Resolution);
+    GEN_CHECK_OFF(PS2M, u8CurrCmd);
+    GEN_CHECK_OFF(PS2M, fThrottleActive);
+    GEN_CHECK_OFF(PS2M, fDelayReset);
+    GEN_CHECK_OFF(PS2M, enmMode);
+    GEN_CHECK_OFF(PS2M, enmProtocol);
+    GEN_CHECK_OFF(PS2M, enmKnockState);
+    GEN_CHECK_OFF(PS2M, evtQ);
+    GEN_CHECK_OFF(PS2M, cmdQ);
+    GEN_CHECK_OFF(PS2M, iAccumX);
+    GEN_CHECK_OFF(PS2M, fAccumB);
+    GEN_CHECK_OFF(PS2M, fCurrB);
+    GEN_CHECK_OFF(PS2M, uThrottleDelay);
+    GEN_CHECK_OFF(PS2M, pCritSectR3);
+    GEN_CHECK_OFF(PS2M, pDelayTimerR3);
+    GEN_CHECK_OFF(PS2M, pThrottleTimerR3);
+    GEN_CHECK_OFF(PS2M, pDelayTimerRC);
+    GEN_CHECK_OFF(PS2M, pThrottleTimerRC);
+    GEN_CHECK_OFF(PS2M, pDelayTimerR0);
+    GEN_CHECK_OFF(PS2M, pThrottleTimerR0);
+    GEN_CHECK_OFF(PS2M, Mouse.IBase);
+    GEN_CHECK_OFF(PS2M, Mouse.IPort);
+    GEN_CHECK_OFF(PS2M, Mouse.pDrvBase);
+    GEN_CHECK_OFF(PS2M, Mouse.pDrv);
+
+    /* Network/DevPCNet.cpp */
+    GEN_CHECK_SIZE(PCNETSTATE);
+    GEN_CHECK_OFF(PCNETSTATE, PciDev);
+#ifndef PCNET_NO_POLLING
+    GEN_CHECK_OFF(PCNETSTATE, pTimerPollR3);
+    GEN_CHECK_OFF(PCNETSTATE, pTimerPollR0);
+    GEN_CHECK_OFF(PCNETSTATE, pTimerPollRC);
+#endif
+    GEN_CHECK_OFF(PCNETSTATE, pTimerSoftIntR3);
+    GEN_CHECK_OFF(PCNETSTATE, pTimerSoftIntR0);
+    GEN_CHECK_OFF(PCNETSTATE, pTimerSoftIntRC);
+    GEN_CHECK_OFF(PCNETSTATE, u32RAP);
+    GEN_CHECK_OFF(PCNETSTATE, iISR);
+    GEN_CHECK_OFF(PCNETSTATE, u32Lnkst);
+    GEN_CHECK_OFF(PCNETSTATE, GCRDRA);
+    GEN_CHECK_OFF(PCNETSTATE, GCTDRA);
+    GEN_CHECK_OFF(PCNETSTATE, aPROM);
+    GEN_CHECK_OFF(PCNETSTATE, aPROM[1]);
+    GEN_CHECK_OFF(PCNETSTATE, aCSR);
+    GEN_CHECK_OFF(PCNETSTATE, aCSR[1]);
+    GEN_CHECK_OFF(PCNETSTATE, aCSR[CSR_MAX_REG - 1]);
+    GEN_CHECK_OFF(PCNETSTATE, aBCR);
+    GEN_CHECK_OFF(PCNETSTATE, aBCR[1]);
+    GEN_CHECK_OFF(PCNETSTATE, aBCR[BCR_MAX_RAP - 1]);
+    GEN_CHECK_OFF(PCNETSTATE, aMII);
+    GEN_CHECK_OFF(PCNETSTATE, aMII[1]);
+    GEN_CHECK_OFF(PCNETSTATE, aMII[MII_MAX_REG - 1]);
+    GEN_CHECK_OFF(PCNETSTATE, u16CSR0LastSeenByGuest);
+    GEN_CHECK_OFF(PCNETSTATE, u64LastPoll);
+    GEN_CHECK_OFF(PCNETSTATE, abLoopBuf);
+    GEN_CHECK_OFF(PCNETSTATE, abRecvBuf);
+    GEN_CHECK_OFF(PCNETSTATE, iLog2DescSize);
+    GEN_CHECK_OFF(PCNETSTATE, GCUpperPhys);
+    GEN_CHECK_OFF(PCNETSTATE, pXmitQueueR3);
+    GEN_CHECK_OFF(PCNETSTATE, pXmitQueueR0);
+    GEN_CHECK_OFF(PCNETSTATE, pXmitQueueRC);
+    GEN_CHECK_OFF(PCNETSTATE, pCanRxQueueR3);
+    GEN_CHECK_OFF(PCNETSTATE, pCanRxQueueR0);
+    GEN_CHECK_OFF(PCNETSTATE, pCanRxQueueRC);
+    GEN_CHECK_OFF(PCNETSTATE, pTimerRestore);
+    GEN_CHECK_OFF(PCNETSTATE, pDevInsR3);
+    GEN_CHECK_OFF(PCNETSTATE, pDevInsR0);
+    GEN_CHECK_OFF(PCNETSTATE, pDevInsRC);
+    GEN_CHECK_OFF(PCNETSTATE, pDrvR3);
+    GEN_CHECK_OFF(PCNETSTATE, pDrvBase);
+    GEN_CHECK_OFF(PCNETSTATE, IBase);
+    GEN_CHECK_OFF(PCNETSTATE, INetworkDown);
+    GEN_CHECK_OFF(PCNETSTATE, INetworkConfig);
+    GEN_CHECK_OFF(PCNETSTATE, MMIOBase);
+    GEN_CHECK_OFF(PCNETSTATE, IOPortBase);
+    GEN_CHECK_OFF(PCNETSTATE, fLinkUp);
+    GEN_CHECK_OFF(PCNETSTATE, fLinkTempDown);
+    GEN_CHECK_OFF(PCNETSTATE, cLinkDownReported);
+    GEN_CHECK_OFF(PCNETSTATE, MacConfigured);
+    GEN_CHECK_OFF(PCNETSTATE, Led);
+    GEN_CHECK_OFF(PCNETSTATE, ILeds);
+    GEN_CHECK_OFF(PCNETSTATE, pLedsConnector);
+    GEN_CHECK_OFF(PCNETSTATE, CritSect);
+#ifdef PCNET_NO_POLLING
+    GEN_CHECK_OFF(PCNETSTATE, TDRAPhysOld);
+    GEN_CHECK_OFF(PCNETSTATE, cbTDRAOld);
+    GEN_CHECK_OFF(PCNETSTATE, RDRAPhysOld);
+    GEN_CHECK_OFF(PCNETSTATE, cbRDRAOld);
+    GEN_CHECK_OFF(PCNETSTATE, pfnEMInterpretInstructionGC
+    GEN_CHECK_OFF(PCNETSTATE, pfnEMInterpretInstructionR0
+#endif
+    GEN_CHECK_OFF(PCNETSTATE, fGCEnabled);
+    GEN_CHECK_OFF(PCNETSTATE, fR0Enabled);
+    GEN_CHECK_OFF(PCNETSTATE, uDevType);
+    GEN_CHECK_OFF(PCNETSTATE, StatReceiveBytes);
+    GEN_CHECK_OFF(PCNETSTATE, StatTransmitBytes);
+#ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(PCNETSTATE, StatMMIOReadR3);
+    GEN_CHECK_OFF(PCNETSTATE, StatMMIOReadRZ);
+    GEN_CHECK_OFF(PCNETSTATE, StatMIIReads);
+# ifdef PCNET_NO_POLLING
+    GEN_CHECK_OFF(PCNETSTATE, StatRCVRingWrite);
+    GEN_CHECK_OFF(PCNETSTATE, StatRingWriteOutsideRangeR3);
+# endif
+#endif
+
+    /* PC/DevACPI.cpp */
+    GEN_CHECK_SIZE(ACPIState);
+    GEN_CHECK_OFF(ACPIState, dev);
+    GEN_CHECK_OFF(ACPIState, pm1a_en);
+    GEN_CHECK_OFF(ACPIState, pm1a_sts);
+    GEN_CHECK_OFF(ACPIState, pm1a_ctl);
+    GEN_CHECK_OFF(ACPIState, u64PmTimerInitial);
+    GEN_CHECK_OFF(ACPIState, pPmTimerR3);
+    GEN_CHECK_OFF(ACPIState, pPmTimerR0);
+    GEN_CHECK_OFF(ACPIState, pPmTimerRC);
+    GEN_CHECK_OFF(ACPIState, uPmTimerVal);
+    GEN_CHECK_OFF(ACPIState, gpe0_en);
+    GEN_CHECK_OFF(ACPIState, gpe0_sts);
+    GEN_CHECK_OFF(ACPIState, uBatteryIndex);
+    GEN_CHECK_OFF(ACPIState, au8BatteryInfo);
+    GEN_CHECK_OFF(ACPIState, uSystemInfoIndex);
+    GEN_CHECK_OFF(ACPIState, u64RamSize);
+    GEN_CHECK_OFF(ACPIState, uSleepState);
+    GEN_CHECK_OFF(ACPIState, au8RSDPPage);
+    GEN_CHECK_OFF(ACPIState, u8IndexShift);
+    GEN_CHECK_OFF(ACPIState, u8UseIOApic);
+    GEN_CHECK_OFF(ACPIState, fUseFdc);
+    GEN_CHECK_OFF(ACPIState, fUseHpet);
+    GEN_CHECK_OFF(ACPIState, fUseSmc);
+    GEN_CHECK_OFF(ACPIState, CpuSetAttached);
+    GEN_CHECK_OFF(ACPIState, idCpuLockCheck);
+    GEN_CHECK_OFF(ACPIState, CpuSetLocked);
+    GEN_CHECK_OFF(ACPIState, u32CpuEventType);
+    GEN_CHECK_OFF(ACPIState, u32CpuEvent);
+    GEN_CHECK_OFF(ACPIState, fCpuHotPlug);
+    GEN_CHECK_OFF(ACPIState, u32NicPciAddress);
+    GEN_CHECK_OFF(ACPIState, u32HbcPciAddress);
+    GEN_CHECK_OFF(ACPIState, u32IommuPciAddress);
+    GEN_CHECK_OFF(ACPIState, u32SbIoApicPciAddress);
+    GEN_CHECK_OFF(ACPIState, u64PciConfigMMioAddress);
+    GEN_CHECK_OFF(ACPIState, IBase);
+    GEN_CHECK_OFF(ACPIState, IACPIPort);
+    GEN_CHECK_OFF(ACPIState, pDevInsR3);
+    GEN_CHECK_OFF(ACPIState, pDevInsR0);
+    GEN_CHECK_OFF(ACPIState, pDrvBase);
+    GEN_CHECK_OFF(ACPIState, pDrv);
+    GEN_CHECK_OFF(ACPIState, u16SMBusSlvDat);
+
+    /* PC/DevPIC.cpp */
+    GEN_CHECK_SIZE(PICSTATE);
+    GEN_CHECK_OFF(PICSTATE, last_irr);
+    GEN_CHECK_OFF(PICSTATE, irr);
+    GEN_CHECK_OFF(PICSTATE, imr);
+    GEN_CHECK_OFF(PICSTATE, isr);
+    GEN_CHECK_OFF(PICSTATE, priority_add);
+    GEN_CHECK_OFF(PICSTATE, irq_base);
+    GEN_CHECK_OFF(PICSTATE, read_reg_select);
+    GEN_CHECK_OFF(PICSTATE, poll);
+    GEN_CHECK_OFF(PICSTATE, special_mask);
+    GEN_CHECK_OFF(PICSTATE, init_state);
+    GEN_CHECK_OFF(PICSTATE, auto_eoi);
+    GEN_CHECK_OFF(PICSTATE, rotate_on_auto_eoi);
+    GEN_CHECK_OFF(PICSTATE, special_fully_nested_mode);
+    GEN_CHECK_OFF(PICSTATE, init4);
+    GEN_CHECK_OFF(PICSTATE, elcr);
+    GEN_CHECK_OFF(PICSTATE, elcr_mask);
+    GEN_CHECK_OFF(PICSTATE, pDevInsR3);
+    GEN_CHECK_OFF(PICSTATE, pDevInsR0);
+    GEN_CHECK_OFF(PICSTATE, pDevInsRC);
+    GEN_CHECK_OFF(PICSTATE, idxPic);
+    GEN_CHECK_OFF(PICSTATE, auTags);
+
+    GEN_CHECK_SIZE(DEVPIC);
+    GEN_CHECK_OFF(DEVPIC, aPics);
+    GEN_CHECK_OFF(DEVPIC, aPics[1]);
+    GEN_CHECK_OFF(DEVPIC, pDevInsR3);
+    GEN_CHECK_OFF(DEVPIC, pDevInsR0);
+    GEN_CHECK_OFF(DEVPIC, pDevInsRC);
+    GEN_CHECK_OFF(DEVPIC, pPicHlpR3);
+    GEN_CHECK_OFF(DEVPIC, pPicHlpR0);
+    GEN_CHECK_OFF(DEVPIC, pPicHlpRC);
+#ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(DEVPIC, StatSetIrqGC);
+    GEN_CHECK_OFF(DEVPIC, StatClearedActiveSlaveIRQ);
+#endif
+
+    /* PC/DevPit-i8254.cpp */
+    GEN_CHECK_SIZE(DMAState);
+    GEN_CHECK_OFF(DMAState, DMAC);
+    GEN_CHECK_OFF(DMAState, DMAC[0].ChState[0]);
+    GEN_CHECK_OFF(DMAState, DMAC[0].ChState[1]);
+    GEN_CHECK_OFF(DMAState, DMAC[0].u8Mask);
+    GEN_CHECK_OFF(DMAState, DMAC[1].ChState[0]);
+    GEN_CHECK_OFF(DMAState, DMAC[1].ChState[1]);
+    GEN_CHECK_OFF(DMAState, DMAC[1].u8Mask);
+
+    /* PC/DevPit-i8254.cpp */
+    GEN_CHECK_SIZE(PITCHANNEL);
+    GEN_CHECK_OFF(PITCHANNEL, pPitR3);
+    GEN_CHECK_OFF(PITCHANNEL, pTimerR3);
+    GEN_CHECK_OFF(PITCHANNEL, pPitR0);
+    GEN_CHECK_OFF(PITCHANNEL, pTimerR0);
+    GEN_CHECK_OFF(PITCHANNEL, pPitRC);
+    GEN_CHECK_OFF(PITCHANNEL, pTimerRC);
+    GEN_CHECK_OFF(PITCHANNEL, u64ReloadTS);
+    GEN_CHECK_OFF(PITCHANNEL, u64NextTS);
+    GEN_CHECK_OFF(PITCHANNEL, count_load_time);
+    GEN_CHECK_OFF(PITCHANNEL, next_transition_time);
+    GEN_CHECK_OFF(PITCHANNEL, irq);
+    GEN_CHECK_OFF(PITCHANNEL, cRelLogEntries);
+    GEN_CHECK_OFF(PITCHANNEL, count);
+    GEN_CHECK_OFF(PITCHANNEL, latched_count);
+    GEN_CHECK_OFF(PITCHANNEL, count_latched);
+    GEN_CHECK_OFF(PITCHANNEL, status_latched);
+    GEN_CHECK_OFF(PITCHANNEL, status);
+    GEN_CHECK_OFF(PITCHANNEL, read_state);
+    GEN_CHECK_OFF(PITCHANNEL, write_state);
+    GEN_CHECK_OFF(PITCHANNEL, write_latch);
+    GEN_CHECK_OFF(PITCHANNEL, rw_mode);
+    GEN_CHECK_OFF(PITCHANNEL, mode);
+    GEN_CHECK_OFF(PITCHANNEL, bcd);
+    GEN_CHECK_OFF(PITCHANNEL, gate);
+    GEN_CHECK_SIZE(PITSTATE);
+    GEN_CHECK_OFF(PITSTATE, channels);
+    GEN_CHECK_OFF(PITSTATE, channels[1]);
+    GEN_CHECK_OFF(PITSTATE, speaker_data_on);
+//    GEN_CHECK_OFF(PITSTATE, dummy_refresh_clock);
+    GEN_CHECK_OFF(PITSTATE, IOPortBaseCfg);
+    GEN_CHECK_OFF(PITSTATE, fSpeakerCfg);
+    GEN_CHECK_OFF(PITSTATE, pDevIns);
+    GEN_CHECK_OFF(PITSTATE, StatPITIrq);
+    GEN_CHECK_OFF(PITSTATE, StatPITHandler);
+
+    /* PC/DevRTC.cpp */
+    GEN_CHECK_SIZE(RTCSTATE);
+    GEN_CHECK_OFF(RTCSTATE, cmos_data);
+    GEN_CHECK_OFF(RTCSTATE, cmos_data[1]);
+    GEN_CHECK_OFF(RTCSTATE, cmos_index);
+    GEN_CHECK_OFF(RTCSTATE, current_tm);
+    GEN_CHECK_OFF(RTCSTATE, current_tm.tm_sec);
+    GEN_CHECK_OFF(RTCSTATE, current_tm.tm_min);
+    GEN_CHECK_OFF(RTCSTATE, current_tm.tm_hour);
+    GEN_CHECK_OFF(RTCSTATE, current_tm.tm_mday);
+    GEN_CHECK_OFF(RTCSTATE, current_tm.tm_mon);
+    GEN_CHECK_OFF(RTCSTATE, current_tm.tm_year);
+    GEN_CHECK_OFF(RTCSTATE, current_tm.tm_wday);
+    GEN_CHECK_OFF(RTCSTATE, current_tm.tm_yday);
+    GEN_CHECK_OFF(RTCSTATE, irq);
+    GEN_CHECK_OFF(RTCSTATE, fUTC);
+    GEN_CHECK_OFF(RTCSTATE, IOPortBase);
+    GEN_CHECK_OFF(RTCSTATE, pPeriodicTimerR0);
+    GEN_CHECK_OFF(RTCSTATE, pPeriodicTimerR3);
+    GEN_CHECK_OFF(RTCSTATE, pPeriodicTimerRC);
+    GEN_CHECK_OFF(RTCSTATE, next_periodic_time);
+    GEN_CHECK_OFF(RTCSTATE, next_second_time);
+    GEN_CHECK_OFF(RTCSTATE, pSecondTimerR0);
+    GEN_CHECK_OFF(RTCSTATE, pSecondTimerR3);
+    GEN_CHECK_OFF(RTCSTATE, pSecondTimerRC);
+    GEN_CHECK_OFF(RTCSTATE, pSecondTimer2R0);
+    GEN_CHECK_OFF(RTCSTATE, pSecondTimer2R3);
+    GEN_CHECK_OFF(RTCSTATE, pSecondTimer2RC);
+    GEN_CHECK_OFF(RTCSTATE, pDevInsR0);
+    GEN_CHECK_OFF(RTCSTATE, pDevInsR3);
+    GEN_CHECK_OFF(RTCSTATE, pDevInsRC);
+    GEN_CHECK_OFF(RTCSTATE, RtcReg);
+    GEN_CHECK_OFF(RTCSTATE, pRtcHlpR3);
+    GEN_CHECK_OFF(RTCSTATE, cRelLogEntries);
+    GEN_CHECK_OFF(RTCSTATE, CurLogPeriod);
+    GEN_CHECK_OFF(RTCSTATE, CurHintPeriod);
+
+    GEN_CHECK_SIZE(APIC);
+    GEN_CHECK_OFF(APIC, pApicDevR0);
+    GEN_CHECK_OFF(APIC, pApicDevR3);
+    GEN_CHECK_OFF(APIC, pApicDevRC);
+    GEN_CHECK_OFF(APIC, HCPhysApicPib);
+    GEN_CHECK_OFF(APIC, pvApicPibR0);
+    GEN_CHECK_OFF(APIC, pvApicPibR3);
+    GEN_CHECK_OFF(APIC, pvApicPibRC);
+    GEN_CHECK_OFF(APIC, cbApicPib);
+    GEN_CHECK_OFF(APIC, fVirtApicRegsEnabled);
+    GEN_CHECK_OFF(APIC, fPostedIntrsEnabled);
+    GEN_CHECK_OFF(APIC, fSupportsTscDeadline);
+    GEN_CHECK_OFF(APIC, fIoApicPresent);
+    GEN_CHECK_OFF(APIC, fRZEnabled);
+    GEN_CHECK_OFF(APIC, enmMaxMode);
+
+    GEN_CHECK_SIZE(APICCPU);
+    GEN_CHECK_OFF(APICCPU, pvApicPageR0);
+    GEN_CHECK_OFF(APICCPU, pvApicPageR3);
+    GEN_CHECK_OFF(APICCPU, pvApicPageRC);
+    GEN_CHECK_OFF(APICCPU, cbApicPage);
+    GEN_CHECK_OFF(APICCPU, uEsrInternal);
+    GEN_CHECK_OFF(APICCPU, uApicBaseMsr);
+    GEN_CHECK_OFF(APICCPU, HCPhysApicPib);
+    GEN_CHECK_OFF(APICCPU, pvApicPibR0);
+    GEN_CHECK_OFF(APICCPU, pvApicPibR3);
+    GEN_CHECK_OFF(APICCPU, pvApicPibRC);
+    GEN_CHECK_OFF(APICCPU, ApicPibLevel);
+    GEN_CHECK_OFF(APICCPU, pTimerR0);
+    GEN_CHECK_OFF(APICCPU, pTimerR3);
+    GEN_CHECK_OFF(APICCPU, pTimerRC);
+    GEN_CHECK_OFF(APICCPU, TimerCritSect);
+    GEN_CHECK_OFF(APICCPU, u64TimerInitial);
+    GEN_CHECK_OFF(APICCPU, uHintedTimerInitialCount);
+    GEN_CHECK_OFF(APICCPU, uHintedTimerShift);
+# ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(APICCPU, StatMmioReadRZ);
+    GEN_CHECK_OFF(APICCPU, StatMmioReadR3);
+    GEN_CHECK_OFF(APICCPU, StatMmioWriteRZ);
+    GEN_CHECK_OFF(APICCPU, StatMmioWriteR3);
+    GEN_CHECK_OFF(APICCPU, StatMsrReadRZ);
+    GEN_CHECK_OFF(APICCPU, StatMsrReadR3);
+    GEN_CHECK_OFF(APICCPU, StatMsrWriteRZ);
+    GEN_CHECK_OFF(APICCPU, StatMsrWriteR3);
+    GEN_CHECK_OFF(APICCPU, StatUpdatePendingIntrs);
+    GEN_CHECK_OFF(APICCPU, StatPostIntr);
+    GEN_CHECK_OFF(APICCPU, StatPostIntrAlreadyPending);
+    GEN_CHECK_OFF(APICCPU, StatTimerCallback);
+    GEN_CHECK_OFF(APICCPU, StatTprWrite);
+    GEN_CHECK_OFF(APICCPU, StatTprRead);
+    GEN_CHECK_OFF(APICCPU, StatEoiWrite);
+    GEN_CHECK_OFF(APICCPU, StatMaskedByTpr);
+    GEN_CHECK_OFF(APICCPU, StatMaskedByPpr);
+    GEN_CHECK_OFF(APICCPU, StatTimerIcrWrite);
+    GEN_CHECK_OFF(APICCPU, StatIcrLoWrite);
+    GEN_CHECK_OFF(APICCPU, StatIcrHiWrite);
+    GEN_CHECK_OFF(APICCPU, StatIcrFullWrite);
+# endif /* VBOX_WITH_STATISTICS */
+
+    /* PC/DevIoApic.cpp */
+    GEN_CHECK_SIZE(IOAPIC);
+    GEN_CHECK_OFF(IOAPIC, pDevInsR3);
+    GEN_CHECK_OFF(IOAPIC, pIoApicHlpR3);
+    GEN_CHECK_OFF(IOAPIC, pDevInsR0);
+    GEN_CHECK_OFF(IOAPIC, pIoApicHlpR0);
+    GEN_CHECK_OFF(IOAPIC, pDevInsRC);
+    GEN_CHECK_OFF(IOAPIC, pIoApicHlpRC);
+    GEN_CHECK_OFF(IOAPIC, u8Id);
+    GEN_CHECK_OFF(IOAPIC, u8Index);
+    GEN_CHECK_OFF(IOAPIC, cCpus);
+    GEN_CHECK_OFF(IOAPIC, au64RedirTable);
+    GEN_CHECK_OFF(IOAPIC, uIrr);
+# ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(IOAPIC, StatMmioReadRZ);
+    GEN_CHECK_OFF(IOAPIC, StatMmioReadR3);
+    GEN_CHECK_OFF(IOAPIC, StatMmioWriteRZ);
+    GEN_CHECK_OFF(IOAPIC, StatMmioWriteR3);
+    GEN_CHECK_OFF(IOAPIC, StatSetIrqRZ);
+    GEN_CHECK_OFF(IOAPIC, StatSetIrqR3);
+    GEN_CHECK_OFF(IOAPIC, StatSetEoiRZ);
+    GEN_CHECK_OFF(IOAPIC, StatSetEoiR3);
+# endif
+
+    /* Storage/DevATA.cpp */
+    GEN_CHECK_SIZE(BMDMAState);
+    GEN_CHECK_OFF(BMDMAState, u8Cmd);
+    GEN_CHECK_OFF(BMDMAState, u8Status);
+    GEN_CHECK_OFF(BMDMAState, GCPhysAddr);
+    GEN_CHECK_SIZE(BMDMADesc);
+    GEN_CHECK_OFF(BMDMADesc, GCPhysBuffer);
+    GEN_CHECK_OFF(BMDMADesc, cbBuffer);
+    GEN_CHECK_SIZE(ATADevState);
+    GEN_CHECK_OFF(ATADevState, fLBA48);
+    GEN_CHECK_OFF(ATADevState, fATAPI);
+    GEN_CHECK_OFF(ATADevState, fIrqPending);
+    GEN_CHECK_OFF(ATADevState, cMultSectors);
+    GEN_CHECK_OFF(ATADevState, cbSector);
+    GEN_CHECK_OFF(ATADevState, PCHSGeometry.cCylinders);
+    GEN_CHECK_OFF(ATADevState, PCHSGeometry.cHeads);
+    GEN_CHECK_OFF(ATADevState, PCHSGeometry.cSectors);
+    GEN_CHECK_OFF(ATADevState, cSectorsPerIRQ);
+    GEN_CHECK_OFF(ATADevState, cTotalSectors);
+    GEN_CHECK_OFF(ATADevState, uATARegFeature);
+    GEN_CHECK_OFF(ATADevState, uATARegFeatureHOB);
+    GEN_CHECK_OFF(ATADevState, uATARegError);
+    GEN_CHECK_OFF(ATADevState, uATARegNSector);
+    GEN_CHECK_OFF(ATADevState, uATARegNSectorHOB);
+    GEN_CHECK_OFF(ATADevState, uATARegSector);
+    GEN_CHECK_OFF(ATADevState, uATARegSectorHOB);
+    GEN_CHECK_OFF(ATADevState, uATARegLCyl);
+    GEN_CHECK_OFF(ATADevState, uATARegLCylHOB);
+    GEN_CHECK_OFF(ATADevState, uATARegHCyl);
+    GEN_CHECK_OFF(ATADevState, uATARegHCylHOB);
+    GEN_CHECK_OFF(ATADevState, uATARegSelect);
+    GEN_CHECK_OFF(ATADevState, uATARegStatus);
+    GEN_CHECK_OFF(ATADevState, uATARegCommand);
+    GEN_CHECK_OFF(ATADevState, uATARegDevCtl);
+    GEN_CHECK_OFF(ATADevState, uATATransferMode);
+    GEN_CHECK_OFF(ATADevState, uTxDir);
+    GEN_CHECK_OFF(ATADevState, iBeginTransfer);
+    GEN_CHECK_OFF(ATADevState, iSourceSink);
+    GEN_CHECK_OFF(ATADevState, fDMA);
+    GEN_CHECK_OFF(ATADevState, fATAPITransfer);
+    GEN_CHECK_OFF(ATADevState, cbTotalTransfer);
+    GEN_CHECK_OFF(ATADevState, cbElementaryTransfer);
+    GEN_CHECK_OFF(ATADevState, iIOBufferCur);
+    GEN_CHECK_OFF(ATADevState, iIOBufferEnd);
+    GEN_CHECK_OFF(ATADevState, iIOBufferPIODataStart);
+    GEN_CHECK_OFF(ATADevState, iIOBufferPIODataEnd);
+    GEN_CHECK_OFF(ATADevState, iATAPILBA);
+    GEN_CHECK_OFF(ATADevState, cbATAPISector);
+    GEN_CHECK_OFF(ATADevState, aATAPICmd);
+    GEN_CHECK_OFF(ATADevState, aATAPICmd[ATAPI_PACKET_SIZE - 1]);
+    GEN_CHECK_OFF(ATADevState, abATAPISense);
+    GEN_CHECK_OFF(ATADevState, abATAPISense[ATAPI_SENSE_SIZE - 1]);
+    GEN_CHECK_OFF(ATADevState, cNotifiedMediaChange);
+    GEN_CHECK_OFF(ATADevState, MediaEventStatus);
+    GEN_CHECK_OFF(ATADevState, MediaTrackType);
+    GEN_CHECK_OFF(ATADevState, Led);
+    GEN_CHECK_OFF(ATADevState, cbIOBuffer);
+    GEN_CHECK_OFF(ATADevState, pbIOBufferR3);
+    GEN_CHECK_OFF(ATADevState, pbIOBufferR0);
+    GEN_CHECK_OFF(ATADevState, pbIOBufferRC);
+    GEN_CHECK_OFF(ATADevState, StatATADMA);
+    GEN_CHECK_OFF(ATADevState, StatATAPIO);
+    GEN_CHECK_OFF(ATADevState, StatATAPIDMA);
+    GEN_CHECK_OFF(ATADevState, StatATAPIPIO);
+    GEN_CHECK_OFF(ATADevState, StatReads);
+    GEN_CHECK_OFF(ATADevState, StatBytesRead);
+    GEN_CHECK_OFF(ATADevState, StatWrites);
+    GEN_CHECK_OFF(ATADevState, StatBytesWritten);
+    GEN_CHECK_OFF(ATADevState, StatFlushes);
+    GEN_CHECK_OFF(ATADevState, fATAPIPassthrough);
+    GEN_CHECK_OFF(ATADevState, fOverwriteInquiry);
+    GEN_CHECK_OFF(ATADevState, cErrors);
+    GEN_CHECK_OFF(ATADevState, pDrvBase);
+    GEN_CHECK_OFF(ATADevState, pDrvMedia);
+    GEN_CHECK_OFF(ATADevState, pDrvMount);
+    GEN_CHECK_OFF(ATADevState, IBase);
+    GEN_CHECK_OFF(ATADevState, IPort);
+    GEN_CHECK_OFF(ATADevState, IMountNotify);
+    GEN_CHECK_OFF(ATADevState, iLUN);
+    GEN_CHECK_OFF(ATADevState, pDevInsR3);
+    GEN_CHECK_OFF(ATADevState, pDevInsR0);
+    GEN_CHECK_OFF(ATADevState, pDevInsRC);
+    GEN_CHECK_OFF(ATADevState, pControllerR3);
+    GEN_CHECK_OFF(ATADevState, pControllerR0);
+    GEN_CHECK_OFF(ATADevState, pControllerRC);
+    GEN_CHECK_OFF(ATADevState, szSerialNumber);
+    GEN_CHECK_OFF(ATADevState, szSerialNumber[ATA_SERIAL_NUMBER_LENGTH]);
+    GEN_CHECK_OFF(ATADevState, szFirmwareRevision);
+    GEN_CHECK_OFF(ATADevState, szFirmwareRevision[ATA_FIRMWARE_REVISION_LENGTH]);
+    GEN_CHECK_OFF(ATADevState, szModelNumber);
+    GEN_CHECK_OFF(ATADevState, szModelNumber[ATA_MODEL_NUMBER_LENGTH]);
+    GEN_CHECK_OFF(ATADevState, szInquiryVendorId);
+    GEN_CHECK_OFF(ATADevState, szInquiryVendorId[SCSI_INQUIRY_VENDOR_ID_LENGTH]);
+    GEN_CHECK_OFF(ATADevState, szInquiryProductId);
+    GEN_CHECK_OFF(ATADevState, szInquiryProductId[SCSI_INQUIRY_PRODUCT_ID_LENGTH]);
+    GEN_CHECK_OFF(ATADevState, szInquiryRevision);
+    GEN_CHECK_OFF(ATADevState, szInquiryRevision[SCSI_INQUIRY_REVISION_LENGTH]);
+    GEN_CHECK_OFF(ATADevState, pTrackList);
+    GEN_CHECK_SIZE(ATATransferRequest);
+    GEN_CHECK_OFF(ATATransferRequest, iIf);
+    GEN_CHECK_OFF(ATATransferRequest, iBeginTransfer);
+    GEN_CHECK_OFF(ATATransferRequest, iSourceSink);
+    GEN_CHECK_OFF(ATATransferRequest, cbTotalTransfer);
+    GEN_CHECK_OFF(ATATransferRequest, uTxDir);
+    GEN_CHECK_SIZE(ATAAbortRequest);
+    GEN_CHECK_OFF(ATAAbortRequest, iIf);
+    GEN_CHECK_OFF(ATAAbortRequest, fResetDrive);
+    GEN_CHECK_SIZE(ATARequest);
+    GEN_CHECK_OFF(ATARequest, ReqType);
+    GEN_CHECK_OFF(ATARequest, u);
+    GEN_CHECK_OFF(ATARequest, u.t);
+    GEN_CHECK_OFF(ATARequest, u.a);
+    GEN_CHECK_SIZE(ATACONTROLLER);
+    GEN_CHECK_OFF(ATACONTROLLER, IOPortBase1);
+    GEN_CHECK_OFF(ATACONTROLLER, IOPortBase2);
+    GEN_CHECK_OFF(ATACONTROLLER, irq);
+    GEN_CHECK_OFF(ATACONTROLLER, lock);
+    GEN_CHECK_OFF(ATACONTROLLER, iSelectedIf);
+    GEN_CHECK_OFF(ATACONTROLLER, iAIOIf);
+    GEN_CHECK_OFF(ATACONTROLLER, uAsyncIOState);
+    GEN_CHECK_OFF(ATACONTROLLER, fChainedTransfer);
+    GEN_CHECK_OFF(ATACONTROLLER, fReset);
+    GEN_CHECK_OFF(ATACONTROLLER, fRedo);
+    GEN_CHECK_OFF(ATACONTROLLER, fRedoIdle);
+    GEN_CHECK_OFF(ATACONTROLLER, fRedoDMALastDesc);
+    GEN_CHECK_OFF(ATACONTROLLER, BmDma);
+    GEN_CHECK_OFF(ATACONTROLLER, GCPhysFirstDMADesc);
+    GEN_CHECK_OFF(ATACONTROLLER, GCPhysLastDMADesc);
+    GEN_CHECK_OFF(ATACONTROLLER, GCPhysRedoDMABuffer);
+    GEN_CHECK_OFF(ATACONTROLLER, cbRedoDMABuffer);
+    GEN_CHECK_OFF(ATACONTROLLER, aIfs);
+    GEN_CHECK_OFF(ATACONTROLLER, aIfs[1]);
+    GEN_CHECK_OFF(ATACONTROLLER, pDevInsR3);
+    GEN_CHECK_OFF(ATACONTROLLER, pDevInsR0);
+    GEN_CHECK_OFF(ATACONTROLLER, pDevInsRC);
+    GEN_CHECK_OFF(ATACONTROLLER, fShutdown);
+    GEN_CHECK_OFF(ATACONTROLLER, AsyncIOThread);
+    GEN_CHECK_OFF(ATACONTROLLER, hAsyncIOSem);
+    GEN_CHECK_OFF(ATACONTROLLER, aAsyncIORequests[4]);
+    GEN_CHECK_OFF(ATACONTROLLER, AsyncIOReqHead);
+    GEN_CHECK_OFF(ATACONTROLLER, AsyncIOReqTail);
+    GEN_CHECK_OFF(ATACONTROLLER, AsyncIORequestLock);
+    GEN_CHECK_OFF(ATACONTROLLER, SuspendIOSem);
+    GEN_CHECK_OFF(ATACONTROLLER, fSignalIdle);
+    GEN_CHECK_OFF(ATACONTROLLER, DelayIRQMillies);
+    GEN_CHECK_OFF(ATACONTROLLER, u64ResetTime);
+    GEN_CHECK_OFF(ATACONTROLLER, StatAsyncOps);
+    GEN_CHECK_OFF(ATACONTROLLER, StatAsyncMinWait);
+    GEN_CHECK_OFF(ATACONTROLLER, StatAsyncMaxWait);
+    GEN_CHECK_OFF(ATACONTROLLER, StatAsyncTimeUS);
+    GEN_CHECK_OFF(ATACONTROLLER, StatAsyncTime);
+    GEN_CHECK_OFF(ATACONTROLLER, StatLockWait);
+    GEN_CHECK_SIZE(PCIATAState);
+    GEN_CHECK_OFF(PCIATAState, dev);
+    GEN_CHECK_OFF(PCIATAState, aCts);
+    GEN_CHECK_OFF(PCIATAState, aCts[1]);
+    GEN_CHECK_OFF(PCIATAState, pDevIns);
+    GEN_CHECK_OFF(PCIATAState, IBase);
+    GEN_CHECK_OFF(PCIATAState, ILeds);
+    GEN_CHECK_OFF(PCIATAState, pLedsConnector);
+    GEN_CHECK_OFF(PCIATAState, fRCEnabled);
+    GEN_CHECK_OFF(PCIATAState, fR0Enabled);
+
+#ifdef VBOX_WITH_USB
+    /* USB/DevOHCI.cpp */
+    GEN_CHECK_SIZE(OHCIHUBPORT);
+    GEN_CHECK_OFF(OHCIHUBPORT, fReg);
+    GEN_CHECK_OFF(OHCIHUBPORT, pDev);
+
+    GEN_CHECK_SIZE(OHCIROOTHUB);
+    GEN_CHECK_OFF(OHCIROOTHUB, pIBase);
+    GEN_CHECK_OFF(OHCIROOTHUB, pIRhConn);
+    GEN_CHECK_OFF(OHCIROOTHUB, pIDev);
+    GEN_CHECK_OFF(OHCIROOTHUB, IBase);
+    GEN_CHECK_OFF(OHCIROOTHUB, IRhPort);
+    GEN_CHECK_OFF(OHCIROOTHUB, status);
+    GEN_CHECK_OFF(OHCIROOTHUB, desc_a);
+    GEN_CHECK_OFF(OHCIROOTHUB, desc_b);
+    GEN_CHECK_OFF(OHCIROOTHUB, aPorts);
+    GEN_CHECK_OFF(OHCIROOTHUB, aPorts[1]);
+    GEN_CHECK_OFF(OHCIROOTHUB, aPorts[OHCI_NDP_MAX - 1]);
+    GEN_CHECK_OFF(OHCIROOTHUB, pOhci);
+
+    GEN_CHECK_SIZE(OHCI);
+    GEN_CHECK_OFF(OHCI, PciDev);
+    GEN_CHECK_OFF(OHCI, MMIOBase);
+    GEN_CHECK_OFF(OHCI, pEndOfFrameTimerR3);
+    GEN_CHECK_OFF(OHCI, pEndOfFrameTimerR0);
+    GEN_CHECK_OFF(OHCI, pEndOfFrameTimerRC);
+    GEN_CHECK_OFF(OHCI, pDevInsR3);
+    GEN_CHECK_OFF(OHCI, pDevInsR0);
+    GEN_CHECK_OFF(OHCI, pDevInsRC);
+    GEN_CHECK_OFF(OHCI, SofTime);
+    //GEN_CHECK_OFF(OHCI, dqic:3);
+    //GEN_CHECK_OFF(OHCI, fno:1);
+    GEN_CHECK_OFF(OHCI, RootHub);
+    GEN_CHECK_OFF(OHCI, ctl);
+    GEN_CHECK_OFF(OHCI, status);
+    GEN_CHECK_OFF(OHCI, intr_status);
+    GEN_CHECK_OFF(OHCI, intr);
+    GEN_CHECK_OFF(OHCI, hcca);
+    GEN_CHECK_OFF(OHCI, per_cur);
+    GEN_CHECK_OFF(OHCI, ctrl_cur);
+    GEN_CHECK_OFF(OHCI, ctrl_head);
+    GEN_CHECK_OFF(OHCI, bulk_cur);
+    GEN_CHECK_OFF(OHCI, bulk_head);
+    GEN_CHECK_OFF(OHCI, done);
+    //GEN_CHECK_OFF(OHCI, fsmps:15);
+    //GEN_CHECK_OFF(OHCI, fit:1);
+    //GEN_CHECK_OFF(OHCI, fi:14);
+    //GEN_CHECK_OFF(OHCI, frt:1);
+    GEN_CHECK_OFF(OHCI, HcFmNumber);
+    GEN_CHECK_OFF(OHCI, pstart);
+    GEN_CHECK_OFF(OHCI, cTicksPerFrame);
+    GEN_CHECK_OFF(OHCI, cTicksPerUsbTick);
+    GEN_CHECK_OFF(OHCI, cInFlight);
+    GEN_CHECK_OFF(OHCI, aInFlight);
+    GEN_CHECK_OFF(OHCI, aInFlight[0].GCPhysTD);
+    GEN_CHECK_OFF(OHCI, aInFlight[0].pUrb);
+    GEN_CHECK_OFF(OHCI, aInFlight[1]);
+    GEN_CHECK_OFF(OHCI, cInDoneQueue);
+    GEN_CHECK_OFF(OHCI, aInDoneQueue);
+    GEN_CHECK_OFF(OHCI, aInDoneQueue[0].GCPhysTD);
+    GEN_CHECK_OFF(OHCI, aInDoneQueue[1]);
+    GEN_CHECK_OFF(OHCI, u32FmDoneQueueTail);
+    GEN_CHECK_OFF(OHCI, pLoad);
+# ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(OHCI, StatCanceledIsocUrbs);
+    GEN_CHECK_OFF(OHCI, StatCanceledGenUrbs);
+    GEN_CHECK_OFF(OHCI, StatDroppedUrbs);
+    GEN_CHECK_OFF(OHCI, StatTimer);
+# endif
+    GEN_CHECK_OFF(OHCI, CsIrq);
+    GEN_CHECK_OFF(OHCI, CritSect);
+
+# ifdef VBOX_WITH_EHCI_IMPL
+    /* USB/DevEHCI.cpp */
+    GEN_CHECK_SIZE(EHCIHUBPORT);
+    GEN_CHECK_OFF(EHCIHUBPORT, fReg);
+    GEN_CHECK_OFF(EHCIHUBPORT, pDev);
+
+    GEN_CHECK_SIZE(EHCIROOTHUB);
+    GEN_CHECK_OFF(EHCIROOTHUB, pIBase);
+    GEN_CHECK_OFF(EHCIROOTHUB, pIRhConn);
+    GEN_CHECK_OFF(EHCIROOTHUB, pIDev);
+    GEN_CHECK_OFF(EHCIROOTHUB, IBase);
+    GEN_CHECK_OFF(EHCIROOTHUB, IRhPort);
+    GEN_CHECK_OFF(EHCIROOTHUB, Led);
+    GEN_CHECK_OFF(EHCIROOTHUB, ILeds);
+    GEN_CHECK_OFF(EHCIROOTHUB, pLedsConnector);
+    GEN_CHECK_OFF(EHCIROOTHUB, aPorts);
+    GEN_CHECK_OFF(EHCIROOTHUB, aPorts[1]);
+    GEN_CHECK_OFF(EHCIROOTHUB, aPorts[EHCI_NDP_MAX - 1]);
+    GEN_CHECK_OFF(EHCIROOTHUB, pEhci);
+
+    GEN_CHECK_SIZE(EHCI);
+    GEN_CHECK_OFF(EHCI, PciDev);
+    GEN_CHECK_OFF(EHCI, MMIOBase);
+    GEN_CHECK_OFF(EHCI, pDevInsR3);
+    GEN_CHECK_OFF(EHCI, pDevInsR0);
+    GEN_CHECK_OFF(EHCI, pDevInsRC);
+    GEN_CHECK_OFF(EHCI, MMIOBase);
+    GEN_CHECK_OFF(EHCI, SofTime);
+    GEN_CHECK_OFF(EHCI, RootHub);
+    GEN_CHECK_OFF(EHCI, cap_length);
+    GEN_CHECK_OFF(EHCI, hci_version);
+    GEN_CHECK_OFF(EHCI, hcs_params);
+    GEN_CHECK_OFF(EHCI, hcc_params);
+    GEN_CHECK_OFF(EHCI, cmd);
+    GEN_CHECK_OFF(EHCI, intr_status);
+    GEN_CHECK_OFF(EHCI, intr);
+    GEN_CHECK_OFF(EHCI, frame_idx);
+    GEN_CHECK_OFF(EHCI, ds_segment);
+    GEN_CHECK_OFF(EHCI, periodic_list_base);
+    GEN_CHECK_OFF(EHCI, async_list_base);
+    GEN_CHECK_OFF(EHCI, config);
+    GEN_CHECK_OFF(EHCI, uIrqInterval);
+    GEN_CHECK_OFF(EHCI, HcFmNumber);
+    GEN_CHECK_OFF(EHCI, uFramesPerTimerCall);
+    GEN_CHECK_OFF(EHCI, cTicksPerFrame);
+    GEN_CHECK_OFF(EHCI, cTicksPerUsbTick);
+    GEN_CHECK_OFF(EHCI, cInFlight);
+    GEN_CHECK_OFF(EHCI, aInFlight);
+    GEN_CHECK_OFF(EHCI, aInFlight[0].GCPhysTD);
+    GEN_CHECK_OFF(EHCI, aInFlight[0].pUrb);
+    GEN_CHECK_OFF(EHCI, aInFlight[1]);
+    GEN_CHECK_OFF(EHCI, aInFlight[256]);
+    GEN_CHECK_OFF(EHCI, pLoad);
+    GEN_CHECK_OFF(EHCI, fAsyncTraversalTimerActive);
+#  ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(EHCI, StatCanceledIsocUrbs);
+    GEN_CHECK_OFF(EHCI, StatCanceledGenUrbs);
+    GEN_CHECK_OFF(EHCI, StatDroppedUrbs);
+#  endif
+    GEN_CHECK_OFF(EHCI, u64TimerHz);
+    GEN_CHECK_OFF(EHCI, cIdleCycles);
+    GEN_CHECK_OFF(EHCI, uFrameRate);
+    GEN_CHECK_OFF(EHCI, fIdle);
+    GEN_CHECK_OFF(EHCI, hThreadFrame);
+    GEN_CHECK_OFF(EHCI, hSemEventFrame);
+    GEN_CHECK_OFF(EHCI, fBusStarted);
+    GEN_CHECK_OFF(EHCI, CsIrq);
+    GEN_CHECK_OFF(EHCI, uFrameRateDefault);
+    GEN_CHECK_OFF(EHCI, nsWait);
+    GEN_CHECK_OFF(EHCI, CritSect);
+# endif /* VBOX_WITH_EHCI_IMPL */
+
+# ifdef VBOX_WITH_XHCI_IMPL
+    /* USB/DevXHCI.cpp */
+    GEN_CHECK_SIZE(XHCIHUBPORT);
+    GEN_CHECK_OFF(XHCIHUBPORT, portsc);
+    GEN_CHECK_OFF(XHCIHUBPORT, portpm);
+    GEN_CHECK_OFF(XHCIHUBPORT, portli);
+    GEN_CHECK_OFF(XHCIHUBPORT, pDev);
+
+    GEN_CHECK_SIZE(XHCIROOTHUB);
+    GEN_CHECK_OFF(XHCIROOTHUB, pIBase);
+    GEN_CHECK_OFF(XHCIROOTHUB, pIRhConn);
+    GEN_CHECK_OFF(XHCIROOTHUB, pIDev);
+    GEN_CHECK_OFF(XHCIROOTHUB, IBase);
+    GEN_CHECK_OFF(XHCIROOTHUB, IRhPort);
+    GEN_CHECK_OFF(XHCIROOTHUB, Led);
+    GEN_CHECK_OFF(XHCIROOTHUB, cPortsImpl);
+    GEN_CHECK_OFF(XHCIROOTHUB, pXhci);
+
+    GEN_CHECK_SIZE(XHCIINTRPTR);
+    GEN_CHECK_OFF(XHCIINTRPTR, iman);
+    GEN_CHECK_OFF(XHCIINTRPTR, imod);
+    GEN_CHECK_OFF(XHCIINTRPTR, erstba);
+    GEN_CHECK_OFF(XHCIINTRPTR, erdp);
+    GEN_CHECK_OFF(XHCIINTRPTR, erep);
+    GEN_CHECK_OFF(XHCIINTRPTR, erst_idx);
+    GEN_CHECK_OFF(XHCIINTRPTR, trb_count);
+    GEN_CHECK_OFF(XHCIINTRPTR, evtr_pcs);
+    GEN_CHECK_OFF(XHCIINTRPTR, ipe);
+
+    GEN_CHECK_SIZE(XHCI);
+    GEN_CHECK_OFF(XHCI, PciDev);
+    GEN_CHECK_OFF(XHCI, pDevInsR3);
+    GEN_CHECK_OFF(XHCI, pDevInsR0);
+    GEN_CHECK_OFF(XHCI, pDevInsRC);
+    GEN_CHECK_OFF(XHCI, pNotifierQueueR3);
+    GEN_CHECK_OFF(XHCI, pNotifierQueueR0);
+    GEN_CHECK_OFF(XHCI, pNotifierQueueRC);
+    GEN_CHECK_OFF(XHCI, pWrapTimerR3);
+    GEN_CHECK_OFF(XHCI, pWrapTimerR0);
+    GEN_CHECK_OFF(XHCI, pWrapTimerRC);
+    GEN_CHECK_OFF(XHCI, pWorkerThread);
+    GEN_CHECK_OFF(XHCI, pSupDrvSession);
+    GEN_CHECK_OFF(XHCI, hEvtProcess);
+    GEN_CHECK_OFF(XHCI, fWrkThreadSleeping);
+    GEN_CHECK_OFF(XHCI, u32TasksNew);
+    GEN_CHECK_OFF(XHCI, ILeds);
+    GEN_CHECK_OFF(XHCI, pLedsConnector);
+    GEN_CHECK_OFF(XHCI, MMIOBase);
+    GEN_CHECK_OFF(XHCI, RootHub2);
+    GEN_CHECK_OFF(XHCI, RootHub3);
+    GEN_CHECK_OFF(XHCI, aPorts);
+    GEN_CHECK_OFF(XHCI, aPorts[1]);
+    GEN_CHECK_OFF(XHCI, aPorts[XHCI_NDP_MAX - 1]);
+    GEN_CHECK_OFF(XHCI, cap_length);
+    GEN_CHECK_OFF(XHCI, hci_version);
+    GEN_CHECK_OFF(XHCI, hcs_params3);
+    GEN_CHECK_OFF(XHCI, hcc_params);
+    GEN_CHECK_OFF(XHCI, dbell_off);
+    GEN_CHECK_OFF(XHCI, rts_off);
+    GEN_CHECK_OFF(XHCI, cmd);
+    GEN_CHECK_OFF(XHCI, status);
+    GEN_CHECK_OFF(XHCI, dnctrl);
+    GEN_CHECK_OFF(XHCI, config);
+    GEN_CHECK_OFF(XHCI, crcr);
+    GEN_CHECK_OFF(XHCI, dcbaap);
+    GEN_CHECK_OFF(XHCI, abExtCap);
+    GEN_CHECK_OFF(XHCI, cbExtCap);
+    GEN_CHECK_OFF(XHCI, cmdr_dqp);
+    GEN_CHECK_OFF(XHCI, cmdr_ccs);
+    GEN_CHECK_OFF(XHCI, aSlotState);
+    GEN_CHECK_OFF(XHCI, aBellsRung);
+    GEN_CHECK_OFF(XHCI, pLoad);
+#  ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(XHCI, StatErrorIsocUrbs);
+    GEN_CHECK_OFF(XHCI, StatErrorIsocPkts);
+    GEN_CHECK_OFF(XHCI, StatEventsWritten);
+    GEN_CHECK_OFF(XHCI, StatEventsDropped);
+    GEN_CHECK_OFF(XHCI, StatIntrsPending);
+    GEN_CHECK_OFF(XHCI, StatIntrsSet);
+    GEN_CHECK_OFF(XHCI, StatIntrsNotSet);
+    GEN_CHECK_OFF(XHCI, StatIntrsCleared);
+#  endif
+# endif /* VBOX_WITH_XHCI_IMPL */
+#endif /* VBOX_WITH_USB */
+
+    /* Parallel/DevParallel.cpp */
+    GEN_CHECK_SIZE(PARALLELPORT);
+    GEN_CHECK_OFF(PARALLELPORT, pDevInsR3);
+    GEN_CHECK_OFF(PARALLELPORT, pDevInsR0);
+    GEN_CHECK_OFF(PARALLELPORT, pDevInsRC);
+    GEN_CHECK_OFF(PARALLELPORT, IBase);
+    GEN_CHECK_OFF(PARALLELPORT, IHostParallelPort);
+    GEN_CHECK_OFF(PARALLELPORT, pDrvHostParallelConnector);
+    GEN_CHECK_OFF(PARALLELPORT, fGCEnabled);
+    GEN_CHECK_OFF(PARALLELPORT, fR0Enabled);
+    GEN_CHECK_OFF(PARALLELPORT, fEppTimeout);
+    GEN_CHECK_OFF(PARALLELPORT, IOBase);
+    GEN_CHECK_OFF(PARALLELPORT, iIrq);
+    GEN_CHECK_OFF(PARALLELPORT, regData);
+    GEN_CHECK_OFF(PARALLELPORT, regStatus);
+    GEN_CHECK_OFF(PARALLELPORT, regControl);
+    GEN_CHECK_OFF(PARALLELPORT, regEppAddr);
+    GEN_CHECK_OFF(PARALLELPORT, regEppData);
+#if 0
+    GEN_CHECK_OFF(PARALLELPORT, reg_ecp_ecr);
+    GEN_CHECK_OFF(PARALLELPORT, reg_ecp_base_plus_400h);
+    GEN_CHECK_OFF(PARALLELPORT, reg_ecp_config_b);
+    GEN_CHECK_OFF(PARALLELPORT, ecp_fifo);
+    GEN_CHECK_OFF(PARALLELPORT, ecp_fifo[1]);
+    GEN_CHECK_OFF(PARALLELPORT, act_fifo_pos_write);
+    GEN_CHECK_OFF(PARALLELPORT, act_fifo_pos_read);
+#endif
+
+    /* Serial/UartCore.cpp */
+    GEN_CHECK_SIZE(UARTCORE);
+    GEN_CHECK_OFF(UARTCORE, CritSect);
+    GEN_CHECK_OFF(UARTCORE, pDevInsR3);
+    GEN_CHECK_OFF(UARTCORE, pDevInsR0);
+    GEN_CHECK_OFF(UARTCORE, pDevInsRC);
+    GEN_CHECK_OFF(UARTCORE, iLUN);
+    GEN_CHECK_OFF(UARTCORE, IBase);
+    GEN_CHECK_OFF(UARTCORE, ISerialPort);
+    GEN_CHECK_OFF(UARTCORE, pDrvBase);
+    GEN_CHECK_OFF(UARTCORE, pDrvSerial);
+    GEN_CHECK_OFF(UARTCORE, fFlags);
+    GEN_CHECK_OFF(UARTCORE, enmType);
+    GEN_CHECK_OFF(UARTCORE, pTimerRcvFifoTimeoutR3);
+    GEN_CHECK_OFF(UARTCORE, pTimerTxUnconnectedR3);
+    GEN_CHECK_OFF(UARTCORE, pfnUartIrqReqR3);
+    GEN_CHECK_OFF(UARTCORE, pTimerRcvFifoTimeoutR0);
+    GEN_CHECK_OFF(UARTCORE, pTimerTxUnconnectedR0);
+    GEN_CHECK_OFF(UARTCORE, pfnUartIrqReqR0);
+    GEN_CHECK_OFF(UARTCORE, pTimerRcvFifoTimeoutRC);
+    GEN_CHECK_OFF(UARTCORE, pTimerTxUnconnectedRC);
+    GEN_CHECK_OFF(UARTCORE, pfnUartIrqReqRC);
+    GEN_CHECK_OFF(UARTCORE, uRegDivisor);
+    GEN_CHECK_OFF(UARTCORE, uRegRbr);
+    GEN_CHECK_OFF(UARTCORE, uRegThr);
+    GEN_CHECK_OFF(UARTCORE, uRegIer);
+    GEN_CHECK_OFF(UARTCORE, uRegIir);
+    GEN_CHECK_OFF(UARTCORE, uRegFcr);
+    GEN_CHECK_OFF(UARTCORE, uRegLcr);
+    GEN_CHECK_OFF(UARTCORE, uRegMcr);
+    GEN_CHECK_OFF(UARTCORE, uRegLsr);
+    GEN_CHECK_OFF(UARTCORE, uRegMsr);
+    GEN_CHECK_OFF(UARTCORE, uRegScr);
+    GEN_CHECK_OFF(UARTCORE, fIrqCtiPending);
+    GEN_CHECK_OFF(UARTCORE, fThreEmptyPending);
+    GEN_CHECK_OFF(UARTCORE, FifoXmit);
+    GEN_CHECK_OFF(UARTCORE, FifoRecv);
+    GEN_CHECK_OFF(UARTCORE, cSymbolXferTicks);
+    GEN_CHECK_OFF(UARTCORE, cbAvailRdr);
+
+    /* Serial/DevSerial.cpp */
+    GEN_CHECK_SIZE(DEVSERIAL);
+    GEN_CHECK_OFF(DEVSERIAL, pDevInsR3);
+    GEN_CHECK_OFF(DEVSERIAL, pDevInsR0);
+    GEN_CHECK_OFF(DEVSERIAL, pDevInsRC);
+    GEN_CHECK_OFF(DEVSERIAL, fR0Enabled);
+    GEN_CHECK_OFF(DEVSERIAL, fRCEnabled);
+    GEN_CHECK_OFF(DEVSERIAL, uIrq);
+    GEN_CHECK_OFF(DEVSERIAL, PortBase);
+    GEN_CHECK_OFF(DEVSERIAL, UartCore);
+
+    /* Serial/DevOxPcie958.cpp */
+    GEN_CHECK_SIZE(DEVOX958);
+    GEN_CHECK_OFF(DEVOX958, PciDev);
+    GEN_CHECK_OFF(DEVOX958, pDevInsR3);
+    GEN_CHECK_OFF(DEVOX958, pDevInsR0);
+    GEN_CHECK_OFF(DEVOX958, pDevInsRC);
+    GEN_CHECK_OFF(DEVOX958, fR0Enabled);
+    GEN_CHECK_OFF(DEVOX958, fRCEnabled);
+    GEN_CHECK_OFF(DEVOX958, u32RegIrqStsGlob);
+    GEN_CHECK_OFF(DEVOX958, u32RegIrqEnGlob);
+    GEN_CHECK_OFF(DEVOX958, u32RegIrqEnWake);
+    GEN_CHECK_OFF(DEVOX958, cUarts);
+    GEN_CHECK_OFF(DEVOX958, GCPhysMMIO);
+    GEN_CHECK_OFF(DEVOX958, aUarts);
+    GEN_CHECK_OFF(DEVOX958, aUarts[OX958_UARTS_MAX - 1]);
+
+#ifdef VBOX_WITH_AHCI
+    /* Storage/DevAHCI.cpp */
+
+    GEN_CHECK_SIZE(AHCIPort);
+    GEN_CHECK_OFF(AHCIPort, pDevInsR3);
+    GEN_CHECK_OFF(AHCIPort, pDevInsR0);
+    GEN_CHECK_OFF(AHCIPort, pDevInsRC);
+    GEN_CHECK_OFF(AHCIPort, pAhciR3);
+    GEN_CHECK_OFF(AHCIPort, pAhciR0);
+    GEN_CHECK_OFF(AHCIPort, pAhciRC);
+    GEN_CHECK_OFF(AHCIPort, regCLB);
+    GEN_CHECK_OFF(AHCIPort, regCLBU);
+    GEN_CHECK_OFF(AHCIPort, regFB);
+    GEN_CHECK_OFF(AHCIPort, regFBU);
+    GEN_CHECK_OFF(AHCIPort, regIS);
+    GEN_CHECK_OFF(AHCIPort, regIE);
+    GEN_CHECK_OFF(AHCIPort, regCMD);
+    GEN_CHECK_OFF(AHCIPort, regTFD);
+    GEN_CHECK_OFF(AHCIPort, regSIG);
+    GEN_CHECK_OFF(AHCIPort, regSSTS);
+    GEN_CHECK_OFF(AHCIPort, regSCTL);
+    GEN_CHECK_OFF(AHCIPort, regSERR);
+    GEN_CHECK_OFF(AHCIPort, regSACT);
+    GEN_CHECK_OFF(AHCIPort, regCI);
+    GEN_CHECK_OFF(AHCIPort, cTasksActive);
+    GEN_CHECK_OFF(AHCIPort, GCPhysAddrClb);
+    GEN_CHECK_OFF(AHCIPort, GCPhysAddrFb);
+    GEN_CHECK_OFF(AHCIPort, fPoweredOn);
+    GEN_CHECK_OFF(AHCIPort, fSpunUp);
+    GEN_CHECK_OFF(AHCIPort, fFirstD2HFisSent);
+    GEN_CHECK_OFF(AHCIPort, fATAPI);
+    GEN_CHECK_OFF(AHCIPort, fPortReset);
+    GEN_CHECK_OFF(AHCIPort, fTrimEnabled);
+    GEN_CHECK_OFF(AHCIPort, fResetDevice);
+    GEN_CHECK_OFF(AHCIPort, fHotpluggable);
+    GEN_CHECK_OFF(AHCIPort, fRedo);
+    GEN_CHECK_OFF(AHCIPort, fWrkThreadSleeping);
+    GEN_CHECK_OFF(AHCIPort, cTotalSectors);
+    GEN_CHECK_OFF(AHCIPort, cbSector);
+    GEN_CHECK_OFF(AHCIPort, cMultSectors);
+    GEN_CHECK_OFF(AHCIPort, uATATransferMode);
+    GEN_CHECK_OFF(AHCIPort, abATAPISense);
+    GEN_CHECK_OFF(AHCIPort, cLogSectorsPerPhysicalExp);
+    GEN_CHECK_OFF(AHCIPort, iLUN);
+    GEN_CHECK_OFF(AHCIPort, u32TasksFinished);
+    GEN_CHECK_OFF(AHCIPort, u32QueuedTasksFinished);
+    GEN_CHECK_OFF(AHCIPort, u32TasksNew);
+    GEN_CHECK_OFF(AHCIPort, u32TasksRedo);
+    GEN_CHECK_OFF(AHCIPort, u32CurrentCommandSlot);
+    GEN_CHECK_OFF(AHCIPort, pDrvBase);
+    GEN_CHECK_OFF(AHCIPort, pDrvMedia);
+    GEN_CHECK_OFF(AHCIPort, pDrvMediaEx);
+    GEN_CHECK_OFF(AHCIPort, pszDesc);
+    GEN_CHECK_OFF(AHCIPort, IBase);
+    GEN_CHECK_OFF(AHCIPort, IPort);
+    GEN_CHECK_OFF(AHCIPort, IMediaExPort);
+    GEN_CHECK_OFF(AHCIPort, PCHSGeometry);
+    GEN_CHECK_OFF(AHCIPort, Led);
+    GEN_CHECK_OFF(AHCIPort, pAsyncIOThread);
+
+    GEN_CHECK_OFF(AHCIPort, pTaskErr);
+    GEN_CHECK_OFF(AHCIPort, hEvtProcess);
+    GEN_CHECK_OFF(AHCIPort, szSerialNumber);
+    GEN_CHECK_OFF(AHCIPort, szSerialNumber[AHCI_SERIAL_NUMBER_LENGTH]); /* One additional byte for the termination.*/
+    GEN_CHECK_OFF(AHCIPort, szFirmwareRevision);
+    GEN_CHECK_OFF(AHCIPort, szFirmwareRevision[AHCI_FIRMWARE_REVISION_LENGTH]); /* One additional byte for the termination.*/
+    GEN_CHECK_OFF(AHCIPort, szModelNumber);
+    GEN_CHECK_OFF(AHCIPort, szModelNumber[AHCI_MODEL_NUMBER_LENGTH]); /* One additional byte for the termination.*/
+    GEN_CHECK_OFF(AHCIPort, szInquiryVendorId);
+    GEN_CHECK_OFF(AHCIPort, szInquiryVendorId[AHCI_ATAPI_INQUIRY_VENDOR_ID_LENGTH]); /* One additional byte for the termination.*/
+    GEN_CHECK_OFF(AHCIPort, szInquiryProductId);
+    GEN_CHECK_OFF(AHCIPort, szInquiryProductId[AHCI_ATAPI_INQUIRY_PRODUCT_ID_LENGTH]); /* One additional byte for the termination.*/
+    GEN_CHECK_OFF(AHCIPort, szInquiryRevision);
+    GEN_CHECK_OFF(AHCIPort, szInquiryRevision[AHCI_ATAPI_INQUIRY_REVISION_LENGTH]); /* One additional byte for the termination.*/
+    GEN_CHECK_OFF(AHCIPort, cErrors);
+    GEN_CHECK_OFF(AHCIPort, fRedo);
+
+    GEN_CHECK_SIZE(AHCI);
+    GEN_CHECK_OFF(AHCI, dev);
+    GEN_CHECK_OFF(AHCI, pDevInsR3);
+    GEN_CHECK_OFF(AHCI, pDevInsR0);
+    GEN_CHECK_OFF(AHCI, pDevInsRC);
+    GEN_CHECK_OFF(AHCI, IBase);
+    GEN_CHECK_OFF(AHCI, ILeds);
+    GEN_CHECK_OFF(AHCI, pLedsConnector);
+    GEN_CHECK_OFF(AHCI, MMIOBase);
+    GEN_CHECK_OFF(AHCI, regHbaCap);
+    GEN_CHECK_OFF(AHCI, regHbaCtrl);
+    GEN_CHECK_OFF(AHCI, regHbaIs);
+    GEN_CHECK_OFF(AHCI, regHbaPi);
+    GEN_CHECK_OFF(AHCI, regHbaVs);
+    GEN_CHECK_OFF(AHCI, regHbaCccCtl);
+    GEN_CHECK_OFF(AHCI, regHbaCccPorts);
+    GEN_CHECK_OFF(AHCI, regIdx);
+    GEN_CHECK_OFF(AHCI, pHbaCccTimerR3);
+    GEN_CHECK_OFF(AHCI, pHbaCccTimerR0);
+    GEN_CHECK_OFF(AHCI, pHbaCccTimerRC);
+    GEN_CHECK_OFF(AHCI, pNotifierQueueR3);
+    GEN_CHECK_OFF(AHCI, pNotifierQueueR0);
+    GEN_CHECK_OFF(AHCI, pNotifierQueueRC);
+    GEN_CHECK_OFF(AHCI, uCccPortNr);
+    GEN_CHECK_OFF(AHCI, uCccTimeout);
+    GEN_CHECK_OFF(AHCI, uCccNr);
+    GEN_CHECK_OFF(AHCI, uCccCurrentNr);
+    GEN_CHECK_OFF(AHCI, ahciPort);
+    GEN_CHECK_OFF(AHCI, ahciPort[AHCI_MAX_NR_PORTS_IMPL-1]);
+    GEN_CHECK_OFF(AHCI, lock);
+    GEN_CHECK_OFF(AHCI, u32PortsInterrupted);
+    GEN_CHECK_OFF(AHCI, cThreadsActive);
+    GEN_CHECK_OFF(AHCI, fReset);
+    GEN_CHECK_OFF(AHCI, f64BitAddr);
+    GEN_CHECK_OFF(AHCI, fGCEnabled);
+    GEN_CHECK_OFF(AHCI, fR0Enabled);
+    GEN_CHECK_OFF(AHCI, fSignalIdle);
+    GEN_CHECK_OFF(AHCI, fBootable);
+    GEN_CHECK_OFF(AHCI, fLegacyPortResetMethod);
+    GEN_CHECK_OFF(AHCI, cPortsImpl);
+    GEN_CHECK_OFF(AHCI, cCmdSlotsAvail);
+    GEN_CHECK_OFF(AHCI, f8ByteMMIO4BytesWrittenSuccessfully);
+    GEN_CHECK_OFF(AHCI, pSupDrvSession);
+#endif /* VBOX_WITH_AHCI */
+
+#ifdef VBOX_WITH_E1000
+    GEN_CHECK_SIZE(EEPROM93C46);
+    GEN_CHECK_OFF(EEPROM93C46, m_eState);
+    GEN_CHECK_OFF(EEPROM93C46, m_au16Data);
+    GEN_CHECK_OFF(EEPROM93C46, m_fWriteEnabled);
+    GEN_CHECK_OFF(EEPROM93C46, m_u16Word);
+    GEN_CHECK_OFF(EEPROM93C46, m_u16Mask);
+    GEN_CHECK_OFF(EEPROM93C46, m_u16Addr);
+    GEN_CHECK_OFF(EEPROM93C46, m_u32InternalWires);
+    GEN_CHECK_OFF(EEPROM93C46, m_eOp);
+
+    GEN_CHECK_SIZE(E1KSTATE);
+    GEN_CHECK_OFF(E1KSTATE, IBase);
+    GEN_CHECK_OFF(E1KSTATE, INetworkDown);
+    GEN_CHECK_OFF(E1KSTATE, INetworkConfig);
+    GEN_CHECK_OFF(E1KSTATE, ILeds);
+    GEN_CHECK_OFF(E1KSTATE, pDrvBase);
+    GEN_CHECK_OFF(E1KSTATE, pDrvR3);
+    GEN_CHECK_OFF(E1KSTATE, pDrvR0);
+    GEN_CHECK_OFF(E1KSTATE, pDrvRC);
+    GEN_CHECK_OFF(E1KSTATE, pLedsConnector);
+    GEN_CHECK_OFF(E1KSTATE, pDevInsR3);
+    GEN_CHECK_OFF(E1KSTATE, pDevInsR0);
+    GEN_CHECK_OFF(E1KSTATE, pDevInsRC);
+    GEN_CHECK_OFF(E1KSTATE, pTxQueueR3);
+    GEN_CHECK_OFF(E1KSTATE, pTxQueueR0);
+    GEN_CHECK_OFF(E1KSTATE, pTxQueueRC);
+    GEN_CHECK_OFF(E1KSTATE, pCanRxQueueR3);
+    GEN_CHECK_OFF(E1KSTATE, pCanRxQueueR0);
+    GEN_CHECK_OFF(E1KSTATE, pCanRxQueueRC);
+    GEN_CHECK_OFF(E1KSTATE, pRIDTimerR3);
+    GEN_CHECK_OFF(E1KSTATE, pRIDTimerR0);
+    GEN_CHECK_OFF(E1KSTATE, pRIDTimerRC);
+    GEN_CHECK_OFF(E1KSTATE, pRADTimerR3);
+    GEN_CHECK_OFF(E1KSTATE, pRADTimerR0);
+    GEN_CHECK_OFF(E1KSTATE, pRADTimerRC);
+    GEN_CHECK_OFF(E1KSTATE, pTIDTimerR3);
+    GEN_CHECK_OFF(E1KSTATE, pTIDTimerR0);
+    GEN_CHECK_OFF(E1KSTATE, pTIDTimerRC);
+    GEN_CHECK_OFF(E1KSTATE, pTADTimerR3);
+    GEN_CHECK_OFF(E1KSTATE, pTADTimerR0);
+    GEN_CHECK_OFF(E1KSTATE, pTADTimerRC);
+    GEN_CHECK_OFF(E1KSTATE, pIntTimerR3);
+    GEN_CHECK_OFF(E1KSTATE, pIntTimerR0);
+    GEN_CHECK_OFF(E1KSTATE, pIntTimerRC);
+    GEN_CHECK_OFF(E1KSTATE, pLUTimerR3);
+    GEN_CHECK_OFF(E1KSTATE, pLUTimerR0);
+    GEN_CHECK_OFF(E1KSTATE, pLUTimerRC);
+    GEN_CHECK_OFF(E1KSTATE, cs);
+# ifndef E1K_GLOBAL_MUTEX
+    GEN_CHECK_OFF(E1KSTATE, csRx);
+# endif
+    GEN_CHECK_OFF(E1KSTATE, addrMMReg);
+    GEN_CHECK_OFF(E1KSTATE, macConfigured);
+    GEN_CHECK_OFF(E1KSTATE, IOPortBase);
+    GEN_CHECK_OFF(E1KSTATE, pciDevice);
+    GEN_CHECK_OFF(E1KSTATE, u64AckedAt);
+    GEN_CHECK_OFF(E1KSTATE, fIntRaised);
+    GEN_CHECK_OFF(E1KSTATE, fCableConnected);
+    GEN_CHECK_OFF(E1KSTATE, fR0Enabled);
+    GEN_CHECK_OFF(E1KSTATE, fRCEnabled);
+    GEN_CHECK_OFF(E1KSTATE, auRegs[E1K_NUM_OF_32BIT_REGS]);
+    GEN_CHECK_OFF(E1KSTATE, led);
+    GEN_CHECK_OFF(E1KSTATE, u32PktNo);
+    GEN_CHECK_OFF(E1KSTATE, uSelectedReg);
+    GEN_CHECK_OFF(E1KSTATE, auMTA[128]);
+    GEN_CHECK_OFF(E1KSTATE, aRecAddr);
+    GEN_CHECK_OFF(E1KSTATE, auVFTA[128]);
+    GEN_CHECK_OFF(E1KSTATE, u16RxBSize);
+    GEN_CHECK_OFF(E1KSTATE, fLocked);
+    GEN_CHECK_OFF(E1KSTATE, fDelayInts);
+    GEN_CHECK_OFF(E1KSTATE, fIntMaskUsed);
+    GEN_CHECK_OFF(E1KSTATE, fMaybeOutOfSpace);
+    GEN_CHECK_OFF(E1KSTATE, hEventMoreRxDescAvail);
+    GEN_CHECK_OFF(E1KSTATE, contextTSE);
+    GEN_CHECK_OFF(E1KSTATE, contextNormal);
+# ifdef E1K_WITH_TXD_CACHE
+    GEN_CHECK_OFF(E1KSTATE, aTxDescriptors);
+    GEN_CHECK_OFF(E1KSTATE, nTxDFetched);
+    GEN_CHECK_OFF(E1KSTATE, iTxDCurrent);
+    GEN_CHECK_OFF(E1KSTATE, fGSO);
+    GEN_CHECK_OFF(E1KSTATE, cbTxAlloc);
+# endif
+    GEN_CHECK_OFF(E1KSTATE, GsoCtx);
+    GEN_CHECK_OFF(E1KSTATE, uTxFallback);
+    GEN_CHECK_OFF(E1KSTATE, fVTag);
+    GEN_CHECK_OFF(E1KSTATE, u16VTagTCI);
+    GEN_CHECK_OFF(E1KSTATE, aTxPacketFallback[E1K_MAX_TX_PKT_SIZE]);
+    GEN_CHECK_OFF(E1KSTATE, u16TxPktLen);
+    GEN_CHECK_OFF(E1KSTATE, fIPcsum);
+    GEN_CHECK_OFF(E1KSTATE, fTCPcsum);
+    GEN_CHECK_OFF(E1KSTATE, u32PayRemain);
+    GEN_CHECK_OFF(E1KSTATE, u16HdrRemain);
+    GEN_CHECK_OFF(E1KSTATE, u16SavedFlags);
+    GEN_CHECK_OFF(E1KSTATE, u32SavedCsum);
+    GEN_CHECK_OFF(E1KSTATE, eeprom);
+    GEN_CHECK_OFF(E1KSTATE, phy);
+    GEN_CHECK_OFF(E1KSTATE, StatReceiveBytes);
+#endif /* VBOX_WITH_E1000 */
+
+    /* VMMDev*.cpp/h */
+    GEN_CHECK_SIZE(VMMDEV);
+    GEN_CHECK_OFF(VMMDEV, PciDev);
+    GEN_CHECK_OFF(VMMDEV, CritSect);
+    GEN_CHECK_OFF(VMMDEV, hypervisorSize);
+    GEN_CHECK_OFF(VMMDEV, mouseCapabilities);
+    GEN_CHECK_OFF(VMMDEV, mouseXAbs);
+    GEN_CHECK_OFF(VMMDEV, mouseYAbs);
+    GEN_CHECK_OFF(VMMDEV, fHostCursorRequested);
+    GEN_CHECK_OFF(VMMDEV, pDevInsR3);
+    GEN_CHECK_OFF(VMMDEV, pDevInsR0);
+    GEN_CHECK_OFF(VMMDEV, pDevInsRC);
+    GEN_CHECK_OFF(VMMDEV, IBase);
+    GEN_CHECK_OFF(VMMDEV, IPort);
+#ifdef VBOX_WITH_HGCM
+    GEN_CHECK_OFF(VMMDEV, IHGCMPort);
+#endif
+    GEN_CHECK_OFF(VMMDEV, pDrvBase);
+    GEN_CHECK_OFF(VMMDEV, pDrv);
+#ifdef VBOX_WITH_HGCM
+    GEN_CHECK_OFF(VMMDEV, pHGCMDrv);
+#endif
+    GEN_CHECK_OFF(VMMDEV, szMsg);
+    GEN_CHECK_OFF(VMMDEV, iMsg);
+    GEN_CHECK_OFF(VMMDEV, irq);
+    GEN_CHECK_OFF(VMMDEV, u32HostEventFlags);
+    GEN_CHECK_OFF(VMMDEV, u32GuestFilterMask);
+    GEN_CHECK_OFF(VMMDEV, u32NewGuestFilterMask);
+    GEN_CHECK_OFF(VMMDEV, fNewGuestFilterMask);
+    GEN_CHECK_OFF(VMMDEV, GCPhysVMMDevRAM);
+    GEN_CHECK_OFF(VMMDEV, pVMMDevRAMR3);
+    GEN_CHECK_OFF(VMMDEV, pVMMDevRAMR0);
+    GEN_CHECK_OFF(VMMDEV, pVMMDevRAMRC);
+    GEN_CHECK_OFF(VMMDEV, pVMMDevHeapR3);
+    GEN_CHECK_OFF(VMMDEV, GCPhysVMMDevHeap);
+    GEN_CHECK_OFF(VMMDEV, guestInfo);
+    GEN_CHECK_OFF(VMMDEV, guestCaps);
+    GEN_CHECK_OFF(VMMDEV, fu32AdditionsOk);
+    GEN_CHECK_OFF(VMMDEV, u32VideoAccelEnabled);
+    GEN_CHECK_OFF(VMMDEV, displayChangeData);
+    GEN_CHECK_OFF(VMMDEV, pCredentials);
+    GEN_CHECK_OFF(VMMDEV, cMbMemoryBalloon);
+    GEN_CHECK_OFF(VMMDEV, cMbMemoryBalloonLast);
+    GEN_CHECK_OFF(VMMDEV, cbGuestRAM);
+    GEN_CHECK_OFF(VMMDEV, idSession);
+    GEN_CHECK_OFF(VMMDEV, u32StatIntervalSize);
+    GEN_CHECK_OFF(VMMDEV, u32LastStatIntervalSize);
+    GEN_CHECK_OFF(VMMDEV, fLastSeamlessEnabled),
+    GEN_CHECK_OFF(VMMDEV, fSeamlessEnabled);
+    GEN_CHECK_OFF(VMMDEV, fVRDPEnabled);
+    GEN_CHECK_OFF(VMMDEV, uVRDPExperienceLevel);
+#ifdef VMMDEV_WITH_ALT_TIMESYNC
+    GEN_CHECK_OFF(VMMDEV, hostTime);
+    GEN_CHECK_OFF(VMMDEV, fTimesyncBackdoorLo);
+#endif
+    GEN_CHECK_OFF(VMMDEV, fGetHostTimeDisabled);
+    GEN_CHECK_OFF(VMMDEV, fBackdoorLogDisabled);
+    GEN_CHECK_OFF(VMMDEV, fKeepCredentials);
+    GEN_CHECK_OFF(VMMDEV, fHeapEnabled);
+#ifdef VBOX_WITH_HGCM
+    GEN_CHECK_OFF(VMMDEV, listHGCMCmd);
+    GEN_CHECK_OFF(VMMDEV, critsectHGCMCmdList);
+    GEN_CHECK_OFF(VMMDEV, u32HGCMEnabled);
+#endif
+    GEN_CHECK_OFF(VMMDEV, SharedFolders);
+    GEN_CHECK_OFF(VMMDEV, SharedFolders.Led);
+    GEN_CHECK_OFF(VMMDEV, SharedFolders.ILeds);
+    GEN_CHECK_OFF(VMMDEV, SharedFolders.pLedsConnector);
+    GEN_CHECK_OFF(VMMDEV, fCpuHotPlugEventsEnabled);
+    GEN_CHECK_OFF(VMMDEV, enmCpuHotPlugEvent);
+    GEN_CHECK_OFF(VMMDEV, idCpuCore);
+    GEN_CHECK_OFF(VMMDEV, idCpuPackage);
+    GEN_CHECK_OFF(VMMDEV, StatMemBalloonChunks);
+    GEN_CHECK_OFF(VMMDEV, fRZEnabled);
+    GEN_CHECK_OFF(VMMDEV, fTestingEnabled);
+    GEN_CHECK_OFF(VMMDEV, fTestingMMIO);
+    GEN_CHECK_OFF(VMMDEV, u32TestingHighTimestamp);
+    GEN_CHECK_OFF(VMMDEV, u32TestingCmd);
+    GEN_CHECK_OFF(VMMDEV, offTestingData);
+    GEN_CHECK_OFF(VMMDEV, TestingData);
+    GEN_CHECK_OFF(VMMDEV, TestingData.Value.u64Value);
+    GEN_CHECK_OFF(VMMDEV, TestingData.Value.u32Unit);
+    GEN_CHECK_OFF(VMMDEV, TestingData.Value.szName);
+    GEN_CHECK_OFF(VMMDEV, nsLastHeartbeatTS);
+    GEN_CHECK_OFF(VMMDEV, fFlatlined);
+    GEN_CHECK_OFF(VMMDEV, fHeartbeatActive);
+    GEN_CHECK_OFF(VMMDEV, cNsHeartbeatInterval);
+    GEN_CHECK_OFF(VMMDEV, cNsHeartbeatTimeout);
+    GEN_CHECK_OFF(VMMDEV, pFlatlinedTimer);
+
+#ifdef VBOX_WITH_BUSLOGIC
+    GEN_CHECK_SIZE(BUSLOGICDEVICE);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, pBusLogicR3);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, pBusLogicR0);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, pBusLogicRC);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, fPresent);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, iLUN);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, IBase);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, IMediaPort);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, IMediaExPort);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, ILed);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, pDrvBase);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, pDrvMedia);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, pDrvMediaEx);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, Led);
+    GEN_CHECK_OFF(BUSLOGICDEVICE, cOutstandingRequests);
+
+    GEN_CHECK_SIZE(BUSLOGIC);
+    GEN_CHECK_OFF(BUSLOGIC, dev);
+    GEN_CHECK_OFF(BUSLOGIC, pDevInsR3);
+    GEN_CHECK_OFF(BUSLOGIC, pDevInsR0);
+    GEN_CHECK_OFF(BUSLOGIC, pDevInsRC);
+    GEN_CHECK_OFF(BUSLOGIC, IOPortBase);
+    GEN_CHECK_OFF(BUSLOGIC, MMIOBase);
+    GEN_CHECK_OFF(BUSLOGIC, regStatus);
+    GEN_CHECK_OFF(BUSLOGIC, regInterrupt);
+    GEN_CHECK_OFF(BUSLOGIC, regGeometry);
+    GEN_CHECK_OFF(BUSLOGIC, LocalRam);
+    GEN_CHECK_OFF(BUSLOGIC, uOperationCode);
+    GEN_CHECK_OFF(BUSLOGIC, aCommandBuffer);
+    GEN_CHECK_OFF(BUSLOGIC, aCommandBuffer[BUSLOGIC_COMMAND_SIZE_MAX]);
+    GEN_CHECK_OFF(BUSLOGIC, iParameter);
+    GEN_CHECK_OFF(BUSLOGIC, cbCommandParametersLeft);
+    GEN_CHECK_OFF(BUSLOGIC, fUseLocalRam);
+    GEN_CHECK_OFF(BUSLOGIC, aReplyBuffer);
+    GEN_CHECK_OFF(BUSLOGIC, aReplyBuffer[BUSLOGIC_REPLY_SIZE_MAX]);
+    GEN_CHECK_OFF(BUSLOGIC, iReply);
+    GEN_CHECK_OFF(BUSLOGIC, cbReplyParametersLeft);
+    GEN_CHECK_OFF(BUSLOGIC, fIRQEnabled);
+    GEN_CHECK_OFF(BUSLOGIC, cMailbox);
+    GEN_CHECK_OFF(BUSLOGIC, GCPhysAddrMailboxOutgoingBase);
+    GEN_CHECK_OFF(BUSLOGIC, uMailboxOutgoingPositionCurrent);
+    GEN_CHECK_OFF(BUSLOGIC, cMailboxesReady);
+    GEN_CHECK_OFF(BUSLOGIC, fNotificationSent);
+    GEN_CHECK_OFF(BUSLOGIC, GCPhysAddrMailboxIncomingBase);
+    GEN_CHECK_OFF(BUSLOGIC, uMailboxIncomingPositionCurrent);
+    GEN_CHECK_OFF(BUSLOGIC, fStrictRoundRobinMode);
+    GEN_CHECK_OFF(BUSLOGIC, fExtendedLunCCBFormat);
+    GEN_CHECK_OFF(BUSLOGIC, pNotifierQueueR3);
+    GEN_CHECK_OFF(BUSLOGIC, pNotifierQueueR0);
+    GEN_CHECK_OFF(BUSLOGIC, pNotifierQueueRC);
+    GEN_CHECK_OFF(BUSLOGIC, CritSectIntr);
+    GEN_CHECK_OFF(BUSLOGIC, aDeviceStates);
+    GEN_CHECK_OFF(BUSLOGIC, aDeviceStates[BUSLOGIC_MAX_DEVICES-1]);
+    GEN_CHECK_OFF(BUSLOGIC, IBase);
+    GEN_CHECK_OFF(BUSLOGIC, ILeds);
+    GEN_CHECK_OFF(BUSLOGIC, pLedsConnector);
+    GEN_CHECK_OFF(BUSLOGIC, pMediaNotify);
+    GEN_CHECK_OFF(BUSLOGIC, fSignalIdle);
+    GEN_CHECK_OFF(BUSLOGIC, fWrkThreadSleeping);
+    GEN_CHECK_OFF(BUSLOGIC, pSupDrvSession);
+    GEN_CHECK_OFF(BUSLOGIC, hEvtProcess);
+    GEN_CHECK_OFF(BUSLOGIC, paGCPhysAddrCCBRedo);
+    GEN_CHECK_OFF(BUSLOGIC, cReqsRedo);
+# ifdef LOG_ENABLED
+    GEN_CHECK_OFF(BUSLOGIC, cInMailboxesReady);
+# endif
+#endif /* VBOX_WITH_BUSLOGIC */
+
+#ifdef VBOX_WITH_LSILOGIC
+    GEN_CHECK_SIZE(LSILOGICSCSI);
+    GEN_CHECK_OFF(LSILOGICSCSI, PciDev);
+    GEN_CHECK_OFF(LSILOGICSCSI, pDevInsR3);
+    GEN_CHECK_OFF(LSILOGICSCSI, pDevInsR0);
+    GEN_CHECK_OFF(LSILOGICSCSI, pDevInsRC);
+    GEN_CHECK_OFF(LSILOGICSCSI, fGCEnabled);
+    GEN_CHECK_OFF(LSILOGICSCSI, fR0Enabled);
+    GEN_CHECK_OFF(LSILOGICSCSI, enmState);
+    GEN_CHECK_OFF(LSILOGICSCSI, enmWhoInit);
+    GEN_CHECK_OFF(LSILOGICSCSI, enmDoorbellState);
+    GEN_CHECK_OFF(LSILOGICSCSI, fDiagnosticEnabled);
+    GEN_CHECK_OFF(LSILOGICSCSI, fNotificationSent);
+    GEN_CHECK_OFF(LSILOGICSCSI, fEventNotificationEnabled);
+    GEN_CHECK_OFF(LSILOGICSCSI, fDiagRegsEnabled);
+    GEN_CHECK_OFF(LSILOGICSCSI, pNotificationQueueR3);
+    GEN_CHECK_OFF(LSILOGICSCSI, pNotificationQueueR0);
+    GEN_CHECK_OFF(LSILOGICSCSI, pNotificationQueueRC);
+    GEN_CHECK_OFF(LSILOGICSCSI, cDeviceStates);
+    GEN_CHECK_OFF(LSILOGICSCSI, paDeviceStates);
+    GEN_CHECK_OFF(LSILOGICSCSI, GCPhysMMIOBase);
+    GEN_CHECK_OFF(LSILOGICSCSI, IOPortBase);
+    GEN_CHECK_OFF(LSILOGICSCSI, uInterruptMask);
+    GEN_CHECK_OFF(LSILOGICSCSI, uInterruptStatus);
+    GEN_CHECK_OFF(LSILOGICSCSI, aMessage);
+    GEN_CHECK_OFF(LSILOGICSCSI, aMessage[sizeof(MptConfigurationRequest)-1]);
+    GEN_CHECK_OFF(LSILOGICSCSI, iMessage);
+    GEN_CHECK_OFF(LSILOGICSCSI, cMessage);
+    GEN_CHECK_OFF(LSILOGICSCSI, ReplyBuffer);
+    GEN_CHECK_OFF(LSILOGICSCSI, uNextReplyEntryRead);
+    GEN_CHECK_OFF(LSILOGICSCSI, cReplySize);
+    GEN_CHECK_OFF(LSILOGICSCSI, u16IOCFaultCode);
+    GEN_CHECK_OFF(LSILOGICSCSI, u32HostMFAHighAddr);
+    GEN_CHECK_OFF(LSILOGICSCSI, u32SenseBufferHighAddr);
+    GEN_CHECK_OFF(LSILOGICSCSI, cMaxDevices);
+    GEN_CHECK_OFF(LSILOGICSCSI, cMaxBuses);
+    GEN_CHECK_OFF(LSILOGICSCSI, cbReplyFrame);
+    GEN_CHECK_OFF(LSILOGICSCSI, iDiagnosticAccess);
+    GEN_CHECK_OFF(LSILOGICSCSI, cReplyQueueEntries);
+    GEN_CHECK_OFF(LSILOGICSCSI, cRequestQueueEntries);
+    GEN_CHECK_OFF(LSILOGICSCSI, ReplyPostQueueCritSect);
+    GEN_CHECK_OFF(LSILOGICSCSI, ReplyFreeQueueCritSect);
+    GEN_CHECK_OFF(LSILOGICSCSI, RequestQueueCritSect);
+    GEN_CHECK_OFF(LSILOGICSCSI, ReplyFreeQueueWriteCritSect);
+    GEN_CHECK_OFF(LSILOGICSCSI, pReplyFreeQueueBaseR3);
+    GEN_CHECK_OFF(LSILOGICSCSI, pReplyPostQueueBaseR3);
+    GEN_CHECK_OFF(LSILOGICSCSI, pRequestQueueBaseR3);
+    GEN_CHECK_OFF(LSILOGICSCSI, pReplyFreeQueueBaseR0);
+    GEN_CHECK_OFF(LSILOGICSCSI, pReplyPostQueueBaseR0);
+    GEN_CHECK_OFF(LSILOGICSCSI, pRequestQueueBaseR0);
+    GEN_CHECK_OFF(LSILOGICSCSI, pReplyFreeQueueBaseRC);
+    GEN_CHECK_OFF(LSILOGICSCSI, pReplyPostQueueBaseRC);
+    GEN_CHECK_OFF(LSILOGICSCSI, pRequestQueueBaseRC);
+    GEN_CHECK_OFF(LSILOGICSCSI, uReplyFreeQueueNextEntryFreeWrite);
+    GEN_CHECK_OFF(LSILOGICSCSI, uReplyFreeQueueNextAddressRead);
+    GEN_CHECK_OFF(LSILOGICSCSI, uReplyPostQueueNextEntryFreeWrite);
+    GEN_CHECK_OFF(LSILOGICSCSI, uReplyPostQueueNextAddressRead);
+    GEN_CHECK_OFF(LSILOGICSCSI, uRequestQueueNextEntryFreeWrite);
+    GEN_CHECK_OFF(LSILOGICSCSI, uRequestQueueNextAddressRead);
+    GEN_CHECK_OFF(LSILOGICSCSI, u16NextHandle);
+    GEN_CHECK_OFF(LSILOGICSCSI, enmCtrlType);
+    GEN_CHECK_OFF(LSILOGICSCSI, IBase);
+    GEN_CHECK_OFF(LSILOGICSCSI, ILeds);
+    GEN_CHECK_OFF(LSILOGICSCSI, pLedsConnector);
+    GEN_CHECK_OFF(LSILOGICSCSI, pMediaNotify);
+    GEN_CHECK_OFF(LSILOGICSCSI, pConfigurationPages);
+    GEN_CHECK_OFF(LSILOGICSCSI, fSignalIdle);
+    GEN_CHECK_OFF(LSILOGICSCSI, fRedo);
+    GEN_CHECK_OFF(LSILOGICSCSI, fWrkThreadSleeping);
+    GEN_CHECK_OFF(LSILOGICSCSI, pTasksRedoHead);
+    GEN_CHECK_OFF(LSILOGICSCSI, u32DiagMemAddr);
+    GEN_CHECK_OFF(LSILOGICSCSI, cbMemRegns);
+    GEN_CHECK_OFF(LSILOGICSCSI, ListMemRegns);
+    GEN_CHECK_OFF(LSILOGICSCSI, pSupDrvSession);
+    GEN_CHECK_OFF(LSILOGICSCSI, pThreadWrk);
+    GEN_CHECK_OFF(LSILOGICSCSI, hEvtProcess);
+#endif /* VBOX_WITH_LSILOGIC */
+
+    GEN_CHECK_SIZE(HPET);
+    GEN_CHECK_OFF(HPET, pDevInsR3);
+    GEN_CHECK_OFF(HPET, pDevInsR0);
+    GEN_CHECK_OFF(HPET, pDevInsRC);
+    GEN_CHECK_OFF(HPET, u64HpetOffset);
+    GEN_CHECK_OFF(HPET, u32Capabilities);
+    GEN_CHECK_OFF(HPET, u32Period);
+    GEN_CHECK_OFF(HPET, u64HpetConfig);
+    GEN_CHECK_OFF(HPET, u64Isr);
+    GEN_CHECK_OFF(HPET, u64HpetCounter);
+    GEN_CHECK_OFF(HPET, CritSect);
+    GEN_CHECK_OFF(HPET, fIch9);
+
+    GEN_CHECK_SIZE(HPETTIMER);
+    GEN_CHECK_OFF(HPETTIMER, pTimerR3);
+    GEN_CHECK_OFF(HPETTIMER, pHpetR3);
+    GEN_CHECK_OFF(HPETTIMER, pTimerR0);
+    GEN_CHECK_OFF(HPETTIMER, pHpetR0);
+    GEN_CHECK_OFF(HPETTIMER, pTimerRC);
+    GEN_CHECK_OFF(HPETTIMER, pHpetRC);
+    GEN_CHECK_OFF(HPETTIMER, idxTimer);
+    GEN_CHECK_OFF(HPETTIMER, u64Config);
+    GEN_CHECK_OFF(HPETTIMER, u64Cmp);
+    GEN_CHECK_OFF(HPETTIMER, u64Fsb);
+    GEN_CHECK_OFF(HPETTIMER, u64Period);
+    GEN_CHECK_OFF(HPETTIMER, u8Wrap);
+
+    GEN_CHECK_SIZE(AC97DRIVER);
+    GEN_CHECK_OFF(AC97DRIVER, Node);
+    GEN_CHECK_OFF(AC97DRIVER, pAC97State);
+    GEN_CHECK_OFF(AC97DRIVER, fFlags);
+    GEN_CHECK_OFF(AC97DRIVER, uLUN);
+    GEN_CHECK_OFF(AC97DRIVER, fAttached);
+    GEN_CHECK_OFF(AC97DRIVER, pConnector);
+    GEN_CHECK_OFF(AC97DRIVER, LineIn);
+    GEN_CHECK_OFF(AC97DRIVER, MicIn);
+    GEN_CHECK_OFF(AC97DRIVER, Out);
+
+    GEN_CHECK_SIZE(AC97STATE);
+    GEN_CHECK_OFF(AC97STATE, CritSect);
+    GEN_CHECK_OFF(AC97STATE, pDevInsR3);
+    GEN_CHECK_OFF(AC97STATE, pDevInsR0);
+    GEN_CHECK_OFF(AC97STATE, pDevInsRC);
+    GEN_CHECK_OFF(AC97STATE, fRZEnabled);
+    GEN_CHECK_OFF(AC97STATE, glob_cnt);
+    GEN_CHECK_OFF(AC97STATE, glob_sta);
+    GEN_CHECK_OFF(AC97STATE, cas);
+    GEN_CHECK_OFF(AC97STATE, last_samp);
+    GEN_CHECK_OFF(AC97STATE, mixer_data);
+    GEN_CHECK_OFF(AC97STATE, aStreams);
+    GEN_CHECK_OFF(AC97STATE, uTimerHz);
+    GEN_CHECK_OFF(AC97STATE, pTimerRC);
+    GEN_CHECK_OFF(AC97STATE, pTimerR3);
+    GEN_CHECK_OFF(AC97STATE, pTimerR0);
+#ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(AC97STATE, StatTimer);
+    GEN_CHECK_OFF(AC97STATE, StatIn);
+    GEN_CHECK_OFF(AC97STATE, StatOut);
+    GEN_CHECK_OFF(AC97STATE, StatBytesRead);
+    GEN_CHECK_OFF(AC97STATE, StatBytesWritten);
+#endif
+    GEN_CHECK_OFF(AC97STATE, lstDrv);
+    GEN_CHECK_OFF(AC97STATE, pMixer);
+    GEN_CHECK_OFF(AC97STATE, pSinkOut);
+    GEN_CHECK_OFF(AC97STATE, pSinkLineIn);
+    GEN_CHECK_OFF(AC97STATE, pSinkMicIn);
+    GEN_CHECK_OFF(AC97STATE, silence);
+    GEN_CHECK_OFF(AC97STATE, bup_flag);
+    GEN_CHECK_OFF(AC97STATE, IBase);
+    GEN_CHECK_OFF(AC97STATE, IOPortBase);
+    GEN_CHECK_OFF(AC97STATE, uCodecModel);
+
+    GEN_CHECK_SIZE(AC97STREAM);
+    GEN_CHECK_OFF(AC97STREAM, pAC97State);
+
+    GEN_CHECK_SIZE(AC97STREAMSTATE);
+    GEN_CHECK_OFF(AC97STREAMSTATE, CritSect);
+    GEN_CHECK_OFF(AC97STREAMSTATE, pCircBuf);
+    GEN_CHECK_OFF(AC97STREAMSTATE, tsTransferLast);
+
+    GEN_CHECK_SIZE(HDADRIVERSTREAM);
+    GEN_CHECK_OFF(HDADRIVERSTREAM, pMixStrm);
+
+    GEN_CHECK_SIZE(HDADRIVER);
+    GEN_CHECK_OFF(HDADRIVER, Node);
+    GEN_CHECK_OFF(HDADRIVER, pHDAState);
+    GEN_CHECK_OFF(HDADRIVER, fFlags);
+    GEN_CHECK_OFF(HDADRIVER, uLUN);
+    GEN_CHECK_OFF(HDADRIVER, fAttached);
+    GEN_CHECK_OFF(HDADRIVER, pConnector);
+    GEN_CHECK_OFF(HDADRIVER, LineIn);
+#ifdef VBOX_WITH_HDA_MIC_IN
+    GEN_CHECK_OFF(HDADRIVER, MicIn);
+#endif
+    GEN_CHECK_OFF(HDADRIVER, Front);
+#ifdef VBOX_WITH_HDA_51_SURROUND
+    GEN_CHECK_OFF(HDADRIVER, CenterLFE);
+    GEN_CHECK_OFF(HDADRIVER, Rear);
+#endif
+
+    GEN_CHECK_SIZE(HDABDLESTATE);
+    GEN_CHECK_OFF(HDABDLESTATE, u32BDLIndex);
+    GEN_CHECK_OFF(HDABDLESTATE, cbBelowFIFOW);
+    GEN_CHECK_OFF(HDABDLESTATE, u32BufOff);
+
+    GEN_CHECK_SIZE(HDABDLEDESC);
+    GEN_CHECK_OFF(HDABDLEDESC, u64BufAddr);
+    GEN_CHECK_OFF(HDABDLEDESC, u32BufSize);
+    GEN_CHECK_OFF(HDABDLEDESC, fFlags);
+
+    GEN_CHECK_SIZE(HDABDLE);
+    GEN_CHECK_OFF(HDABDLE, Desc);
+    GEN_CHECK_OFF(HDABDLE, State);
+
+    GEN_CHECK_SIZE(HDASTREAMMAP);
+
+    GEN_CHECK_SIZE(HDASTREAMSTATE);
+    GEN_CHECK_OFF(HDASTREAMSTATE, uCurBDLE);
+    GEN_CHECK_OFF(HDASTREAMSTATE, fInReset);
+    GEN_CHECK_OFF(HDASTREAMSTATE, Mapping);
+    GEN_CHECK_OFF(HDASTREAMSTATE, BDLE);
+    GEN_CHECK_OFF(HDASTREAMSTATE, pCircBuf);
+
+    GEN_CHECK_SIZE(HDASTREAMDBGINFORT);
+
+    GEN_CHECK_SIZE(HDASTREAMDBGINFO);
+    GEN_CHECK_OFF(HDASTREAMDBGINFO, Runtime);
+
+    GEN_CHECK_SIZE(HDASTREAM);
+    GEN_CHECK_OFF(HDASTREAM, u8SD);
+    GEN_CHECK_OFF(HDASTREAM, u64BDLBase);
+    GEN_CHECK_OFF(HDASTREAM, u16FMT);
+    GEN_CHECK_OFF(HDASTREAM, u16FIFOS);
+    GEN_CHECK_OFF(HDASTREAM, u16LVI);
+    GEN_CHECK_OFF(HDASTREAM, State);
+    GEN_CHECK_OFF(HDASTREAM, Dbg);
+    GEN_CHECK_OFF(HDASTREAM, CritSect);
+
+    GEN_CHECK_SIZE(HDASTATE);
+    GEN_CHECK_OFF(HDASTATE, PciDev);
+    GEN_CHECK_OFF(HDASTATE, pDevInsR3);
+    GEN_CHECK_OFF(HDASTATE, pDevInsR0);
+    GEN_CHECK_OFF(HDASTATE, pDevInsRC);
+    GEN_CHECK_OFF(HDASTATE, IBase);
+    GEN_CHECK_OFF(HDASTATE, MMIOBaseAddr);
+    GEN_CHECK_OFF(HDASTATE, au32Regs[0]);
+    GEN_CHECK_OFF(HDASTATE, au32Regs[HDA_NUM_REGS]);
+    GEN_CHECK_OFF(HDASTATE, aStreams);
+    GEN_CHECK_OFF(HDASTATE, aTags);
+    GEN_CHECK_OFF(HDASTATE, u64CORBBase);
+    GEN_CHECK_OFF(HDASTATE, u64RIRBBase);
+    GEN_CHECK_OFF(HDASTATE, u64DPBase);
+    GEN_CHECK_OFF(HDASTATE, pu32CorbBuf);
+    GEN_CHECK_OFF(HDASTATE, cbCorbBuf);
+    GEN_CHECK_OFF(HDASTATE, pu64RirbBuf);
+    GEN_CHECK_OFF(HDASTATE, cbRirbBuf);
+    GEN_CHECK_OFF(HDASTATE, fRZEnabled);
+#ifdef VBOX_WITH_STATISTICS
+# ifndef VBOX_WITH_AUDIO_CALLBACKS
+    GEN_CHECK_OFF(HDASTATE, StatTimer);
+# endif
+    GEN_CHECK_OFF(HDASTATE, StatBytesRead);
+    GEN_CHECK_OFF(HDASTATE, StatBytesWritten);
+#endif /* VBOX_WITH_STATISTICS */
+    GEN_CHECK_OFF(HDASTATE, pCodec);
+    GEN_CHECK_OFF(HDASTATE, lstDrv);
+    GEN_CHECK_OFF(HDASTATE, pMixer);
+    GEN_CHECK_OFF(HDASTATE, SinkFront);
+#ifdef VBOX_WITH_HDA_51_SURROUND
+    GEN_CHECK_OFF(HDASTATE, SinkCenterLFE);
+    GEN_CHECK_OFF(HDASTATE, SinkRear);
+#endif
+    GEN_CHECK_OFF(HDASTATE, SinkLineIn);
+#ifdef VBOX_WITH_HDA_MIC_IN
+    GEN_CHECK_OFF(HDASTATE, SinkMicIn);
+#endif
+    GEN_CHECK_OFF(HDASTATE, u64WalClk);
+    GEN_CHECK_OFF(HDASTATE, u16RespIntCnt);
+    GEN_CHECK_OFF(HDASTATE, cPosAdjustFrames);
+    GEN_CHECK_OFF(HDASTATE, u8IRQL);
+
+#ifdef VBOX_WITH_NVME_IMPL
+    GEN_CHECK_SIZE(NVMEQUEUEHDR);
+    GEN_CHECK_OFF(NVMEQUEUEHDR, u16Id);
+    GEN_CHECK_OFF(NVMEQUEUEHDR, cEntries);
+    GEN_CHECK_OFF(NVMEQUEUEHDR, enmState);
+    GEN_CHECK_OFF(NVMEQUEUEHDR, GCPhysBase);
+    GEN_CHECK_OFF(NVMEQUEUEHDR, cbEntry);
+    GEN_CHECK_OFF(NVMEQUEUEHDR, idxHead);
+    GEN_CHECK_OFF(NVMEQUEUEHDR, idxTail);
+    GEN_CHECK_OFF(NVMEQUEUEHDR, fPhysCont);
+    GEN_CHECK_OFF(NVMEQUEUEHDR, enmType);
+
+    GEN_CHECK_SIZE(NVMEQUEUESUBM);
+    GEN_CHECK_OFF(NVMEQUEUESUBM, Hdr);
+    GEN_CHECK_OFF(NVMEQUEUESUBM, u16CompletionQueueId);
+    GEN_CHECK_OFF(NVMEQUEUESUBM, enmPriority);
+    GEN_CHECK_OFF(NVMEQUEUESUBM, hEvtProcess);
+    GEN_CHECK_OFF(NVMEQUEUESUBM, pWrkThrdR3);
+    GEN_CHECK_OFF(NVMEQUEUESUBM, NdLstWrkThrdAssgnd);
+    GEN_CHECK_OFF(NVMEQUEUESUBM, cReqsActive);
+
+    GEN_CHECK_SIZE(NVMEQUEUECOMP);
+    GEN_CHECK_OFF(NVMEQUEUECOMP, Hdr);
+    GEN_CHECK_OFF(NVMEQUEUECOMP, fIntrEnabled);
+    GEN_CHECK_OFF(NVMEQUEUECOMP, u32IntrVec);
+    GEN_CHECK_OFF(NVMEQUEUECOMP, cSubmQueuesRef);
+    GEN_CHECK_OFF(NVMEQUEUECOMP, cWaiters);
+    GEN_CHECK_OFF(NVMEQUEUECOMP, LstCompletionsWaiting);
+    GEN_CHECK_OFF(NVMEQUEUECOMP, hMtx);
+
+    GEN_CHECK_SIZE(NVME);
+    GEN_CHECK_OFF(NVME, PciDev);
+    GEN_CHECK_OFF(NVME, pDevInsR3);
+    GEN_CHECK_OFF(NVME, pDevInsR0);
+    GEN_CHECK_OFF(NVME, pDevInsRC);
+    GEN_CHECK_OFF(NVME, IBase);
+    GEN_CHECK_OFF(NVME, ILeds);
+    GEN_CHECK_OFF(NVME, pLedsConnector);
+    GEN_CHECK_OFF(NVME, pSupDrvSession);
+    GEN_CHECK_OFF(NVME, GCPhysMMIO);
+    GEN_CHECK_OFF(NVME, IOPortBase);
+    GEN_CHECK_OFF(NVME, cQueuesSubmMax);
+    GEN_CHECK_OFF(NVME, cQueuesCompMax);
+    GEN_CHECK_OFF(NVME, cQueueEntriesMax);
+    GEN_CHECK_OFF(NVME, cTimeoutMax);
+    GEN_CHECK_OFF(NVME, cWrkThrdsMax);
+    GEN_CHECK_OFF(NVME, cCompQueuesWaitersMax);
+    GEN_CHECK_OFF(NVME, cNamespaces);
+    GEN_CHECK_OFF(NVME, szSerialNumber);
+    GEN_CHECK_OFF(NVME, szModelNumber);
+    GEN_CHECK_OFF(NVME, szFirmwareRevision);
+    GEN_CHECK_OFF(NVME, fRCEnabled);
+    GEN_CHECK_OFF(NVME, fR0Enabled);
+    GEN_CHECK_OFF(NVME, enmState);
+    GEN_CHECK_OFF(NVME, u32IntrMask);
+    GEN_CHECK_OFF(NVME, aIntrVecs);
+    GEN_CHECK_OFF(NVME, u32IoCompletionQueueEntrySize);
+    GEN_CHECK_OFF(NVME, u32IoSubmissionQueueEntrySize);
+    GEN_CHECK_OFF(NVME, uShutdwnNotifierLast);
+    GEN_CHECK_OFF(NVME, uAmsSet);
+    GEN_CHECK_OFF(NVME, uMpsSet);
+    GEN_CHECK_OFF(NVME, uCssSet);
+    GEN_CHECK_OFF(NVME, u32RegIdx);
+    GEN_CHECK_OFF(NVME, cbPage);
+    GEN_CHECK_OFF(NVME, paQueuesSubmR3);
+    GEN_CHECK_OFF(NVME, paQueuesCompR3);
+    GEN_CHECK_OFF(NVME, paQueuesSubmR0);
+    GEN_CHECK_OFF(NVME, paQueuesCompR0);
+    GEN_CHECK_OFF(NVME, paQueuesSubmRC);
+    GEN_CHECK_OFF(NVME, paQueuesCompRC);
+    GEN_CHECK_OFF(NVME, pvCtrlMemBufR3);
+    GEN_CHECK_OFF(NVME, GCPhysCtrlMemBuf);
+    GEN_CHECK_OFF(NVME, cbCtrlMemBuf);
+    GEN_CHECK_OFF(NVME, u32CtrlMemBufSz);
+    GEN_CHECK_OFF(NVME, pWakeQueueR3);
+    GEN_CHECK_OFF(NVME, pWakeQueueR0);
+    GEN_CHECK_OFF(NVME, pWakeQueueRC);
+    GEN_CHECK_OFF(NVME, cAsyncEvtReqsMax);
+    GEN_CHECK_OFF(NVME, CritSectAsyncEvtReqs);
+    GEN_CHECK_OFF(NVME, paAsyncEvtReqCids);
+    GEN_CHECK_OFF(NVME, paNamespaces);
+    GEN_CHECK_OFF(NVME, cWrkThrdsCur);
+    GEN_CHECK_OFF(NVME, cWrkThrdsActive);
+    GEN_CHECK_OFF(NVME, LstWrkThrds);
+    GEN_CHECK_OFF(NVME, CritSectWrkThrds);
+    GEN_CHECK_OFF(NVME, fSignalIdle);
+# ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(NVME, aStatMemXfer[0]);
+    GEN_CHECK_OFF(NVME, aStatMemXfer[NVME_CMBSZ_SUPP_BIT_IDX_MAX]);
+# endif
+#endif
+
+#ifdef VBOX_WITH_IOMMU_AMD
+# ifdef IOMMU_WITH_DTE_CACHE
+    GEN_CHECK_SIZE(DTECACHE);
+# endif
+# ifdef IOMMU_WITH_DTE_CACHE
+    GEN_CHECK_SIZE(IRTECACHE);
+# endif
+    GEN_CHECK_SIZE(IOMMU);
+    GEN_CHECK_OFF(IOMMU, idxIommu);
+    GEN_CHECK_OFF(IOMMU, u32Magic);
+    GEN_CHECK_OFF(IOMMU, hMmio);
+    GEN_CHECK_OFF(IOMMU, hEvtCmdThread);
+    GEN_CHECK_OFF(IOMMU, fCmdThreadSignaled);
+# ifdef IOMMU_WITH_DTE_CACHE
+    GEN_CHECK_OFF(IOMMU, CritSectCache);
+    GEN_CHECK_OFF(IOMMU, aDeviceIds);
+    GEN_CHECK_OFF(IOMMU, aDteCache);
+# endif
+# ifdef IOMMU_WITH_IRTE_CACHE
+    GEN_CHECK_OFF(IOMMU, aIrteCache);
+# endif
+    GEN_CHECK_OFF(IOMMU, IommuBar);
+    GEN_CHECK_OFF(IOMMU, aDevTabBaseAddrs);
+    GEN_CHECK_OFF(IOMMU, CmdBufBaseAddr);
+    GEN_CHECK_OFF(IOMMU, EvtLogBaseAddr);
+    GEN_CHECK_OFF(IOMMU, Ctrl);
+    GEN_CHECK_OFF(IOMMU, ExclRangeBaseAddr);
+    GEN_CHECK_OFF(IOMMU, ExclRangeLimit);
+    GEN_CHECK_OFF(IOMMU, ExtFeat);
+    GEN_CHECK_OFF(IOMMU, PprLogBaseAddr);
+    GEN_CHECK_OFF(IOMMU, HwEvtHi);
+    GEN_CHECK_OFF(IOMMU, HwEvtLo);
+    GEN_CHECK_OFF(IOMMU, HwEvtStatus);
+    GEN_CHECK_OFF(IOMMU, GALogBaseAddr);
+    GEN_CHECK_OFF(IOMMU, GALogTailAddr);
+    GEN_CHECK_OFF(IOMMU, PprLogBBaseAddr);
+    GEN_CHECK_OFF(IOMMU, EvtLogBBaseAddr);
+    GEN_CHECK_OFF(IOMMU, DevSpecificFeat);
+    GEN_CHECK_OFF(IOMMU, DevSpecificCtrl);
+    GEN_CHECK_OFF(IOMMU, DevSpecificStatus);
+    GEN_CHECK_OFF(IOMMU, MiscInfo);
+    GEN_CHECK_OFF(IOMMU, PerfOptCtrl);
+    GEN_CHECK_OFF(IOMMU, XtGenIntrCtrl);
+    GEN_CHECK_OFF(IOMMU, XtPprIntrCtrl);
+    GEN_CHECK_OFF(IOMMU, XtGALogIntrCtrl);
+    GEN_CHECK_OFF(IOMMU, aMarcApers);
+    GEN_CHECK_OFF(IOMMU, RsvdReg);
+    GEN_CHECK_OFF(IOMMU, CmdBufHeadPtr);
+    GEN_CHECK_OFF(IOMMU, CmdBufTailPtr);
+    GEN_CHECK_OFF(IOMMU, EvtLogHeadPtr);
+    GEN_CHECK_OFF(IOMMU, EvtLogTailPtr);
+    GEN_CHECK_OFF(IOMMU, Status);
+    GEN_CHECK_OFF(IOMMU, PprLogHeadPtr);
+    GEN_CHECK_OFF(IOMMU, PprLogTailPtr);
+    GEN_CHECK_OFF(IOMMU, GALogHeadPtr);
+    GEN_CHECK_OFF(IOMMU, GALogTailPtr);
+    GEN_CHECK_OFF(IOMMU, PprLogBHeadPtr);
+    GEN_CHECK_OFF(IOMMU, PprLogBTailPtr);
+    GEN_CHECK_OFF(IOMMU, EvtLogBHeadPtr);
+    GEN_CHECK_OFF(IOMMU, EvtLogBTailPtr);
+    GEN_CHECK_OFF(IOMMU, PprLogAutoResp);
+    GEN_CHECK_OFF(IOMMU, PprLogOverflowEarly);
+    GEN_CHECK_OFF(IOMMU, PprLogBOverflowEarly);
+# ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(IOMMU, StatMmioReadR3);
+    GEN_CHECK_OFF(IOMMU, StatMmioReadRZ);
+    GEN_CHECK_OFF(IOMMU, StatMmioWriteR3);
+    GEN_CHECK_OFF(IOMMU, StatMmioWriteRZ);
+    GEN_CHECK_OFF(IOMMU, StatMsiRemapR3);
+    GEN_CHECK_OFF(IOMMU, StatMsiRemapRZ);
+    GEN_CHECK_OFF(IOMMU, StatMemReadR3);
+    GEN_CHECK_OFF(IOMMU, StatMemReadRZ);
+    GEN_CHECK_OFF(IOMMU, StatMemWriteR3);
+    GEN_CHECK_OFF(IOMMU, StatMemWriteRZ);
+    GEN_CHECK_OFF(IOMMU, StatMemBulkReadR3);
+    GEN_CHECK_OFF(IOMMU, StatMemBulkReadRZ);
+    GEN_CHECK_OFF(IOMMU, StatMemBulkWriteR3);
+    GEN_CHECK_OFF(IOMMU, StatMemBulkWriteRZ);
+    GEN_CHECK_OFF(IOMMU, StatCmd);
+    GEN_CHECK_OFF(IOMMU, StatCmdCompWait);
+    GEN_CHECK_OFF(IOMMU, StatCmdInvDte);
+    GEN_CHECK_OFF(IOMMU, StatCmdInvIommuPages);
+    GEN_CHECK_OFF(IOMMU, StatCmdInvIotlbPages);
+    GEN_CHECK_OFF(IOMMU, StatCmdInvIntrTable);
+    GEN_CHECK_OFF(IOMMU, StatCmdPrefIommuPages);
+    GEN_CHECK_OFF(IOMMU, StatCmdCompletePprReq);
+    GEN_CHECK_OFF(IOMMU, StatCmdInvIommuAll);
+    GEN_CHECK_OFF(IOMMU, StatIotlbeCached);
+    GEN_CHECK_OFF(IOMMU, StatIotlbeLazyEvictReuse);
+    GEN_CHECK_OFF(IOMMU, StatProfDteLookup);
+    GEN_CHECK_OFF(IOMMU, StatProfIotlbeLookup);
+    GEN_CHECK_OFF(IOMMU, StatProfIrteLookup);
+    GEN_CHECK_OFF(IOMMU, StatProfIrteCacheLookup);
+    GEN_CHECK_OFF(IOMMU, StatAccessCacheHit);
+    GEN_CHECK_OFF(IOMMU, StatAccessCacheHitFull);
+    GEN_CHECK_OFF(IOMMU, StatAccessCacheMiss);
+    GEN_CHECK_OFF(IOMMU, StatAccessCacheNonContig);
+    GEN_CHECK_OFF(IOMMU, StatAccessCachePermDenied);
+    GEN_CHECK_OFF(IOMMU, StatAccessDteNonContig);
+    GEN_CHECK_OFF(IOMMU, StatAccessDtePermDenied);
+    GEN_CHECK_OFF(IOMMU, StatIntrCacheHit);
+    GEN_CHECK_OFF(IOMMU, StatIntrCacheMiss);
+# endif
+#endif
+
+#ifdef VBOX_WITH_IOMMU_INTEL
+    GEN_CHECK_SIZE(DMAR);
+    GEN_CHECK_OFF(DMAR, idxIommu);
+    GEN_CHECK_OFF(DMAR, abRegs0);
+    GEN_CHECK_OFF(DMAR, abRegs1);
+    GEN_CHECK_OFF(DMAR, uIrtaReg);
+    GEN_CHECK_OFF(DMAR, uRtaddrReg);
+    GEN_CHECK_OFF(DMAR, uVerReg);
+    GEN_CHECK_OFF(DMAR, fCapReg);
+    GEN_CHECK_OFF(DMAR, fExtCapReg);
+    GEN_CHECK_OFF(DMAR, fHawBaseMask);
+    GEN_CHECK_OFF(DMAR, fMgawInvMask);
+    GEN_CHECK_OFF(DMAR, cMaxPagingLevel);
+    GEN_CHECK_OFF(DMAR, fPermValidMask);
+    GEN_CHECK_OFF(DMAR, hEvtInvQueue);
+    GEN_CHECK_OFF(DMAR, enmDiag);
+    GEN_CHECK_OFF(DMAR, hMmio);
+# ifdef VBOX_WITH_STATISTICS
+    GEN_CHECK_OFF(DMAR, StatMmioReadR3);
+    GEN_CHECK_OFF(DMAR, StatMmioReadRZ);
+    GEN_CHECK_OFF(DMAR, StatMmioWriteR3);
+    GEN_CHECK_OFF(DMAR, StatMmioWriteRZ);
+    GEN_CHECK_OFF(DMAR, StatMsiRemapCfiR3);
+    GEN_CHECK_OFF(DMAR, StatMsiRemapCfiRZ);
+    GEN_CHECK_OFF(DMAR, StatMsiRemapRfiR3);
+    GEN_CHECK_OFF(DMAR, StatMsiRemapRfiRZ);
+    GEN_CHECK_OFF(DMAR, StatMemReadR3);
+    GEN_CHECK_OFF(DMAR, StatMemReadRZ);
+    GEN_CHECK_OFF(DMAR, StatMemWriteR3);
+    GEN_CHECK_OFF(DMAR, StatMemWriteRZ);
+    GEN_CHECK_OFF(DMAR, StatMemBulkReadR3);
+    GEN_CHECK_OFF(DMAR, StatMemBulkReadRZ);
+    GEN_CHECK_OFF(DMAR, StatMemBulkWriteR3);
+    GEN_CHECK_OFF(DMAR, StatMemBulkWriteRZ);
+    GEN_CHECK_OFF(DMAR, StatCcInvDsc);
+    GEN_CHECK_OFF(DMAR, StatIotlbInvDsc);
+    GEN_CHECK_OFF(DMAR, StatDevtlbInvDsc);
+    GEN_CHECK_OFF(DMAR, StatIecInvDsc);
+    GEN_CHECK_OFF(DMAR, StatInvWaitDsc);
+    GEN_CHECK_OFF(DMAR, StatPasidIotlbInvDsc);
+    GEN_CHECK_OFF(DMAR, StatPasidCacheInvDsc);
+    GEN_CHECK_OFF(DMAR, StatPasidDevtlbInvDsc);
+# endif
+
+    GEN_CHECK_SIZE(DMARIOPAGE);
+    GEN_CHECK_OFF(DMARIOPAGE, GCPhysBase);
+    GEN_CHECK_OFF(DMARIOPAGE, cShift);
+    GEN_CHECK_OFF(DMARIOPAGE, fPerm);
+
+    GEN_CHECK_SIZE(DMARIOADDRRANGE);
+    GEN_CHECK_OFF(DMARIOADDRRANGE, uAddr);
+    GEN_CHECK_OFF(DMARIOADDRRANGE, cb);
+    GEN_CHECK_OFF(DMARIOADDRRANGE, fPerm);
+
+    GEN_CHECK_SIZE(DMARMEMREQIN);
+    GEN_CHECK_OFF(DMARMEMREQIN, AddrRange);
+    GEN_CHECK_OFF(DMARMEMREQIN, idDevice);
+    GEN_CHECK_OFF(DMARMEMREQIN, Pasid);
+    GEN_CHECK_OFF(DMARMEMREQIN, enmAddrType);
+    GEN_CHECK_OFF(DMARMEMREQIN, enmReqType);
+
+    GEN_CHECK_SIZE(DMARMEMREQOUT);
+    GEN_CHECK_OFF(DMARMEMREQOUT, AddrRange);
+    GEN_CHECK_OFF(DMARMEMREQOUT, idDomain);
+
+    GEN_CHECK_SIZE(DMARMEMREQAUX);
+    GEN_CHECK_OFF(DMARMEMREQAUX, fTtm
+    GEN_CHECK_OFF(DMARMEMREQAUX, fFpd);
+    GEN_CHECK_OFF(DMARMEMREQAUX, cPagingLevel);
+    GEN_CHECK_OFF(DMARMEMREQAUX, GCPhysFlPt);
+    GEN_CHECK_OFF(DMARMEMREQAUX, GCPhysSlPt);
+
+    GEN_CHECK_SIZE(DMARMEMREQREMAP);
+    GEN_CHECK_OFF(DMARMEMREQREMAP, In);
+    GEN_CHECK_OFF(DMARMEMREQREMAP, Aux);
+    GEN_CHECK_OFF(DMARMEMREQREMAP, Out);
+#endif
+
+    return (0);
+}