Index: /trunk/src/VBox/Devices/Makefile.kmk
===================================================================
--- /trunk/src/VBox/Devices/Makefile.kmk	(revision 82882)
+++ /trunk/src/VBox/Devices/Makefile.kmk	(revision 82883)
@@ -1346,26 +1346,10 @@
  #
  ifdef VBOX_WITH_TESTCASES_TSTDEV
-  DLLS += tstDeviceVBoxVMMStubs
-  tstDeviceVBoxVMMStubs_TEMPLATE      = VBoxR3DllNoPic
-  tstDeviceVBoxVMMStubs_SONAME.linux  = tstDeviceVBoxVMMStubs.so
-  tstDeviceVBoxVMMStubs_SONAME.darwin = tstDeviceVBoxVMMStubs.dylib
-  tstDeviceVBoxVMMStubs_DEFS          = IN_VMM_R3 IN_DIS IN_GMM_R3 IN_DBG $(VMM_COMMON_DEFS)
-  tstDeviceVBoxVMMStubs_LIBS          = $(LIB_RUNTIME)
-
-  tstDeviceVBoxVMMStubs_SOURCES  = \
- 	testcase/tstDeviceVMMStubs.cpp
-
   PROGRAMS += tstDevice
   tstDevice_TEMPLATE    = VBOXR3TSTEXE
   tstDevice_DEFS        += IN_SUP_R3
-  tstDevice_LIBS.linux  = $(PATH_STAGE_BIN)/tstDeviceVBoxVMMStubs.so
-  tstDevice_LIBS.darwin = $(PATH_STAGE_BIN)/tstDeviceVBoxVMMStubs.dylib
-  # Required on OS X to prevent resolving symbols in the real VBoxVMM.dylib when VBoxDD.dylib is loaded
-  tstDevice_LDFLAGS.darwin += -force_flat_namespace
   tstDevice_SOURCES     = \
  	testcase/tstDevice.cpp \
- 	testcase/tstDevicePdmDevHlp.cpp \
- 	testcase/tstDeviceVMM.cpp \
- 	testcase/tstDeviceSUP.cpp
+ 	testcase/tstDevicePdmDevHlp.cpp
  endif
 
Index: /trunk/src/VBox/Devices/testcase/tstDevice.cpp
===================================================================
--- /trunk/src/VBox/Devices/testcase/tstDevice.cpp	(revision 82882)
+++ /trunk/src/VBox/Devices/testcase/tstDevice.cpp	(revision 82883)
@@ -154,5 +154,5 @@
     PCTSTDEVPDMMOD                  pPdmMod;
     /** Device registration structure. */
-    const struct PDMDEVREG          *pReg;
+    const PDMDEVREG                 *pReg;
 } TSTDEVPDMDEV;
 /** Pointer to a PDM device descriptor .*/
@@ -204,6 +204,4 @@
 RTLISTANCHOR g_LstPdmDevs;
 
-extern const TSTDEVVMMCALLBACKS g_tstDevVmmCallbacks;
-
 /**
  * PDM R0 imports we implement.
@@ -211,4 +209,5 @@
 static const TSTDEVPDMR0IMPORTS g_aPdmR0Imports[] =
 {
+#if 0
     {"IOMMMIOMapMMIO2Page",            (PFNRT)IOMMMIOMapMMIO2Page},
     {"IOMMMIOResetRegion",             (PFNRT)IOMMMIOResetRegion},
@@ -255,4 +254,7 @@
     {"nocrt_memset",                   (PFNRT)memset},
     {"nocrt_strlen",                   (PFNRT)strlen},
+#else
+    { NULL, NULL }
+#endif
 };
 
@@ -480,14 +482,4 @@
                     &&  tstDevPdmR3IsValidName(pReg->szName),
                     ("Invalid name '%.*s'\n", sizeof(pReg->szName), pReg->szName),
-                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
-    AssertMsgReturn(   !(pReg->fFlags & PDM_DEVREG_FLAGS_RC)
-                    || (   pReg->szRCMod[0]
-                        && strlen(pReg->szRCMod) < sizeof(pReg->szRCMod)),
-                    ("Invalid GC module name '%s' - (Device %s)\n", pReg->szRCMod, pReg->szName),
-                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
-    AssertMsgReturn(   !(pReg->fFlags & PDM_DEVREG_FLAGS_R0)
-                    || (   pReg->szR0Mod[0]
-                        && strlen(pReg->szR0Mod) < sizeof(pReg->szR0Mod)),
-                    ("Invalid R0 module name '%s' - (Device %s)\n", pReg->szR0Mod, pReg->szName),
                     VERR_PDM_INVALID_DEVICE_REGISTRATION);
     AssertMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_HOST_BITS_MASK) == PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT,
@@ -503,6 +495,6 @@
                     ("Max instances %u! (Device %s)\n", pReg->cMaxInstances, pReg->szName),
                     VERR_PDM_INVALID_DEVICE_REGISTRATION);
-    AssertMsgReturn(pReg->cbInstance <= (uint32_t)(pReg->fFlags & (PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0)  ? 96 * _1K : _1M),
-                    ("Instance size %d bytes! (Device %s)\n", pReg->cbInstance, pReg->szName),
+    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,
@@ -852,5 +844,4 @@
         RTListInit(&Dut.SupSession.LstSupSem);
         CFGMNODE Cfg;
-        Cfg.pVmmCallbacks = &g_tstDevVmmCallbacks;
         Cfg.pDut = &Dut;
 
@@ -858,5 +849,5 @@
         AssertRC(rc);
 
-        PPDMDEVINS pDevIns = (PPDMDEVINS)RTMemAllocZ(RT_UOFFSETOF_DYN(PDMDEVINS, achInstanceData[pPdmDev->pReg->cbInstance]));
+        PPDMDEVINS pDevIns = (PPDMDEVINS)RTMemAllocZ(RT_UOFFSETOF_DYN(PDMDEVINS, achInstanceData[pPdmDev->pReg->cbInstanceCC]));
         pDevIns->u32Version               = PDM_DEVINS_VERSION;
         pDevIns->iInstance                = 0;
@@ -865,5 +856,4 @@
         pDevIns->pHlpR3                   = &g_tstDevPdmDevHlpR3;
         pDevIns->pCfg                     = &Cfg;
-        pDevIns->Internal.s.pVmmCallbacks = &g_tstDevVmmCallbacks;
         pDevIns->Internal.s.pDut          = &Dut;
         rc = pPdmDev->pReg->pfnConstruct(pDevIns, 0, &Cfg);
@@ -872,7 +862,7 @@
             PRTDEVDUTIOPORT pIoPort = RTListGetFirst(&Dut.LstIoPorts, RTDEVDUTIOPORT, NdIoPorts);
             uint32_t uVal = 0;
-            PDMCritSectEnter(pDevIns->pCritSectRoR3, VERR_IGNORED);
+            /*PDMCritSectEnter(pDevIns->pCritSectRoR3, VERR_IGNORED);*/
             pIoPort->pfnInR0(pDevIns, pIoPort->pvUserR0, pIoPort->PortStart, &uVal, sizeof(uint8_t));
-            PDMCritSectLeave(pDevIns->pCritSectRoR3);
+            /*PDMCritSectLeave(pDevIns->pCritSectRoR3);*/
         }
     }
Index: /trunk/src/VBox/Devices/testcase/tstDeviceInternal.h
===================================================================
--- /trunk/src/VBox/Devices/testcase/tstDeviceInternal.h	(revision 82882)
+++ /trunk/src/VBox/Devices/testcase/tstDeviceInternal.h	(revision 82883)
@@ -21,4 +21,5 @@
 #endif
 
+#include <VBox/param.h>
 #include <VBox/types.h>
 #include <iprt/assert.h>
@@ -27,5 +28,4 @@
 
 #include "tstDevicePlugin.h"
-#include "tstDeviceVMMInternal.h"
 
 RT_C_DECLS_BEGIN
@@ -34,4 +34,65 @@
 /** 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;
+
+
+/**
+ * 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;
+
+#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/pdmdev.h>
+#include <VBox/vmm/pdmpci.h>
+#include <VBox/vmm/pdmdrv.h>
+RT_C_DECLS_BEGIN
+
 
 /**
@@ -66,22 +127,22 @@
     void                            *pvUserR3;
     /** Out handler - R3. */
-    PFNIOMIOPORTOUT                 pfnOutR3;
+    PFNIOMIOPORTNEWOUT              pfnOutR3;
     /** In handler - R3. */
-    PFNIOMIOPORTIN                  pfnInR3;
+    PFNIOMIOPORTNEWIN               pfnInR3;
     /** Out string handler - R3. */
-    PFNIOMIOPORTOUTSTRING           pfnOutStrR3;
+    PFNIOMIOPORTNEWOUTSTRING        pfnOutStrR3;
     /** In string handler - R3. */
-    PFNIOMIOPORTINSTRING            pfnInStrR3;
+    PFNIOMIOPORTNEWINSTRING         pfnInStrR3;
 
     /** Opaque user data - R0. */
     void                            *pvUserR0;
     /** Out handler - R0. */
-    PFNIOMIOPORTOUT                 pfnOutR0;
+    PFNIOMIOPORTNEWOUT              pfnOutR0;
     /** In handler - R0. */
-    PFNIOMIOPORTIN                  pfnInR0;
+    PFNIOMIOPORTNEWIN               pfnInR0;
     /** Out string handler - R0. */
-    PFNIOMIOPORTOUTSTRING           pfnOutStrR0;
+    PFNIOMIOPORTNEWOUTSTRING        pfnOutStrR0;
     /** In string handler - R0. */
-    PFNIOMIOPORTINSTRING            pfnInStrR0;
+    PFNIOMIOPORTNEWINSTRING         pfnInStrR0;
 
 #ifdef TSTDEV_SUPPORTS_RC
@@ -89,11 +150,11 @@
     void                            *pvUserRC;
     /** Out handler - RC. */
-    PFNIOMIOPORTOUT                 pfnOutRC;
+    PFNIOMIOPORTNEWOUT              pfnOutRC;
     /** In handler - RC. */
-    PFNIOMIOPORTIN                  pfnInRC;
+    PFNIOMIOPORTNEWIN               pfnInRC;
     /** Out string handler - RC. */
-    PFNIOMIOPORTOUTSTRING           pfnOutStrRC;
+    PFNIOMIOPORTNEWOUTSTRING        pfnOutStrRC;
     /** In string handler - RC. */
-    PFNIOMIOPORTINSTRING            pfnInStrRC;
+    PFNIOMIOPORTNEWINSTRING         pfnInStrRC;
 #endif
 } RTDEVDUTIOPORT;
@@ -204,5 +265,5 @@
     /** The SUP session we emulate. */
     TSTDEVSUPDRVSESSION             SupSession;
-    /** The VM state assoicated with this device. */
+    /** The VM state associated with this device. */
     PVM                             pVm;
     /** The registered PCI device instance if this is a PCI device. */
@@ -213,4 +274,7 @@
 
 
+extern const PDMDEVHLPR3 g_tstDevPdmDevHlpR3;
+
+
 DECLHIDDEN(int) tstDevPdmLdrGetSymbol(PTSTDEVDUTINT pThis, const char *pszMod, TSTDEVPDMMODTYPE enmModType,
                                       const char *pszSymbol, PFNRT *ppfn);
Index: /trunk/src/VBox/Devices/testcase/tstDevicePdmDevHlp.cpp
===================================================================
--- /trunk/src/VBox/Devices/testcase/tstDevicePdmDevHlp.cpp	(revision 82882)
+++ /trunk/src/VBox/Devices/testcase/tstDevicePdmDevHlp.cpp	(revision 82883)
@@ -68,337 +68,240 @@
 
 
-/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegister} */
-static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegister(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, RTHCPTR pvUser, PFNIOMIOPORTOUT pfnOut, PFNIOMIOPORTIN pfnIn,
-                                                    PFNIOMIOPORTOUTSTRING pfnOutStr, PFNIOMIOPORTINSTRING pfnInStr, const char *pszDesc)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p p32_tszDesc=%p:{%s}\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc, pszDesc));
-
-    /** @todo Verify there is no overlapping. */
-
-    RT_NOREF(pszDesc);
-    int rc = VINF_SUCCESS;
-    PRTDEVDUTIOPORT pIoPort = (PRTDEVDUTIOPORT)RTMemAllocZ(sizeof(RTDEVDUTIOPORT));
-    if (RT_LIKELY(pIoPort))
-    {
-        pIoPort->PortStart   = Port;
-        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);
-    }
-    else
-        rc = VERR_NO_MEMORY;
-
-    LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegisterRC} */
-static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterRC(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, RTRCPTR pvUser,
-                                                      const char *pszOut, const char *pszIn,
-                                                      const char *pszOutStr, const char *pszInStr, const char *pszDesc)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
-
-    /** @todo */
-    int rc = VINF_SUCCESS;
-    //AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortRegisterR0} */
-static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterR0(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts, RTR0PTR pvUser,
-                                                      const char *pszOut, const char *pszIn,
-                                                      const char *pszOutStr, const char *pszInStr, const char *pszDesc)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
-
-    PTSTDEVDUTINT pThis = pDevIns->Internal.s.pDut;
-    PRTDEVDUTIOPORT pIoPort;
-    int rc = VERR_NOT_FOUND;
-    RTListForEach(&pThis->LstIoPorts, pIoPort, RTDEVDUTIOPORT, NdIoPorts)
-    {
-        /** @todo Support overlapping port ranges. */
-        if (   pIoPort->PortStart == Port
-            && pIoPort->cPorts == cPorts)
-        {
-            rc = VINF_SUCCESS;
-            pIoPort->pvUserR0 = (void *)pvUser;
-            if (pszOut)
-                rc = tstDevPdmLdrGetSymbol(pThis, pDevIns->pReg->szR0Mod, TSTDEVPDMMODTYPE_R0, pszOut, (PFNRT *)&pIoPort->pfnOutR0);
-            if (RT_SUCCESS(rc) && pszIn)
-                rc = tstDevPdmLdrGetSymbol(pThis, pDevIns->pReg->szR0Mod, TSTDEVPDMMODTYPE_R0, pszIn, (PFNRT *)&pIoPort->pfnInR0);
-            if (RT_SUCCESS(rc) && pszOutStr)
-                rc = tstDevPdmLdrGetSymbol(pThis, pDevIns->pReg->szR0Mod, TSTDEVPDMMODTYPE_R0, pszOutStr, (PFNRT *)&pIoPort->pfnOutStrR0);
-            if (RT_SUCCESS(rc) && pszInStr)
-                rc = tstDevPdmLdrGetSymbol(pThis, pDevIns->pReg->szR0Mod, TSTDEVPDMMODTYPE_R0, pszInStr, (PFNRT *)&pIoPort->pfnInStrR0);
-            break;
-        }
-    }
-
-    LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/** @interface_method_impl{PDMDEVHLPR3,pfnIOPortDeregister} */
-static DECLCALLBACK(int) pdmR3DevHlp_IOPortDeregister(PPDMDEVINS pDevIns, RTIOPORT Port, RTIOPORT cPorts)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: Port=%#x cPorts=%#x\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, Port, cPorts));
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegister} */
-static DECLCALLBACK(int) pdmR3DevHlp_MMIORegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange, RTHCPTR pvUser,
-                                                  PFNIOMMMIOWRITE pfnWrite, PFNIOMMMIOREAD pfnRead, PFNIOMMMIOFILL pfnFill,
-                                                  uint32_t fFlags, const char *pszDesc)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p fFlags=%#x pszDesc=%p:{%s}\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, fFlags, pszDesc));
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegisterRC} */
-static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterRC(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange, RTRCPTR pvUser,
-                                                    const char *pszWrite, const char *pszRead, const char *pszFill)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-/** @interface_method_impl{PDMDEVHLPR3,pfnMMIORegisterR0} */
-static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterR0(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange, RTR0PTR pvUser,
-                                                    const char *pszWrite, const char *pszRead, const char *pszFill)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIORegisterHC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIORegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/** @interface_method_impl{PDMDEVHLPR3,pfnMMIODeregister} */
-static DECLCALLBACK(int) pdmR3DevHlp_MMIODeregister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTGCPHYS cbRange)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%RGp\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange));
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
+/** @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));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_IoPortMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @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));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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));
+
+    uint32_t uAddress = 0;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_IoPortGetMappingAddress: caller='%s'/%d: returns %#RX32\n", pDevIns->pReg->szName, pDevIns->iInstance, uAddress));
+    return uAddress;
+}
+
+
+/** @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));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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 = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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 = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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 = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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));
+
+    RTGCPHYS GCPhys = NIL_RTGCPHYS;
+    AssertFailed();
+
+    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));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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;
+}
 
 /**
- * @copydoc PDMDEVHLPR3::pfnMMIO2Register
+ * @copydoc PDMDEVHLPR3::pfnMmio2ChangeRegionNo
  */
-static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Register(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS cb,
-                                                   uint32_t fFlags, void **ppv, const char *pszDesc)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: pPciDev=%p (%#x) iRegion=%#x cb=%#RGp fFlags=%RX32 ppv=%p pszDescp=%p:{%s}\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion,
-             cb, fFlags, ppv, pszDesc, pszDesc));
-    //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/**
- * @interface_method_impl{PDMDEVHLPR3,pfnMMIOExPreRegister}
- */
-static DECLCALLBACK(int)
-pdmR3DevHlp_MMIOExPreRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS cbRegion, uint32_t fFlags,
-                              const char *pszDesc,
-                              RTHCPTR pvUser, PFNIOMMMIOWRITE pfnWrite, PFNIOMMMIOREAD pfnRead, PFNIOMMMIOFILL pfnFill,
-                              RTR0PTR pvUserR0, const char *pszWriteR0, const char *pszReadR0, const char *pszFillR0,
-                              RTRCPTR pvUserRC, const char *pszWriteRC, const char *pszReadRC, const char *pszFillRC)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIOExPreRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x cbRegion=%#RGp fFlags=%RX32 pszDesc=%p:{%s}\n"
-             "                               pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p\n"
-             "                               pvUserR0=%p pszWriteR0=%s pszReadR0=%s pszFillR0=%s\n"
-             "                               pvUserRC=%p pszWriteRC=%s pszReadRC=%s pszFillRC=%s\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, cbRegion,
-             fFlags, pszDesc, pszDesc,
-             pvUser, pfnWrite, pfnRead, pfnFill,
-             pvUserR0, pszWriteR0, pszReadR0, pszFillR0,
-             pvUserRC, pszWriteRC, pszReadRC, pszFillRC));
-    //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
-
-    /*
-     * Resolve the functions.
-     */
-    AssertLogRelReturn(   (!pszWriteR0 && !pszReadR0 && !pszFillR0)
-                       || (pDevIns->pReg->szR0Mod[0] && (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)),
-                       VERR_INVALID_PARAMETER);
-    AssertLogRelReturn(   (!pszWriteRC && !pszReadRC && !pszFillRC)
-                       || (pDevIns->pReg->szRCMod[0] && (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)),
-                       VERR_INVALID_PARAMETER);
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIOExPreRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/**
- * @copydoc PDMDEVHLPR3::pfnMMIOExDeregister
- */
-static DECLCALLBACK(int) pdmR3DevHlp_MMIOExDeregister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIOExDeregister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion));
-
-    AssertReturn(iRegion <= UINT8_MAX || iRegion == UINT32_MAX, VERR_INVALID_PARAMETER);
-    //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIOExDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/**
- * @copydoc PDMDEVHLPR3::pfnMMIOExMap
- */
-static DECLCALLBACK(int) pdmR3DevHlp_MMIOExMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS GCPhys)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIOExMap: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x GCPhys=%#RGp\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, GCPhys));
-    //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 != NULL, VERR_INVALID_PARAMETER);
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIOExMap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/**
- * @copydoc PDMDEVHLPR3::pfnMMIOExUnmap
- */
-static DECLCALLBACK(int) pdmR3DevHlp_MMIOExUnmap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS GCPhys)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIOExUnmap: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x GCPhys=%#RGp\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, GCPhys));
-    //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 != NULL, VERR_INVALID_PARAMETER);
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIOExUnmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/**
- * @copydoc PDMDEVHLPR3::pfnMMIOExReduce
- */
-static DECLCALLBACK(int) pdmR3DevHlp_MMIOExReduce(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS cbRegion)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIOExReduce: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x cbRegion=%RGp\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, cbRegion));
-    //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 != NULL, VERR_INVALID_PARAMETER);
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIOExReduce: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
-}
-
-
-/**
- * @copydoc PDMDEVHLPR3::pfnMMHyperMapMMIO2
- */
-static DECLCALLBACK(int) pdmR3DevHlp_MMHyperMapMMIO2(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS off,
-                                                     RTGCPHYS cb, const char *pszDesc, PRTRCPTR pRCPtr)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pRCPtr=%p\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
-    //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: returns %Rrc *pRCPtr=%RRv\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *pRCPtr));
-    return rc;
-}
-
-
-/**
- * @copydoc PDMDEVHLPR3::pfnMMIO2MapKernel
- */
-static DECLCALLBACK(int) pdmR3DevHlp_MMIO2MapKernel(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion, RTGCPHYS off,
-                                                    RTGCPHYS cb,const char *pszDesc, PRTR0PTR pR0Ptr)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pR0Ptr=%p\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev ? pPciDev->uDevFn : UINT32_MAX, iRegion, off, cb, pszDesc, pszDesc, pR0Ptr));
-    //AssertReturn(!pPciDev || pPciDev->Int.s.pDevInsR3 == pDevIns, VERR_INVALID_PARAMETER);
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: returns %Rrc *pR0Ptr=%RHv\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *pR0Ptr));
+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;
 }
@@ -436,5 +339,4 @@
 
 
-/** @interface_method_impl{PDMDEVHLPR3,pfnSSMRegister} */
 static DECLCALLBACK(int) pdmR3DevHlp_SSMRegister(PPDMDEVINS pDevIns, uint32_t uVersion, size_t cbGuess, const char *pszBefore,
                                                  PFNSSMDEVLIVEPREP pfnLivePrep, PFNSSMDEVLIVEEXEC pfnLiveExec, PFNSSMDEVLIVEVOTE pfnLiveVote,
@@ -450,7 +352,8 @@
              pfnLoadPrep, pfnLoadExec, pfnLoadDone));
 
-    /** @todo */
-    int rc = VINF_SUCCESS;
-    //AssertFailed();
+    RT_NOREF(uVersion, cbGuess, pszBefore, pfnLivePrep, pfnLiveExec, pfnLiveVote, pfnSavePrep, pfnSaveExec, pfnSaveDone,
+             pfnLoadPrep, pfnLoadExec, pfnLoadDone);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
@@ -459,7 +362,670 @@
 
 
+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;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStruct(PSSMHANDLE pSSM, void *pvStruct, PCSSMFIELD paFields)
+{
+    RT_NOREF(pSSM, pvStruct, paFields);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStructEx(PSSMHANDLE pSSM, 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_SSMGetBool(PSSMHANDLE pSSM, bool *pfBool)
+{
+    RT_NOREF(pSSM, pfBool);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetBoolV(PSSMHANDLE pSSM, bool volatile *pfBool)
+{
+    RT_NOREF(pSSM, pfBool);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8(PSSMHANDLE pSSM, uint8_t *pu8)
+{
+    RT_NOREF(pSSM, pu8);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU8V(PSSMHANDLE pSSM, uint8_t volatile *pu8)
+{
+    RT_NOREF(pSSM, pu8);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8(PSSMHANDLE pSSM, int8_t *pi8)
+{
+    RT_NOREF(pSSM, pi8);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS8V(PSSMHANDLE pSSM, int8_t volatile *pi8)
+{
+    RT_NOREF(pSSM, pi8);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16(PSSMHANDLE pSSM, uint16_t *pu16)
+{
+    RT_NOREF(pSSM, pu16);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU16V(PSSMHANDLE pSSM, uint16_t volatile *pu16)
+{
+    RT_NOREF(pSSM, pu16);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16(PSSMHANDLE pSSM, int16_t *pi16)
+{
+    RT_NOREF(pSSM, pi16);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS16V(PSSMHANDLE pSSM, int16_t volatile *pi16)
+{
+    RT_NOREF(pSSM, pi16);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32(PSSMHANDLE pSSM, uint32_t *pu32)
+{
+    RT_NOREF(pSSM, pu32);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU32V(PSSMHANDLE pSSM, uint32_t volatile *pu32)
+{
+    RT_NOREF(pSSM, pu32);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32(PSSMHANDLE pSSM, int32_t *pi32)
+{
+    RT_NOREF(pSSM, pi32);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS32V(PSSMHANDLE pSSM, int32_t volatile *pi32)
+{
+    RT_NOREF(pSSM, pi32);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64(PSSMHANDLE pSSM, uint64_t *pu64)
+{
+    RT_NOREF(pSSM, pu64);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU64V(PSSMHANDLE pSSM, uint64_t volatile *pu64)
+{
+    RT_NOREF(pSSM, pu64);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64(PSSMHANDLE pSSM, int64_t *pi64)
+{
+    RT_NOREF(pSSM, pi64);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS64V(PSSMHANDLE pSSM, int64_t volatile *pi64)
+{
+    RT_NOREF(pSSM, pi64);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128(PSSMHANDLE pSSM, uint128_t *pu128)
+{
+    RT_NOREF(pSSM, pu128);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetU128V(PSSMHANDLE pSSM, uint128_t volatile *pu128)
+{
+    RT_NOREF(pSSM, pu128);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128(PSSMHANDLE pSSM, int128_t *pi128)
+{
+    RT_NOREF(pSSM, pi128);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetS128V(PSSMHANDLE pSSM, int128_t  volatile *pi128)
+{
+    RT_NOREF(pSSM, pi128);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32(PSSMHANDLE pSSM, PRTGCPHYS32 pGCPhys)
+{
+    RT_NOREF(pSSM, pGCPhys);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys32V(PSSMHANDLE pSSM, RTGCPHYS32 volatile *pGCPhys)
+{
+    RT_NOREF(pSSM, pGCPhys);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64(PSSMHANDLE pSSM, PRTGCPHYS64 pGCPhys)
+{
+    RT_NOREF(pSSM, pGCPhys);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys64V(PSSMHANDLE pSSM, RTGCPHYS64 volatile *pGCPhys)
+{
+    RT_NOREF(pSSM, pGCPhys);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhys(PSSMHANDLE pSSM, PRTGCPHYS pGCPhys)
+{
+    RT_NOREF(pSSM, pGCPhys);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPhysV(PSSMHANDLE pSSM, RTGCPHYS volatile *pGCPhys)
+{
+    RT_NOREF(pSSM, pGCPhys);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetUInt(PSSMHANDLE pSSM, PRTUINT pu)
+{
+    RT_NOREF(pSSM, pu);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSInt(PSSMHANDLE pSSM, PRTINT pi)
+{
+    RT_NOREF(pSSM, pi);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUInt(PSSMHANDLE pSSM, PRTGCUINT pu)
+{
+    RT_NOREF(pSSM, pu);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntReg(PSSMHANDLE pSSM, PRTGCUINTREG pu)
+{
+    RT_NOREF(pSSM, pu);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCPtr(PSSMHANDLE pSSM, PRTGCPTR pGCPtr)
+{
+    RT_NOREF(pSSM, pGCPtr);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetGCUIntPtr(PSSMHANDLE pSSM, PRTGCUINTPTR pGCPtr)
+{
+    RT_NOREF(pSSM, pGCPtr);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetRCPtr(PSSMHANDLE pSSM, PRTRCPTR pRCPtr)
+{
+    RT_NOREF(pSSM, pRCPtr);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetIOPort(PSSMHANDLE pSSM, PRTIOPORT pIOPort)
+{
+    RT_NOREF(pSSM, pIOPort);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetSel(PSSMHANDLE pSSM, PRTSEL pSel)
+{
+    RT_NOREF(pSSM, pSel);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetMem(PSSMHANDLE pSSM, void *pv, size_t cb)
+{
+    RT_NOREF(pSSM, pv, cb);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZ(PSSMHANDLE pSSM, char *psz, size_t cbMax)
+{
+    RT_NOREF(pSSM, psz, cbMax);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMGetStrZEx(PSSMHANDLE pSSM, char *psz, size_t cbMax, size_t *pcbStr)
+{
+    RT_NOREF(pSSM, psz,cbMax, pcbStr);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMSkip(PSSMHANDLE pSSM, size_t cb)
+{
+    RT_NOREF(pSSM, cb);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+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);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+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);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_SSMHandleGetStatus(PSSMHANDLE pSSM)
+{
+    RT_NOREF(pSSM);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+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,pfnTMTimerCreate} */
-static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser,
-                                                   uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
+static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
@@ -467,20 +1033,261 @@
              pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
 
-    int rc = VINF_SUCCESS;
-    PTMTIMERR3 pTimer = (PTMTIMERR3)RTMemAllocZ(sizeof(TMTIMER));
-    if (RT_LIKELY(pTimer))
-    {
-        pTimer->pVmmCallbacks  = pDevIns->Internal.s.pVmmCallbacks;
-        pTimer->enmClock       = enmClock;
-        pTimer->pfnCallbackDev = pfnCallback;
-        pTimer->pvUser         = pvUser;
-        pTimer->fFlags         = fFlags;
-        RTListAppend(&pDevIns->Internal.s.pDut->LstTimers, &pTimer->NdDevTimers);
-        *ppTimer = pTimer;
-    }
-    else
-        rc = VERR_NO_MEMORY;
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+
+/** @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 = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerToPtr} */
+static DECLCALLBACK(PTMTIMERR3) pdmR3DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns);
+    return (PTMTIMERR3)hTimer;
+}
+
+
+/** @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);
+    AssertFailed();
+    return 0;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerGetFreq} */
+static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    RT_NOREF(pDevIns, hTimer);
+    AssertFailed();
+    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);
+    AssertFailed();
+    return false;
+}
+
+
+/** @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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSet} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
+{
+    RT_NOREF(pDevIns, hTimer, uExpire);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetFrequencyHint} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz)
+{
+    RT_NOREF(pDevIns, hTimer, uHz);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetMicro} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
+{
+    RT_NOREF(pDevIns, hTimer, cMicrosToNext);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetMillies} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
+{
+    RT_NOREF(pDevIns, hTimer, cMilliesToNext);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerSetNano} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
+{
+    RT_NOREF(pDevIns, hTimer, cNanosToNext);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnTimerStop} */
+static DECLCALLBACK(int) pdmR3DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
+{
+    RT_NOREF(pDevIns, hTimer);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    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)
+{
+    RT_NOREF(pDevIns, hTimer, pCritSect);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @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, pSSM);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @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;
 }
@@ -494,4 +1301,5 @@
              pDevIns->pReg->szName, pDevIns->iInstance, pTime));
 
+    RT_NOREF(pDevIns, pTime);
     AssertFailed();
 
@@ -501,4 +1309,470 @@
 
 
+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)
+{
+    RT_NOREF(pNode, pszName, pcb);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryInteger(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
+{
+    RT_NOREF(pNode, pszName, pu64);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryIntegerDef(PCFGMNODE pNode, const char *pszName, uint64_t *pu64, uint64_t u64Def)
+{
+    RT_NOREF(pNode, pszName, pu64, u64Def);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryString(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString)
+{
+    RT_NOREF(pNode, pszName, pszString, cchString);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringDef(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString, const char *pszDef)
+{
+    RT_NOREF(pNode, pszName, pszString, cchString, pszDef);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBytes(PCFGMNODE pNode, const char *pszName, void *pvData, size_t cbData)
+{
+    RT_NOREF(pNode, pszName, pvData, cbData);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU64(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
+{
+    RT_NOREF(pNode, pszName, pu64);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU64Def(PCFGMNODE pNode, const char *pszName, uint64_t *pu64, uint64_t u64Def)
+{
+    RT_NOREF(pNode, pszName, pu64, u64Def);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+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)
+{
+    RT_NOREF(pNode, pszName, pu32);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU32Def(PCFGMNODE pNode, const char *pszName, uint32_t *pu32, uint32_t u32Def)
+{
+    RT_NOREF(pNode, pszName, pu32, u32Def);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS32(PCFGMNODE pNode, const char *pszName, int32_t *pi32)
+{
+    RT_NOREF(pNode, pszName, pi32);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryS32Def(PCFGMNODE pNode, const char *pszName, int32_t *pi32, int32_t i32Def)
+{
+    RT_NOREF(pNode, pszName, pi32, i32Def);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU16(PCFGMNODE pNode, const char *pszName, uint16_t *pu16)
+{
+    RT_NOREF(pNode, pszName, pu16);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU16Def(PCFGMNODE pNode, const char *pszName, uint16_t *pu16, uint16_t u16Def)
+{
+    RT_NOREF(pNode, pszName, pu16, u16Def);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+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)
+{
+    RT_NOREF(pNode, pszName, pu8);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryU8Def(PCFGMNODE pNode, const char *pszName, uint8_t *pu8, uint8_t u8Def)
+{
+    RT_NOREF(pNode, pszName, pu8, u8Def);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+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)
+{
+    RT_NOREF(pNode, pszName, pf);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryBoolDef(PCFGMNODE pNode, const char *pszName, bool *pf, bool fDef)
+{
+    RT_NOREF(pNode, pszName, pf, fDef);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+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)
+{
+    RT_NOREF(pNode, pszName, pPort, PortDef);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+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)
+{
+    RT_NOREF(pNode, pszName, ppv);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+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)
+{
+    RT_NOREF(pNode, pszName, ppszString);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_CFGMQueryStringAllocDef(PCFGMNODE pNode, const char *pszName, char **ppszString, const char *pszDef)
+{
+    RT_NOREF(pNode, pszName, ppszString, pszDef);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+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)
+{
+    RT_NOREF(pNode, pszzValid);
+    AssertFailed();
+    return false;
+}
+
+
+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);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
 /** @interface_method_impl{PDMDEVHLPR3,pfnTMTimeVirtGet} */
 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TMTimeVirtGet(PPDMDEVINS pDevIns)
@@ -553,6 +1827,6 @@
              pDevIns->pReg->szName, pDevIns->iInstance));
 
-    PTSTDEVDUTINT pThis = TSTDEV_PDMDEVINS_2_DUT(pDevIns);
-    PSUPDRVSESSION pSession = TSTDEV_PTSTDEVSUPDRVSESSION_2_PSUPDRVSESSION(&pThis->SupSession);
+    PSUPDRVSESSION pSession = NIL_RTR0PTR;
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_GetSupDrvSession: caller='%s'/%d: returns %#p\n", pDevIns->pReg->szName, pDevIns->iInstance, pSession));
@@ -568,5 +1842,10 @@
              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",
@@ -583,9 +1862,9 @@
              pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
 
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
+    VBOXSTRICTRC rcStrict = VERR_NOT_IMPLEMENTED;;
+    AssertFailed();
+
+    Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VBOXSTRICTRC_VAL(rcStrict) ));
+    return VBOXSTRICTRC_VAL(rcStrict);
 }
 
@@ -598,9 +1877,9 @@
              pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
 
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
-    return rc;
+    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);
 }
 
@@ -614,5 +1893,5 @@
     AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
 
-    int rc = VERR_NOT_IMPLEMENTED;
+    int rc = VERR_NOT_IMPLEMENTED;;
     AssertFailed();
 
@@ -630,5 +1909,5 @@
     AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
 
-    int rc = VERR_NOT_IMPLEMENTED;
+    int rc = VERR_NOT_IMPLEMENTED;;
     AssertFailed();
 
@@ -651,4 +1930,54 @@
 
 
+/** @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,pfnPhysReadGCVirt} */
 static DECLCALLBACK(int) pdmR3DevHlp_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
@@ -658,5 +1987,5 @@
              pDevIns->pReg->szName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
 
-    int rc = VERR_NOT_IMPLEMENTED;
+    int rc = VERR_NOT_IMPLEMENTED;;
     AssertFailed();
 
@@ -674,5 +2003,5 @@
              pDevIns->pReg->szName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
 
-    int rc = VERR_NOT_IMPLEMENTED;
+    int rc = VERR_NOT_IMPLEMENTED;;
     AssertFailed();
 
@@ -705,22 +2034,6 @@
     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
 
-    PTSTDEVDUTINT pThis = TSTDEV_PDMDEVINS_2_DUT(pDevIns);
-
     void *pv = NULL;
-    PTSTDEVMMHEAPALLOC pHeapAlloc = (PTSTDEVMMHEAPALLOC)RTMemAllocZ(cb + sizeof(TSTDEVMMHEAPALLOC) - 1);
-    if (pHeapAlloc)
-    {
-        /* Poison */
-        memset(&pHeapAlloc->abAlloc[0], 0xfe, cb);
-        pHeapAlloc->cbAlloc       = cb;
-        pHeapAlloc->pVmmCallbacks = pDevIns->Internal.s.pVmmCallbacks;
-        pHeapAlloc->pDut          = pThis;
-
-        tstDevDutLockExcl(pThis);
-        RTListAppend(&pThis->LstMmHeap, &pHeapAlloc->NdMmHeap);
-        tstDevDutUnlockExcl(pThis);
-
-        pv = &pHeapAlloc->abAlloc[0];
-    }
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
@@ -735,7 +2048,6 @@
     LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
 
-    void *pv = pdmR3DevHlp_MMHeapAlloc(pDevIns, cb);
-    if (VALID_PTR(pv))
-        memset(pv, 0, cb);
+    void *pv = NULL;
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
@@ -747,8 +2059,8 @@
 static DECLCALLBACK(void) pdmR3DevHlp_MMHeapFree(PPDMDEVINS pDevIns, void *pv)
 {
-    PDMDEV_ASSERT_DEVINS(pDevIns);
+    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF_PV(pDevIns);
     LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
 
-    MMR3HeapFree(pv);
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
@@ -788,8 +2100,9 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(rc, pszFile, iLine, pszFunction, pszFormat);
-    rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-    return rc;
+
+    RT_NOREF(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat);
+    AssertFailed();
+
+    return VERR_NOT_IMPLEMENTED;
 }
 
@@ -799,8 +2112,9 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(rc, pszFile, iLine, pszFunction, pszFormat, va);
-    rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-    return rc;
+
+    RT_NOREF(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
+    AssertFailed();
+
+    return VERR_NOT_IMPLEMENTED;
 }
 
@@ -810,7 +2124,9 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(fFlags, pszErrorId, pszFormat);
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
+
+    RT_NOREF(pDevIns, fFlags, pszErrorId, pszFormat);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
     return rc;
 }
@@ -821,7 +2137,9 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(fFlags, pszErrorId, pszFormat, va);
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
+
+    RT_NOREF(pDevIns, fFlags, pszErrorId, pszFormat, va);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
     return rc;
 }
@@ -863,4 +2181,19 @@
 
 
+/** @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));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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)
@@ -882,5 +2215,5 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RTTRACEBUF hTraceBuf = NULL;
+    RTTRACEBUF hTraceBuf = NIL_RTTRACEBUF;
     AssertFailed();
     LogFlow(("pdmR3DevHlp_DBGFTraceBuf: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, hTraceBuf));
@@ -894,16 +2227,6 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(pvSample, enmType, pszName, enmUnit, pszDesc);
-    AssertFailed();
-}
-
-
-
-/** @interface_method_impl{PDMDEVHLPR3,pfnSTAMRegisterF} */
-static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterF(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
-                                                    STAMUNIT enmUnit, const char *pszDesc, const char *pszName, ...)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName);
+
+    RT_NOREF(pDevIns, pvSample, enmType, pszName, enmUnit, pszDesc);
     AssertFailed();
 }
@@ -915,5 +2238,6 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
+
+    RT_NOREF(pDevIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, args);
     AssertFailed();
 }
@@ -923,14 +2247,17 @@
  * @interface_method_impl{PDMDEVHLPR3,pfnPCIRegister}
  */
-static DECLCALLBACK(int) pdmR3DevHlp_PCIRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t idxDevCfg, uint32_t fFlags,
+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} idxDevCfg=%d fFlags=%#x uPciDevNo=%#x uPciFunNo=%#x pszName=%p:{%s}\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->abConfig, idxDevCfg, fFlags, uPciDevNo, uPciFunNo, pszName, pszName ? pszName : ""));
+    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),
@@ -939,7 +2266,4 @@
                           ("'%s'/%d: Vendor ID is not set!\n", pDevIns->pReg->szName, pDevIns->iInstance),
                           VERR_INVALID_POINTER);
-    AssertLogRelMsgReturn(idxDevCfg < 256 || idxDevCfg == PDMPCIDEVREG_CFG_NEXT,
-                          ("'%s'/%d: Invalid config selector: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, idxDevCfg),
-                          VERR_OUT_OF_RANGE);
     AssertLogRelMsgReturn(   uPciDevNo < 32
                           || uPciDevNo == PDMPCIDEVREG_DEV_NO_FIRST_UNUSED
@@ -954,6 +2278,17 @@
                           ("'%s'/%d: Invalid flags: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, fFlags),
                           VERR_INVALID_FLAGS);
-    int rc = VINF_SUCCESS;
-    pDevIns->Internal.s.pDut->pPciDev = pPciDev;
+    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
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
@@ -966,8 +2301,21 @@
 {
     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));
-
-    int rc = VERR_NOT_SUPPORTED; /** @todo */
+    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);
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_PCIRegisterMsi: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
@@ -978,20 +2326,73 @@
 /** @interface_method_impl{PDMDEVHLPR3,pfnPCIIORegionRegister} */
 static DECLCALLBACK(int) pdmR3DevHlp_PCIIORegionRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
-                                                         RTGCPHYS cbRegion, PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: pPciDev=%p:{%#x} iRegion=%d cbRegion=%RGp enmType=%d pfnCallback=%p\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iRegion, cbRegion, enmType, pfnCallback));
-
-    AssertLogRelMsgReturn(iRegion < VBOX_PCI_NUM_REGIONS,
-                          ("Region %u exceeds maximum region index %u\n", iRegion, VBOX_PCI_NUM_REGIONS),
-                          VERR_INVALID_PARAMETER);
-
-    int rc = VINF_SUCCESS;
-    PTSTDEVDUTINT pThis = TSTDEV_PDMDEVINS_2_DUT(pDevIns);
-    PTSTDEVDUTPCIREGION pRegion = &pThis->aPciRegions[iRegion];
-    pRegion->cbRegion     = cbRegion;
-    pRegion->enmType      = enmType;
-    pRegion->pfnRegionMap = pfnCallback;
+                                                         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));
+    PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
+
+    /*
+     * 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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
@@ -1000,33 +2401,89 @@
 
 
-/** @interface_method_impl{PDMDEVHLPR3,pfnPCISetConfigCallbacks} */
-static DECLCALLBACK(void) pdmR3DevHlp_PCISetConfigCallbacks(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, PFNPCICONFIGREAD pfnRead, PPFNPCICONFIGREAD ppfnReadOld,
-                                                            PFNPCICONFIGWRITE pfnWrite, PPFNPCICONFIGWRITE ppfnWriteOld)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: pPciDev=%p pfnRead=%p ppfnReadOld=%p pfnWrite=%p ppfnWriteOld=%p\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld));
-
+/** @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));
+    PDMPCIDEV_ASSERT_VALID_RET(pDevIns, pPciDev);
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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)
+{
+    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
     /*
-     * Validate input and resolve defaults.
+     * Just check the busmaster setting here and forward the request to the generic read helper.
      */
-    AssertPtr(pfnRead);
-    AssertPtr(pfnWrite);
-    AssertPtrNull(ppfnReadOld);
-    AssertPtrNull(ppfnWriteOld);
-    AssertPtrNull(pPciDev);
-
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
-}
-
-
-/** @interface_method_impl{PDMDEVHLPR3,pfnPCIPhysRead} */
-static DECLCALLBACK(int) pdmR3DevHlp_PCIPhysRead(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(pPciDev);
-    return pDevIns->pHlpR3->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead);
+    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
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
 }
 
@@ -1037,6 +2494,27 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(pPciDev);
-    return pDevIns->pHlpR3->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
 }
 
@@ -1046,7 +2524,12 @@
 {
     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);
+
+    RT_NOREF(iIrq, iLevel);
     AssertFailed();
 
@@ -1068,5 +2551,11 @@
     LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
 
-    //AssertFailed();
+    /*
+     * Validate input.
+     */
+    Assert(iIrq < 16);
+    Assert((uint32_t)iLevel <= PDM_IRQ_LEVEL_FLIP_FLOP);
+
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
@@ -1092,4 +2581,5 @@
     Assert(GCPhys != 0);
     Assert(uValue != 0);
+
     AssertFailed();
 
@@ -1105,7 +2595,6 @@
              pDevIns->pReg->szName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
 
-    /** @todo */
-    int rc = VERR_PDM_NO_ATTACHED_DRIVER;
-    //AssertFailed();
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
@@ -1130,17 +2619,376 @@
 
 
+/** @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]);
+        AssertPtrReturn(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,pfnQueueCreatePtr} */
+static DECLCALLBACK(int) pdmR3DevHlp_QueueCreatePtr(PPDMDEVINS pDevIns, size_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
+                                                    PFNPDMQUEUEDEV pfnCallback, bool fRZEnabled, const char *pszName, PPDMQUEUE *ppQueue)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR3DevHlp_QueueCreatePtr: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, ppQueue));
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_QueueCreatePtr: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *ppQueue));
+    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, PPDMQUEUE *ppQueue)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fRZEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fRZEnabled, pszName, pszName, ppQueue));
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *ppQueue));
-    return rc;
+                                                 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,pfnQueueToPtr} */
+static DECLCALLBACK(PPDMQUEUE)  pdmR3DevHlp_QueueToPtr(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    RT_NOREF(pDevIns);
+    return (PPDMQUEUE)hQueue;
+}
+
+
+/** @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,pfnQueueInsertEx} */
+static DECLCALLBACK(void) pdmR3DevHlp_QueueInsertEx(PPDMDEVINS pDevIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem,
+                                                    uint64_t cNanoMaxDelay)
+{
+    RT_NOREF(pDevIns, hQueue, pItem, cNanoMaxDelay);
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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));
+
+    RT_NOREF(pDevIns, phEvent);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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));
+
+    RT_NOREF(pDevIns, hEvent);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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));
+
+    RT_NOREF(pDevIns, hEvent);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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));
+
+    RT_NOREF(pDevIns, hEvent, cMillies);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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));
+
+    RT_NOREF(pDevIns, hEvent, uNsTimeout);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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));
+
+    RT_NOREF(pDevIns, hEvent, cNsTimeout);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    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;
 }
 
@@ -1154,8 +3002,7 @@
              pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
 
-    RT_NOREF(RT_SRC_POS_ARGS, pszNameFmt, pCritSect, va);
-    int rc = RTCritSectInit(&pCritSect->s.CritSect);
-    if (RT_SUCCESS(rc))
-        pCritSect->s.pVmmCallbacks = pDevIns->Internal.s.pVmmCallbacks;
+    RT_NOREF(pDevIns, pCritSect, RT_SRC_POS_ARGS, pszNameFmt, va);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
@@ -1169,6 +3016,6 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
 
-    AssertFailed();
     PPDMCRITSECT pCritSect = NULL;
+    AssertFailed();
 
     LogFlow(("pdmR3DevHlp_CritSectGetNop: caller='%s'/%d: return %p\n",
@@ -1184,6 +3031,4 @@
 
     R0PTRTYPE(PPDMCRITSECT) pCritSect = 0;
-    AssertFailed();
-
     LogFlow(("pdmR3DevHlp_CritSectGetNopR0: caller='%s'/%d: return %RHv\n",
              pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
@@ -1198,6 +3043,4 @@
 
     RCPTRTYPE(PPDMCRITSECT) pCritSect = 0;
-    AssertFailed();
-
     LogFlow(("pdmR3DevHlp_CritSectGetNopRC: caller='%s'/%d: return %RRv\n",
              pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
@@ -1217,16 +3060,157 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     AssertPtrReturn(pCritSect, VERR_INVALID_POINTER);
-    LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: pCritSect=%p\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pCritSect));
-
-    /** @todo Implement default atomatic critical section. */
-    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,pfnThreadCreate} */
+
+#if 0
+    LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: pCritSect=%p (%s)\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pCritSect->s.pszName));
+#endif
+
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+
+    LogFlow(("pdmR3DevHlp_SetDeviceCritSect: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
+}
+
+
+/** @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, pCritSect, rcBusy);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @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, pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @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);
+
+    RT_NOREF(pDevIns, pCritSect);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectIsOwner} */
+static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectIsOwner(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pCritSect);
+    AssertFailed();
+    return false;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR3,pfnCritSectIsInitialized} */
+static DECLCALLBACK(bool)     pdmR3DevHlp_CritSectIsInitialized(PPDMDEVINS pDevIns, PCPDMCRITSECT pCritSect)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    RT_NOREF(pDevIns, pCritSect);
+    AssertFailed();
+    return false;
+}
+
+
+/** @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;
+}
+
+
 static DECLCALLBACK(int) pdmR3DevHlp_ThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
                                                   PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
@@ -1236,4 +3220,5 @@
              pDevIns->pReg->szName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
 
+    RT_NOREF(ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
     int rc = VERR_NOT_IMPLEMENTED;
     AssertFailed();
@@ -1245,4 +3230,58 @@
 
 
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadDestroy(PPDMTHREAD pThread, int *pRcThread)
+{
+    RT_NOREF(pThread, pRcThread);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadIAmSuspending(PPDMTHREAD pThread)
+{
+    RT_NOREF(pThread);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadIamRunning(PPDMTHREAD pThread)
+{
+    RT_NOREF(pThread);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadSleep(PPDMTHREAD pThread, RTMSINTERVAL cMillies)
+{
+    RT_NOREF(pThread, cMillies);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadSuspend(PPDMTHREAD pThread)
+{
+    RT_NOREF(pThread);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
+static DECLCALLBACK(int) pdmR3DevHlp_ThreadResume(PPDMTHREAD pThread)
+{
+    RT_NOREF(pThread);
+    int rc = VERR_NOT_IMPLEMENTED;
+    AssertFailed();
+    return rc;
+}
+
+
 /** @interface_method_impl{PDMDEVHLPR3,pfnSetAsyncNotification} */
 static DECLCALLBACK(int) pdmR3DevHlp_SetAsyncNotification(PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify)
@@ -1252,4 +3291,10 @@
 
     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();
 
@@ -1263,4 +3308,5 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
+
     AssertFailed();
 }
@@ -1275,4 +3321,33 @@
              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();
@@ -1288,6 +3363,7 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-
-    RT_NOREF(uChannel, pfnTransferHandler, pvUser);
+    LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: uChannel=%d pfnTransferHandler=%p pvUser=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
+
     int rc = VERR_NOT_IMPLEMENTED;
     AssertFailed();
@@ -1306,5 +3382,4 @@
              pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
 
-    RT_NOREF(uChannel, pvBuffer, off, cbBlock, pcbRead);
     int rc = VERR_NOT_IMPLEMENTED;
     AssertFailed();
@@ -1323,5 +3398,4 @@
              pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
 
-    RT_NOREF(uChannel, pvBuffer, off, cbBlock, pcbWritten);
     int rc = VERR_NOT_IMPLEMENTED;
     AssertFailed();
@@ -1340,5 +3414,4 @@
              pDevIns->pReg->szName, pDevIns->iInstance, uChannel, uLevel));
 
-    RT_NOREF(uChannel, uLevel);
     int rc = VERR_NOT_IMPLEMENTED;
     AssertFailed();
@@ -1356,5 +3429,5 @@
              pDevIns->pReg->szName, pDevIns->iInstance, uChannel));
 
-    uint8_t u8Mode = 0;
+    uint8_t u8Mode = (3 << 2); /* Invalid mode. */
     AssertFailed();
 
@@ -1411,6 +3484,9 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(pszFile, iLine, pszFunction);
-    AssertFailed();
+
+    char szMsg[100];
+    RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
+    RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
+    AssertBreakpoint();
     return false;
 }
@@ -1421,6 +3497,9 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(pszFile, iLine, pszFunction);
-    AssertFailed();
+
+    char szMsg[100];
+    RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
+    RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
+    AssertBreakpoint();
     return false;
 }
@@ -1481,6 +3560,8 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
+
     VMSUSPENDREASON enmReason = VMSUSPENDREASON_INVALID;
     AssertFailed();
+
     LogFlow(("pdmR3DevHlp_VMGetSuspendReason: caller='%s'/%d: returns %d\n",
              pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
@@ -1493,6 +3574,8 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
+
     VMRESUMEREASON enmReason = VMRESUMEREASON_INVALID;
     AssertFailed();
+
     LogFlow(("pdmR3DevHlp_VMGetResumeReason: caller='%s'/%d: returns %d\n",
              pDevIns->pReg->szName, pDevIns->iInstance, enmReason));
@@ -1505,4 +3588,5 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
+
     AssertFailed();
     LogFlow(("pdmR3DevHlp_GetUVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
@@ -1512,11 +3596,11 @@
 
 /** @interface_method_impl{PDMDEVHLPR3,pfnGetVM} */
-static DECLCALLBACK(PVM) pdmR3DevHlp_GetVM(PPDMDEVINS pDevIns)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    PTSTDEVDUTINT pThis = TSTDEV_PDMDEVINS_2_DUT(pDevIns);
-    PVM pVM = pThis->pVm;
+static DECLCALLBACK(PVMCC) pdmR3DevHlp_GetVM(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+
+    AssertFailed();
     LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
-    return pVM;
+    return NULL;
 }
 
@@ -1526,4 +3610,5 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
+
     AssertFailed();
     LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, NULL));
@@ -1536,6 +3621,8 @@
 {
     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;
@@ -1544,19 +3631,39 @@
 
 /** @interface_method_impl{PDMDEVHLPR3,pfnPCIBusRegister} */
-static DECLCALLBACK(int) pdmR3DevHlp_PCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREG pPciBusReg,
-                                                    PCPDMPCIHLPR3 *ppPciHlpR3, uint32_t *piBus)
+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, "
-             ".pfnSetIrqR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppPciHlpR3=%p piBus=%p\n",
+             ".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->pfnSetIrqR3, pPciBusReg->pszSetIrqRC, pPciBusReg->pszSetIrqRC,
-             pPciBusReg->pszSetIrqR0, pPciBusReg->pszSetIrqR0, ppPciHlpR3, piBus));
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc *piBus=%u\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, rc, *piBus));
+             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;
 }
@@ -1564,15 +3671,26 @@
 
 /** @interface_method_impl{PDMDEVHLPR3,pfnPICRegister} */
-static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLPR3 *ppPicHlpR3)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pfnGetInterruptR3=%p, .pszGetIrqRC=%p:{%s}, .pszGetInterruptRC=%p:{%s}, .pszGetIrqR0=%p:{%s}, .pszGetInterruptR0=%p:{%s} } ppPicHlpR3=%p\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrqR3, pPicReg->pfnGetInterruptR3,
-             pPicReg->pszSetIrqRC, pPicReg->pszSetIrqRC, pPicReg->pszGetInterruptRC, pPicReg->pszGetInterruptRC,
-             pPicReg->pszSetIrqR0, pPicReg->pszSetIrqR0, pPicReg->pszGetInterruptR0, pPicReg->pszGetInterruptR0,
-             ppPicHlpR3));
-
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
+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));
@@ -1581,44 +3699,64 @@
 
 
-/** @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, PCPDMIOAPICHLPR3 *ppIoApicHlpR3)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppIoApicHlpR3=%p\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrqR3,
-             pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqR0, pIoApicReg->pszSetIrqR0, ppIoApicHlpR3));
-
-    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); RT_NOREF_PV(pDevIns);
-    LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
-
-    RT_NOREF(pHpetReg, ppHpetHlpR3);
-    int rc = VERR_NOT_IMPLEMENTED;
-    AssertFailed();
-
-    LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, 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;
 }
@@ -1631,5 +3769,21 @@
     LogFlow(("pdmR3DevHlp_PciRawRegister: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
 
-    RT_NOREF(pPciRawReg, ppPciRawHlpR3);
+    /*
+     * 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();
@@ -1648,5 +3802,41 @@
              pDmacReg->pfnReadMemory, pDmacReg->pfnWriteMemory, pDmacReg->pfnSetDREQ, pDmacReg->pfnGetChannelMode, ppDmacHlp));
 
-    RT_NOREF(pDmacReg, 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();
@@ -1685,5 +3875,30 @@
              pDevIns->pReg->szName, pDevIns->iInstance, pFwReg, pFwReg->u32Version, pFwReg->pfnIsHardReset, pFwReg->u32TheEnd, ppFwHlp));
 
-    RT_NOREF(pFwReg, 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();
@@ -1795,25 +4010,192 @@
 {
     PDM_DEVHLPR3_VERSION,
-    pdmR3DevHlp_IOPortRegister,
-    pdmR3DevHlp_IOPortRegisterRC,
-    pdmR3DevHlp_IOPortRegisterR0,
-    pdmR3DevHlp_IOPortDeregister,
-    pdmR3DevHlp_MMIORegister,
-    pdmR3DevHlp_MMIORegisterRC,
-    pdmR3DevHlp_MMIORegisterR0,
-    pdmR3DevHlp_MMIODeregister,
-    pdmR3DevHlp_MMIO2Register,
-    pdmR3DevHlp_MMIOExPreRegister,
-    pdmR3DevHlp_MMIOExDeregister,
-    pdmR3DevHlp_MMIOExMap,
-    pdmR3DevHlp_MMIOExUnmap,
-    pdmR3DevHlp_MMIOExReduce,
-    pdmR3DevHlp_MMHyperMapMMIO2,
-    pdmR3DevHlp_MMIO2MapKernel,
+    pdmR3DevHlp_IoPortCreateEx,
+    pdmR3DevHlp_IoPortMap,
+    pdmR3DevHlp_IoPortUnmap,
+    pdmR3DevHlp_IoPortGetMappingAddress,
+    pdmR3DevHlp_MmioCreateEx,
+    pdmR3DevHlp_MmioMap,
+    pdmR3DevHlp_MmioUnmap,
+    pdmR3DevHlp_MmioReduce,
+    pdmR3DevHlp_MmioGetMappingAddress,
+    pdmR3DevHlp_Mmio2Create,
+    pdmR3DevHlp_Mmio2Destroy,
+    pdmR3DevHlp_Mmio2Map,
+    pdmR3DevHlp_Mmio2Unmap,
+    pdmR3DevHlp_Mmio2Reduce,
+    pdmR3DevHlp_Mmio2GetMappingAddress,
+    pdmR3DevHlp_Mmio2ChangeRegionNo,
     pdmR3DevHlp_ROMRegister,
     pdmR3DevHlp_ROMProtectShadow,
     pdmR3DevHlp_SSMRegister,
+    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_TMTimerCreate,
+    pdmR3DevHlp_TimerCreate,
+    pdmR3DevHlp_TimerToPtr,
+    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_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,
@@ -1835,13 +4217,15 @@
     pdmR3DevHlp_DBGFStopV,
     pdmR3DevHlp_DBGFInfoRegister,
+    pdmR3DevHlp_DBGFInfoRegisterArgv,
     pdmR3DevHlp_DBGFRegRegister,
     pdmR3DevHlp_DBGFTraceBuf,
     pdmR3DevHlp_STAMRegister,
-    pdmR3DevHlp_STAMRegisterF,
     pdmR3DevHlp_STAMRegisterV,
     pdmR3DevHlp_PCIRegister,
     pdmR3DevHlp_PCIRegisterMsi,
     pdmR3DevHlp_PCIIORegionRegister,
-    pdmR3DevHlp_PCISetConfigCallbacks,
+    pdmR3DevHlp_PCIInterceptConfigAccesses,
+    pdmR3DevHlp_PCIConfigWrite,
+    pdmR3DevHlp_PCIConfigRead,
     pdmR3DevHlp_PCIPhysRead,
     pdmR3DevHlp_PCIPhysWrite,
@@ -1853,5 +4237,29 @@
     pdmR3DevHlp_DriverAttach,
     pdmR3DevHlp_DriverDetach,
+    pdmR3DevHlp_DriverReconfigure,
+    pdmR3DevHlp_QueueCreatePtr,
     pdmR3DevHlp_QueueCreate,
+    pdmR3DevHlp_QueueToPtr,
+    pdmR3DevHlp_QueueAlloc,
+    pdmR3DevHlp_QueueInsert,
+    pdmR3DevHlp_QueueInsertEx,
+    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,
@@ -1859,5 +4267,23 @@
     pdmR3DevHlp_CritSectGetNopRC,
     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_ThreadCreate,
+    pdmR3DevHlp_ThreadDestroy,
+    pdmR3DevHlp_ThreadIAmSuspending,
+    pdmR3DevHlp_ThreadIamRunning,
+    pdmR3DevHlp_ThreadSleep,
+    pdmR3DevHlp_ThreadSuspend,
+    pdmR3DevHlp_ThreadResume,
     pdmR3DevHlp_SetAsyncNotification,
     pdmR3DevHlp_AsyncNotificationCompleted,
@@ -1865,7 +4291,7 @@
     pdmR3DevHlp_PCIBusRegister,
     pdmR3DevHlp_PICRegister,
-    pdmR3DevHlp_APICRegister,
-    pdmR3DevHlp_IOAPICRegister,
-    pdmR3DevHlp_HPETRegister,
+    pdmR3DevHlp_ApicRegister,
+    pdmR3DevHlp_IoApicRegister,
+    pdmR3DevHlp_HpetRegister,
     pdmR3DevHlp_PciRawRegister,
     pdmR3DevHlp_DMACRegister,
@@ -1885,14 +4311,17 @@
     pdmR3DevHlp_VMGetSuspendReason,
     pdmR3DevHlp_VMGetResumeReason,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
+    pdmR3DevHlp_PhysBulkGCPhys2CCPtr,
+    pdmR3DevHlp_PhysBulkGCPhys2CCPtrReadOnly,
+    pdmR3DevHlp_PhysBulkReleasePageMappingLocks,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
     pdmR3DevHlp_GetUVM,
     pdmR3DevHlp_GetVM,
Index: unk/src/VBox/Devices/testcase/tstDeviceSUP.cpp
===================================================================
--- /trunk/src/VBox/Devices/testcase/tstDeviceSUP.cpp	(revision 82882)
+++ 	(revision )
@@ -1,251 +1,0 @@
-/* $Id$ */
-/** @file
- * tstDevice - Test framework for PDM devices/drivers, SUP library exports.
- */
-
-/*
- * Copyright (C) 2017-2019 Oracle Corporation
- *
- * This file is part of VirtualBox Open Source Edition (OSE), as
- * available from http://www.virtualbox.org. This file is free software;
- * you can redistribute it and/or modify it under the terms of the GNU
- * General Public License (GPL) as published by the Free Software
- * Foundation, in version 2 as it comes in the "COPYING" file of the
- * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
- */
-
-
-/*********************************************************************************************************************************
-*   Header Files                                                                                                                 *
-*********************************************************************************************************************************/
-#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
-#include <VBox/sup.h>
-
-#include <iprt/mem.h>
-#include <iprt/semaphore.h>
-
-#include "tstDeviceInternal.h"
-
-
-/*********************************************************************************************************************************
-*   Defined Constants And Macros                                                                                                 *
-*********************************************************************************************************************************/
-
-
-
-/*********************************************************************************************************************************
-*   Structures and Typedefs                                                                                                      *
-*********************************************************************************************************************************/
-
-
-
-/*********************************************************************************************************************************
-*   Global Variables                                                                                                             *
-*********************************************************************************************************************************/
-
-
-
-/*********************************************************************************************************************************
-*   Internal Functions                                                                                                           *
-*********************************************************************************************************************************/
-
-SUPR3DECL(int) SUPR3HardenedLdrLoadAppPriv(const char *pszFilename, PRTLDRMOD phLdrMod, uint32_t fFlags, PRTERRINFO pErrInfo)
-{
-    RT_NOREF(fFlags, pErrInfo);
-    int rc = VINF_SUCCESS;
-
-    if (!RTStrCmp(pszFilename, "VBoxVMM"))
-        rc = RTLdrLoad("tstDeviceVBoxVMMStubs", phLdrMod);
-    else
-    {
-        /* Implement loading of any missing libraries here. */
-        AssertFailed();
-        rc = VERR_NOT_FOUND;
-    }
-
-    return rc;
-}
-
-
-SUPDECL(int) SUPSemEventCreate(PSUPDRVSESSION pSession, PSUPSEMEVENT phEvent)
-{
-    PTSTDEVSUPDRVSESSION pThis = TSTDEV_PSUPDRVSESSION_2_PTSTDEVSUPDRVSESSION(pSession);
-    int rc = VINF_SUCCESS;
-    PTSTDEVSUPSEMEVENT pSupSem = (PTSTDEVSUPSEMEVENT)RTMemAllocZ(sizeof(TSTDEVSUPSEMEVENT));
-
-    if (VALID_PTR(pSupSem))
-    {
-        pSupSem->fMulti = false;
-        rc = RTSemEventCreate(&pSupSem->u.hSemEvt);
-        if (RT_SUCCESS(rc))
-        {
-            RTListAppend(&pThis->LstSupSem, &pSupSem->NdSupSem);
-            *phEvent = TSTDEV_PTSTDEVSUPSEMEVENT_2_SUPSEMEVENT(pSupSem);
-        }
-        else
-            RTMemFree(pSupSem);
-    }
-    else
-        rc = VERR_NO_MEMORY;
-
-    return rc;
-}
-
-SUPDECL(int) SUPSemEventClose(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent)
-{
-    PTSTDEVSUPDRVSESSION pThis = TSTDEV_PSUPDRVSESSION_2_PTSTDEVSUPDRVSESSION(pSession);
-    PTSTDEVSUPSEMEVENT pSupSem = TSTDEV_SUPSEMEVENT_2_PTSTDEVSUPSEMEVENT(hEvent);
-
-    PTSTDEVSUPSEMEVENT pIt;
-    RTListForEach(&pThis->LstSupSem, pIt, TSTDEVSUPSEMEVENT, NdSupSem)
-    {
-        if (pIt == pSupSem)
-        {
-            AssertReturn(!pSupSem->fMulti, VERR_INVALID_HANDLE);
-            RTListNodeRemove(&pSupSem->NdSupSem);
-            RTSemEventDestroy(pSupSem->u.hSemEvt);
-            RTMemFree(pSupSem);
-            return VINF_OBJECT_DESTROYED;
-        }
-    }
-
-    AssertFailed();
-    return VERR_INVALID_HANDLE;
-}
-
-SUPDECL(int) SUPSemEventSignal(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent)
-{
-    RT_NOREF(pSession);
-    PTSTDEVSUPSEMEVENT pSupSem = TSTDEV_SUPSEMEVENT_2_PTSTDEVSUPSEMEVENT(hEvent);
-    AssertReturn(!pSupSem->fMulti, VERR_INVALID_HANDLE);
-
-    return RTSemEventSignal(pSupSem->u.hSemEvt);
-}
-
-SUPDECL(int) SUPSemEventWait(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies)
-{
-    RT_NOREF(pSession);
-    PTSTDEVSUPSEMEVENT pSupSem = TSTDEV_SUPSEMEVENT_2_PTSTDEVSUPSEMEVENT(hEvent);
-    AssertReturn(!pSupSem->fMulti, VERR_INVALID_HANDLE);
-
-    return RTSemEventWait(pSupSem->u.hSemEvt, cMillies);
-}
-
-SUPDECL(int) SUPSemEventWaitNoResume(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint32_t cMillies)
-{
-    RT_NOREF(pSession);
-    PTSTDEVSUPSEMEVENT pSupSem = TSTDEV_SUPSEMEVENT_2_PTSTDEVSUPSEMEVENT(hEvent);
-    AssertReturn(!pSupSem->fMulti, VERR_INVALID_HANDLE);
-
-    return RTSemEventWaitNoResume(pSupSem->u.hSemEvt, cMillies);
-}
-
-SUPDECL(int) SUPSemEventWaitNsAbsIntr(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint64_t uNsTimeout)
-{
-    RT_NOREF(pSession);
-    PTSTDEVSUPSEMEVENT pSupSem = TSTDEV_SUPSEMEVENT_2_PTSTDEVSUPSEMEVENT(hEvent);
-    AssertReturn(!pSupSem->fMulti, VERR_INVALID_HANDLE);
-
-#if 0
-    return RTSemEventWaitEx(pSupSem->u.hSemEvt,
-                            RTSEMWAIT_FLAGS_INTERRUPTIBLE | RTSEMWAIT_FLAGS_ABSOLUTE | RTSEMWAIT_FLAGS_NANOSECS,
-                            uNsTimeout);
-#else
-    RT_NOREF(uNsTimeout);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-#endif
-}
-
-SUPDECL(int) SUPSemEventWaitNsRelIntr(PSUPDRVSESSION pSession, SUPSEMEVENT hEvent, uint64_t cNsTimeout)
-{
-    RT_NOREF(pSession);
-    PTSTDEVSUPSEMEVENT pSupSem = TSTDEV_SUPSEMEVENT_2_PTSTDEVSUPSEMEVENT(hEvent);
-    AssertReturn(!pSupSem->fMulti, VERR_INVALID_HANDLE);
-
-#if 0
-    return RTSemEventWaitEx(pSupSem->u.hSemEvt,
-                            RTSEMWAIT_FLAGS_INTERRUPTIBLE | RTSEMWAIT_FLAGS_RELATIVE | RTSEMWAIT_FLAGS_NANOSECS,
-                            cNsTimeout);
-#else
-    RT_NOREF(cNsTimeout);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-#endif
-}
-
-SUPDECL(uint32_t) SUPSemEventGetResolution(PSUPDRVSESSION pSession)
-{
-    RT_NOREF(pSession);
-#if 0
-    return RTSemEventGetResolution();
-#else
-    AssertFailed();
-    return 0;
-#endif
-}
-
-SUPDECL(int) SUPSemEventMultiCreate(PSUPDRVSESSION pSession, PSUPSEMEVENTMULTI phEventMulti)
-{
-    RT_NOREF(pSession, phEventMulti);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-SUPDECL(int) SUPSemEventMultiClose(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti)
-{
-    RT_NOREF(pSession, hEventMulti);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-SUPDECL(int) SUPSemEventMultiSignal(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti)
-{
-    RT_NOREF(pSession, hEventMulti);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-SUPDECL(int) SUPSemEventMultiReset(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti)
-{
-    RT_NOREF(pSession, hEventMulti);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-SUPDECL(int) SUPSemEventMultiWait(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies)
-{
-    RT_NOREF(pSession, hEventMulti, cMillies);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-SUPDECL(int) SUPSemEventMultiWaitNoResume(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint32_t cMillies)
-{
-    RT_NOREF(pSession, hEventMulti, cMillies);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-SUPDECL(int) SUPSemEventMultiWaitNsAbsIntr(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint64_t uNsTimeout)
-{
-    RT_NOREF(pSession, hEventMulti, uNsTimeout);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-SUPDECL(int) SUPSemEventMultiWaitNsRelIntr(PSUPDRVSESSION pSession, SUPSEMEVENTMULTI hEventMulti, uint64_t cNsTimeout)
-{
-    RT_NOREF(pSession, hEventMulti, cNsTimeout);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-SUPDECL(uint32_t) SUPSemEventMultiGetResolution(PSUPDRVSESSION pSession)
-{
-    RT_NOREF(pSession);
-    AssertFailed();
-    return 0;
-}
-
Index: unk/src/VBox/Devices/testcase/tstDeviceVMM.cpp
===================================================================
--- /trunk/src/VBox/Devices/testcase/tstDeviceVMM.cpp	(revision 82882)
+++ 	(revision )
@@ -1,1108 +1,0 @@
-/* $Id$ */
-/** @file
- * tstDevice - Test framework for PDM devices/drivers, VMM callbacks implementation.
- */
-
-/*
- * Copyright (C) 2017-2019 Oracle Corporation
- *
- * This file is part of VirtualBox Open Source Edition (OSE), as
- * available from http://www.virtualbox.org. This file is free software;
- * you can redistribute it and/or modify it under the terms of the GNU
- * General Public License (GPL) as published by the Free Software
- * Foundation, in version 2 as it comes in the "COPYING" file of the
- * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
- */
-
-
-/*********************************************************************************************************************************
-*   Header Files                                                                                                                 *
-*********************************************************************************************************************************/
-#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
-#include <VBox/types.h>
-#include <VBox/version.h>
-#include <VBox/vmm/pdmpci.h>
-
-#include <iprt/mem.h>
-
-#include "tstDeviceInternal.h"
-
-
-/*********************************************************************************************************************************
-*   Defined Constants And Macros                                                                                                 *
-*********************************************************************************************************************************/
-
-/** Frequency of the real clock. */
-#define TMCLOCK_FREQ_REAL       UINT32_C(1000)
-/** Frequency of the virtual clock. */
-#define TMCLOCK_FREQ_VIRTUAL    UINT32_C(1000000000)
-
-
-/*********************************************************************************************************************************
-*   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   pszName         Name of a byte string value.
- * @param   ppItem          Where to store the pointer to the item.
- */
-static int tstDev_CfgmR3ResolveItem(PCTSTDEVCFGITEM paDevCfg, const char *pszName, PCTSTDEVCFGITEM *ppItem)
-{
-    *ppItem = NULL;
-    if (!paDevCfg)
-        return VERR_CFGM_VALUE_NOT_FOUND;
-
-    size_t          cchName = strlen(pszName);
-    PCTSTDEVCFGITEM pDevCfgItem = paDevCfg;
-    while (pDevCfgItem->pszKey != NULL)
-    {
-        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;
-}
-
-
-static DECLCALLBACK(bool) tstDevVmm_CFGMR3AreValuesValid(PCFGMNODE pNode, const char *pszzValid)
-{
-    if (pNode && pNode->pDut->pTestcaseReg->paDevCfg)
-    {
-        PCTSTDEVCFGITEM pDevCfgItem = pNode->pDut->pTestcaseReg->paDevCfg;
-        while (pDevCfgItem->pszKey != NULL)
-        {
-            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(void) tstDevVmm_CFGMR3Dump(PCFGMNODE pRoot)
-{
-    RT_NOREF(pRoot);
-    AssertFailed();
-}
-
-
-static DECLCALLBACK(PCFGMNODE) tstDevVmm_CFGMR3GetChild(PCFGMNODE pNode, const char *pszPath)
-{
-    RT_NOREF(pNode, pszPath);
-    AssertFailed();
-    return NULL;
-}
-
-
-static DECLCALLBACK(PCFGMNODE) tstDevVmm_CFGMR3GetChildFV(PCFGMNODE pNode, const char *pszPathFormat, va_list Args)
-{
-    RT_NOREF(pNode, pszPathFormat, Args);
-    AssertFailed();
-    return NULL;
-}
-
-
-static DECLCALLBACK(PCFGMNODE) tstDevVmm_CFGMR3GetFirstChild(PCFGMNODE pNode)
-{
-    RT_NOREF(pNode);
-    AssertFailed();
-    return NULL;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_CFGMR3GetName(PCFGMNODE pCur, char *pszName, size_t cchName)
-{
-    RT_NOREF(pCur, pszName, cchName);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(PCFGMNODE) tstDevVmm_CFGMR3GetNextChild(PCFGMNODE pCur)
-{
-    RT_NOREF(pCur);
-    AssertFailed();
-    return NULL;
-}
-
-
-static DECLCALLBACK(PCFGMNODE) tstDevVmm_CFGMR3GetParent(PCFGMNODE pNode)
-{
-    RT_NOREF(pNode);
-    AssertFailed();
-    return NULL;
-}
-
-
-static DECLCALLBACK(PCFGMNODE) tstDevVmm_CFGMR3GetRoot(PVM pVM)
-{
-    RT_NOREF(pVM);
-    AssertFailed();
-    return NULL;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_CFGMR3InsertNode(PCFGMNODE pNode, const char *pszName, PCFGMNODE *ppChild)
-{
-    RT_NOREF(pNode, pszName, ppChild);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_CFGMR3InsertNodeFV(PCFGMNODE pNode, PCFGMNODE *ppChild,
-                                                      const char *pszNameFormat, va_list Args)
-{
-    RT_NOREF(pNode, ppChild, pszNameFormat, Args);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_CFGMR3InsertString(PCFGMNODE pNode, const char *pszName, const char *pszString)
-{
-    RT_NOREF(pNode, pszName, pszString);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_CFGMR3QueryBytes(PCFGMNODE pNode, const char *pszName, void *pvData, size_t cbData)
-{
-    RT_NOREF(pNode, pszName, pvData, cbData);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_CFGMR3QueryInteger(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
-{
-    if (!pNode)
-        return VERR_CFGM_NO_PARENT;
-
-    PCTSTDEVCFGITEM pCfgItem;
-    int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTestcaseReg->paDevCfg, pszName, &pCfgItem);
-    if (RT_SUCCESS(rc))
-    {
-        if (pCfgItem->enmType == TSTDEVCFGITEMTYPE_INTEGER)
-            *pu64 = RTStrToUInt64(pCfgItem->pszVal);
-        else
-            rc = VERR_CFGM_NOT_INTEGER;
-    }
-
-    return rc;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_CFGMR3QuerySize(PCFGMNODE pNode, const char *pszName, size_t *pcb)
-{
-    if (!pNode)
-        return VERR_CFGM_NO_PARENT;
-
-    PCTSTDEVCFGITEM pCfgItem;
-    int rc = tstDev_CfgmR3ResolveItem(pNode->pDut->pTestcaseReg->paDevCfg, pszName, &pCfgItem);
-    if (RT_SUCCESS(rc))
-    {
-        switch (pCfgItem->enmType)
-        {
-            case TSTDEVCFGITEMTYPE_INTEGER:
-                *pcb = sizeof(uint64_t);
-                break;
-
-            case TSTDEVCFGITEMTYPE_STRING:
-                *pcb = strlen(pCfgItem->pszVal) + 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) tstDevVmm_CFGMR3QueryString(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->pTestcaseReg->paDevCfg, pszName, &pCfgItem);
-    if (RT_SUCCESS(rc))
-    {
-        switch (pCfgItem->enmType)
-        {
-            case TSTDEVCFGITEMTYPE_STRING:
-            {
-                size_t cchVal = strlen(pCfgItem->pszVal);
-                if (cchString <= cchVal + 1)
-                    memcpy(pszString, pCfgItem->pszVal, 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) tstDevVmm_CFGMR3QueryStringAlloc(PCFGMNODE pNode, const char *pszName, char **ppszString)
-{
-    RT_NOREF(pNode, pszName, ppszString);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_CFGMR3QueryStringAllocDef(PCFGMNODE pNode, const char *pszName, char **ppszString, const char *pszDef)
-{
-    RT_NOREF(pNode, pszName, ppszString, pszDef);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(void) tstDevVmm_CFGMR3RemoveNode(PCFGMNODE pNode)
-{
-    RT_NOREF(pNode);
-    AssertFailed();
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_CFGMR3ValidateConfig(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);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_IOMIOPortWrite(PVM pVM, PVMCPU pVCpu, RTIOPORT Port, uint32_t u32Value, size_t cbValue)
-{
-    RT_NOREF(pVM, pVCpu, Port, u32Value, cbValue);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_IOMMMIOMapMMIO2Page(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysRemapped, uint64_t fPageFlags)
-{
-    RT_NOREF(pVM, GCPhys, GCPhysRemapped, fPageFlags);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_IOMMMIOResetRegion(PVM pVM, RTGCPHYS GCPhys)
-{
-    RT_NOREF(pVM, GCPhys);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_MMHyperAlloc(PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv)
-{
-    RT_NOREF(pVM, cb, uAlignment, enmTag, ppv);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_MMHyperFree(PVM pVM, void *pv)
-{
-    RT_NOREF(pVM, pv);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(RTR0PTR) tstDevVmm_MMHyperR3ToR0(PVM pVM, RTR3PTR R3Ptr)
-{
-    RT_NOREF(pVM, R3Ptr);
-    AssertFailed();
-    return NIL_RTR0PTR;
-}
-
-
-static DECLCALLBACK(RTRCPTR) tstDevVmm_MMHyperR3ToRC(PVM pVM, RTR3PTR R3Ptr)
-{
-    RT_NOREF(pVM, R3Ptr);
-    AssertFailed();
-    return NIL_RTRCPTR;
-}
-
-
-static DECLCALLBACK(void) tstDevVmm_MMR3HeapFree(void *pv)
-{
-    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);
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_MMR3HyperAllocOnceNoRel(PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv)
-{
-    RT_NOREF(pVM, cb, uAlignment, enmTag, ppv);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(uint64_t) tstDevVmm_MMR3PhysGetRamSize(PVM pVM)
-{
-    RT_NOREF(pVM);
-    AssertFailed();
-    return 0;
-}
-
-
-static DECLCALLBACK(uint64_t) tstDevVmm_MMR3PhysGetRamSizeAbove4GB(PVM pVM)
-{
-    RT_NOREF(pVM);
-    AssertFailed();
-    return 0;
-}
-
-
-static DECLCALLBACK(uint32_t) tstDevVmm_MMR3PhysGetRamSizeBelow4GB(PVM pVM)
-{
-    RT_NOREF(pVM);
-    AssertFailed();
-    return 0;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMCritSectEnterDebug(PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
-{
-    RT_NOREF(rcBusy, uId, RT_SRC_POS_ARGS);
-    return RTCritSectEnter(&pCritSect->s.CritSect);
-}
-
-
-static DECLCALLBACK(bool) tstDevVmm_PDMCritSectIsInitialized(PCPDMCRITSECT pCritSect)
-{
-    RT_NOREF(pCritSect);
-    AssertFailed();
-    return false;
-}
-
-
-static DECLCALLBACK(bool) tstDevVmm_PDMCritSectIsOwner(PCPDMCRITSECT pCritSect)
-{
-    return RTCritSectIsOwner(&pCritSect->s.CritSect);
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMCritSectLeave(PPDMCRITSECT pCritSect)
-{
-    return RTCritSectLeave(&pCritSect->s.CritSect);
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMCritSectTryEnterDebug(PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
-{
-    RT_NOREF(pCritSect, uId, RT_SRC_POS_ARGS);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMHCCritSectScheduleExitEvent(PPDMCRITSECT pCritSect, SUPSEMEVENT hEventToSignal)
-{
-    RT_NOREF(pCritSect, hEventToSignal);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(bool) tstDevVmm_PDMNsAllocateBandwidth(PPDMNSFILTER pFilter, size_t cbTransfer)
-{
-    RT_NOREF(pFilter, cbTransfer);
-    AssertFailed();
-    return false;
-}
-
-
-static DECLCALLBACK(PPDMQUEUEITEMCORE) tstDevVmm_PDMQueueAlloc(PPDMQUEUE pQueue)
-{
-    RT_NOREF(pQueue);
-    AssertFailed();
-    return NULL;
-}
-
-
-static DECLCALLBACK(bool) tstDevVmm_PDMQueueFlushIfNecessary(PPDMQUEUE pQueue)
-{
-    RT_NOREF(pQueue);
-    AssertFailed();
-    return false;
-}
-
-
-static DECLCALLBACK(void) tstDevVmm_PDMQueueInsert(PPDMQUEUE pQueue, PPDMQUEUEITEMCORE pItem)
-{
-    RT_NOREF(pQueue, pItem);
-    AssertFailed();
-}
-
-
-static DECLCALLBACK(R0PTRTYPE(PPDMQUEUE)) tstDevVmm_PDMQueueR0Ptr(PPDMQUEUE pQueue)
-{
-    RT_NOREF(pQueue);
-    AssertFailed();
-    return NIL_RTR0PTR;
-}
-
-
-static DECLCALLBACK(RCPTRTYPE(PPDMQUEUE)) tstDevVmm_PDMQueueRCPtr(PPDMQUEUE pQueue)
-{
-    RT_NOREF(pQueue);
-    AssertFailed();
-    return NIL_RTRCPTR;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3AsyncCompletionEpClose(PPDMASYNCCOMPLETIONENDPOINT pEndpoint)
-{
-    RT_NOREF(pEndpoint);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3AsyncCompletionEpCreateForFile(PPPDMASYNCCOMPLETIONENDPOINT ppEndpoint,
-                                                                       const char *pszFilename, uint32_t fFlags,
-                                                                       PPDMASYNCCOMPLETIONTEMPLATE pTemplate)
-{
-    RT_NOREF(ppEndpoint, pszFilename, fFlags, pTemplate);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3AsyncCompletionEpFlush(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, void *pvUser,
-                                                               PPPDMASYNCCOMPLETIONTASK ppTask)
-{
-    RT_NOREF(pEndpoint, pvUser, ppTask);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3AsyncCompletionEpGetSize(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t *pcbSize)
-{
-    RT_NOREF(pEndpoint, pcbSize);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3AsyncCompletionEpRead(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
-                                                              PCRTSGSEG paSegments, unsigned cSegments,
-                                                              size_t cbRead, void *pvUser,
-                                                              PPPDMASYNCCOMPLETIONTASK ppTask)
-{
-    RT_NOREF(pEndpoint, off, paSegments, cSegments, cbRead, pvUser, ppTask);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3AsyncCompletionEpSetBwMgr(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, const char *pszBwMgr)
-{
-    RT_NOREF(pEndpoint, pszBwMgr);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3AsyncCompletionEpSetSize(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t cbSize)
-{
-    RT_NOREF(pEndpoint, cbSize);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3AsyncCompletionEpWrite(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
-                                                               PCRTSGSEG paSegments, unsigned cSegments,
-                                                               size_t cbWrite, void *pvUser,
-                                                               PPPDMASYNCCOMPLETIONTASK ppTask)
-{
-    RT_NOREF(pEndpoint, off, paSegments, cSegments, cbWrite, pvUser, ppTask);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3AsyncCompletionTemplateDestroy(PPDMASYNCCOMPLETIONTEMPLATE pTemplate)
-{
-    RT_NOREF(pTemplate);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3BlkCacheClear(PPDMBLKCACHE pBlkCache)
-{
-    RT_NOREF(pBlkCache);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3BlkCacheDiscard(PPDMBLKCACHE pBlkCache, PCRTRANGE paRanges,
-                                                        unsigned cRanges, void *pvUser)
-{
-    RT_NOREF(pBlkCache, paRanges, cRanges, pvUser);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3BlkCacheFlush(PPDMBLKCACHE pBlkCache, void *pvUser)
-{
-    RT_NOREF(pBlkCache, pvUser);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3BlkCacheIoXferComplete(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEIOXFER hIoXfer, int rcIoXfer)
-{
-    RT_NOREF(pBlkCache, hIoXfer, rcIoXfer);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3BlkCacheRead(PPDMBLKCACHE pBlkCache, uint64_t off, PCRTSGBUF pSgBuf, size_t cbRead, void *pvUser)
-{
-    RT_NOREF(pBlkCache, off, pSgBuf, cbRead, pvUser);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3BlkCacheRelease(PPDMBLKCACHE pBlkCache)
-{
-    RT_NOREF(pBlkCache);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3BlkCacheResume(PPDMBLKCACHE pBlkCache)
-{
-    RT_NOREF(pBlkCache);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3BlkCacheSuspend(PPDMBLKCACHE pBlkCache)
-{
-    RT_NOREF(pBlkCache);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3BlkCacheWrite(PPDMBLKCACHE pBlkCache, uint64_t off, PCRTSGBUF pSgBuf, size_t cbWrite, void *pvUser)
-{
-    RT_NOREF(pBlkCache, off, pSgBuf, cbWrite, pvUser);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3CritSectDelete(PPDMCRITSECT pCritSect)
-{
-    RT_NOREF(pCritSect);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3QueryLun(PUVM pUVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPPDMIBASE ppBase)
-{
-    RT_NOREF(pUVM, pszDevice, iInstance, iLun, ppBase);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3ThreadDestroy(PPDMTHREAD pThread, int *pRcThread)
-{
-    RT_NOREF(pThread, pRcThread);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3ThreadResume(PPDMTHREAD pThread)
-{
-    RT_NOREF(pThread);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3ThreadSleep(PPDMTHREAD pThread, RTMSINTERVAL cMillies)
-{
-    RT_NOREF(pThread, cMillies);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_PDMR3ThreadSuspend(PPDMTHREAD pThread)
-{
-    RT_NOREF(pThread);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(uint64_t) tstDevVmm_TMCpuTicksPerSecond(PVM pVM)
-{
-    RT_NOREF(pVM);
-    AssertFailed();
-    return 0;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMR3TimerDestroy(PTMTIMER pTimer)
-{
-    RT_NOREF(pTimer);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMR3TimerLoad(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
-{
-    RT_NOREF(pTimer, pSSM);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMR3TimerSave(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
-{
-    RT_NOREF(pTimer, pSSM);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMR3TimerSetCritSect(PTMTIMERR3 pTimer, PPDMCRITSECT pCritSect)
-{
-    RT_NOREF(pTimer, pCritSect);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(uint64_t) tstDevVmm_TMTimerFromMilli(PTMTIMER pTimer, uint64_t cMilliSecs)
-{
-    RT_NOREF(pTimer, cMilliSecs);
-    AssertFailed();
-    return 0;
-}
-
-
-static DECLCALLBACK(uint64_t) tstDevVmm_TMTimerFromNano(PTMTIMER pTimer, uint64_t cNanoSecs)
-{
-    RT_NOREF(pTimer, cNanoSecs);
-    AssertFailed();
-    return 0;
-}
-
-
-static DECLCALLBACK(uint64_t) tstDevVmm_TMTimerGet(PTMTIMER pTimer)
-{
-    RT_NOREF(pTimer);
-    AssertFailed();
-    return 0;
-}
-
-
-static DECLCALLBACK(uint64_t) tstDevVmm_TMTimerGetFreq(PTMTIMER pTimer)
-{
-    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;
-    }
-}
-
-
-static DECLCALLBACK(uint64_t) tstDevVmm_TMTimerGetNano(PTMTIMER pTimer)
-{
-    RT_NOREF(pTimer);
-    AssertFailed();
-    return 0;
-}
-
-
-static DECLCALLBACK(bool) tstDevVmm_TMTimerIsActive(PTMTIMER pTimer)
-{
-    RT_NOREF(pTimer);
-    AssertFailed();
-    return false;
-}
-
-
-static DECLCALLBACK(bool) tstDevVmm_TMTimerIsLockOwner(PTMTIMER pTimer)
-{
-    RT_NOREF(pTimer);
-    AssertFailed();
-    return false;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMTimerLock(PTMTIMER pTimer, int rcBusy)
-{
-    RT_NOREF(pTimer, rcBusy);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(PTMTIMERR0) tstDevVmm_TMTimerR0Ptr(PTMTIMER pTimer)
-{
-    return (PTMTIMERR0)pTimer;
-}
-
-
-static DECLCALLBACK(PTMTIMERRC) tstDevVmm_TMTimerRCPtr(PTMTIMER pTimer)
-{
-    RT_NOREF(pTimer);
-    /* Impossible to implement RC modules at the moment. */
-    return NIL_RTRCPTR;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMTimerSet(PTMTIMER pTimer, uint64_t u64Expire)
-{
-    RT_NOREF(pTimer, u64Expire);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMTimerSetFrequencyHint(PTMTIMER pTimer, uint32_t uHz)
-{
-    RT_NOREF(pTimer, uHz);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMTimerSetMicro(PTMTIMER pTimer, uint64_t cMicrosToNext)
-{
-    RT_NOREF(pTimer, cMicrosToNext);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMTimerSetMillies(PTMTIMER pTimer, uint32_t cMilliesToNext)
-{
-    RT_NOREF(pTimer, cMilliesToNext);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMTimerSetNano(PTMTIMER pTimer, uint64_t cNanosToNext)
-{
-    RT_NOREF(pTimer, cNanosToNext);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_TMTimerStop(PTMTIMER pTimer)
-{
-    RT_NOREF(pTimer);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(void) tstDevVmm_TMTimerUnlock(PTMTIMER pTimer)
-{
-    RT_NOREF(pTimer);
-    AssertFailed();
-}
-
-
-static DECLCALLBACK(PVMCPU) tstDevVmm_VMMGetCpu(PVM pVM)
-{
-    RT_NOREF(pVM);
-    AssertFailed();
-    return NULL;
-}
-
-
-static DECLCALLBACK(VMCPUID) tstDevVmm_VMMGetCpuId(PVM pVM)
-{
-    RT_NOREF(pVM);
-    AssertFailed();
-    return NIL_VMCPUID;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_VMMR3DeregisterPatchMemory(PVM pVM, RTGCPTR pPatchMem, unsigned cbPatchMem)
-{
-    RT_NOREF(pVM, pPatchMem, cbPatchMem);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_VMMR3RegisterPatchMemory(PVM pVM, RTGCPTR pPatchMem, unsigned cbPatchMem)
-{
-    RT_NOREF(pVM, pPatchMem, cbPatchMem);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(RTNATIVETHREAD) tstDevVmm_VMR3GetVMCPUNativeThread(PVM pVM)
-{
-    RT_NOREF(pVM);
-    AssertFailed();
-    return NIL_RTNATIVETHREAD;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_VMR3NotifyCpuDeviceReady(PVM pVM, VMCPUID idCpu)
-{
-    RT_NOREF(pVM, idCpu);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_VMR3ReqCallNoWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
-{
-    RT_NOREF(pVM, idDstCpu, pfnFunction, cArgs);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_VMR3ReqCallVoidNoWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
-{
-    RT_NOREF(pVM, idDstCpu, pfnFunction, cArgs);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_VMR3ReqPriorityCallWait(PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
-{
-    RT_NOREF(pVM, idDstCpu, pfnFunction, cArgs);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) tstDevVmm_VMR3WaitForDeviceReady(PVM pVM, VMCPUID idCpu)
-{
-    RT_NOREF(pVM, idCpu);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-
-const TSTDEVVMMCALLBACKS g_tstDevVmmCallbacks =
-{
-    tstDevVmm_CFGMR3AreValuesValid,
-    tstDevVmm_CFGMR3Dump,
-    tstDevVmm_CFGMR3GetChild,
-    tstDevVmm_CFGMR3GetChildFV,
-    tstDevVmm_CFGMR3GetFirstChild,
-    tstDevVmm_CFGMR3GetName,
-    tstDevVmm_CFGMR3GetNextChild,
-    tstDevVmm_CFGMR3GetParent,
-    tstDevVmm_CFGMR3GetRoot,
-    tstDevVmm_CFGMR3InsertNode,
-    tstDevVmm_CFGMR3InsertNodeFV,
-    tstDevVmm_CFGMR3InsertString,
-    tstDevVmm_CFGMR3QueryBytes,
-    tstDevVmm_CFGMR3QueryInteger,
-    tstDevVmm_CFGMR3QuerySize,
-    tstDevVmm_CFGMR3QueryString,
-    tstDevVmm_CFGMR3QueryStringAlloc,
-    tstDevVmm_CFGMR3QueryStringAllocDef,
-    tstDevVmm_CFGMR3RemoveNode,
-    tstDevVmm_CFGMR3ValidateConfig,
-    tstDevVmm_IOMIOPortWrite,
-    tstDevVmm_IOMMMIOMapMMIO2Page,
-    tstDevVmm_IOMMMIOResetRegion,
-    tstDevVmm_MMHyperAlloc,
-    tstDevVmm_MMHyperFree,
-    tstDevVmm_MMHyperR3ToR0,
-    tstDevVmm_MMHyperR3ToRC,
-    tstDevVmm_MMR3HeapFree,
-    tstDevVmm_MMR3HyperAllocOnceNoRel,
-    tstDevVmm_MMR3PhysGetRamSize,
-    tstDevVmm_MMR3PhysGetRamSizeAbove4GB,
-    tstDevVmm_MMR3PhysGetRamSizeBelow4GB,
-    tstDevVmm_PDMCritSectEnterDebug,
-    tstDevVmm_PDMCritSectIsInitialized,
-    tstDevVmm_PDMCritSectIsOwner,
-    tstDevVmm_PDMCritSectLeave,
-    tstDevVmm_PDMCritSectTryEnterDebug,
-    tstDevVmm_PDMHCCritSectScheduleExitEvent,
-    tstDevVmm_PDMNsAllocateBandwidth,
-    tstDevVmm_PDMQueueAlloc,
-    tstDevVmm_PDMQueueFlushIfNecessary,
-    tstDevVmm_PDMQueueInsert,
-    tstDevVmm_PDMQueueR0Ptr,
-    tstDevVmm_PDMQueueRCPtr,
-    tstDevVmm_PDMR3AsyncCompletionEpClose,
-    tstDevVmm_PDMR3AsyncCompletionEpCreateForFile,
-    tstDevVmm_PDMR3AsyncCompletionEpFlush,
-    tstDevVmm_PDMR3AsyncCompletionEpGetSize,
-    tstDevVmm_PDMR3AsyncCompletionEpRead,
-    tstDevVmm_PDMR3AsyncCompletionEpSetBwMgr,
-    tstDevVmm_PDMR3AsyncCompletionEpSetSize,
-    tstDevVmm_PDMR3AsyncCompletionEpWrite,
-    tstDevVmm_PDMR3AsyncCompletionTemplateDestroy,
-    tstDevVmm_PDMR3BlkCacheClear,
-    tstDevVmm_PDMR3BlkCacheDiscard,
-    tstDevVmm_PDMR3BlkCacheFlush,
-    tstDevVmm_PDMR3BlkCacheIoXferComplete,
-    tstDevVmm_PDMR3BlkCacheRead,
-    tstDevVmm_PDMR3BlkCacheRelease,
-    tstDevVmm_PDMR3BlkCacheResume,
-    tstDevVmm_PDMR3BlkCacheSuspend,
-    tstDevVmm_PDMR3BlkCacheWrite,
-    tstDevVmm_PDMR3CritSectDelete,
-    tstDevVmm_PDMR3QueryLun,
-    tstDevVmm_PDMR3ThreadDestroy,
-    tstDevVmm_PDMR3ThreadResume,
-    tstDevVmm_PDMR3ThreadSleep,
-    tstDevVmm_PDMR3ThreadSuspend,
-    tstDevVmm_TMCpuTicksPerSecond,
-    tstDevVmm_TMR3TimerDestroy,
-    tstDevVmm_TMR3TimerLoad,
-    tstDevVmm_TMR3TimerSave,
-    tstDevVmm_TMR3TimerSetCritSect,
-    tstDevVmm_TMTimerFromMilli,
-    tstDevVmm_TMTimerFromNano,
-    tstDevVmm_TMTimerGet,
-    tstDevVmm_TMTimerGetFreq,
-    tstDevVmm_TMTimerGetNano,
-    tstDevVmm_TMTimerIsActive,
-    tstDevVmm_TMTimerIsLockOwner,
-    tstDevVmm_TMTimerLock,
-    tstDevVmm_TMTimerR0Ptr,
-    tstDevVmm_TMTimerRCPtr,
-    tstDevVmm_TMTimerSet,
-    tstDevVmm_TMTimerSetFrequencyHint,
-    tstDevVmm_TMTimerSetMicro,
-    tstDevVmm_TMTimerSetMillies,
-    tstDevVmm_TMTimerSetNano,
-    tstDevVmm_TMTimerStop,
-    tstDevVmm_TMTimerUnlock,
-    tstDevVmm_VMMGetCpu,
-    tstDevVmm_VMMGetCpuId,
-    tstDevVmm_VMMR3DeregisterPatchMemory,
-    tstDevVmm_VMMR3RegisterPatchMemory,
-    tstDevVmm_VMR3GetVMCPUNativeThread,
-    tstDevVmm_VMR3NotifyCpuDeviceReady,
-    tstDevVmm_VMR3ReqCallNoWait,
-    tstDevVmm_VMR3ReqCallVoidNoWait,
-    tstDevVmm_VMR3ReqPriorityCallWait,
-    tstDevVmm_VMR3WaitForDeviceReady
-};
-
Index: unk/src/VBox/Devices/testcase/tstDeviceVMMInternal.h
===================================================================
--- /trunk/src/VBox/Devices/testcase/tstDeviceVMMInternal.h	(revision 82882)
+++ 	(revision )
@@ -1,364 +1,0 @@
-/* $Id$ */
-/** @file
- * tstDevice - Test framework for PDM devices/drivers, definitions of VMM internal types.
- */
-
-/*
- * Copyright (C) 2017-2019 Oracle Corporation
- *
- * This file is part of VirtualBox Open Source Edition (OSE), as
- * available from http://www.virtualbox.org. This file is free software;
- * you can redistribute it and/or modify it under the terms of the GNU
- * General Public License (GPL) as published by the Free Software
- * Foundation, in version 2 as it comes in the "COPYING" file of the
- * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
- */
-
-#ifndef VBOX_INCLUDED_SRC_testcase_tstDeviceVMMInternal_h
-#define VBOX_INCLUDED_SRC_testcase_tstDeviceVMMInternal_h
-#ifndef RT_WITHOUT_PRAGMA_ONCE
-# pragma once
-#endif
-
-#include <VBox/types.h>
-#include <VBox/vmm/tm.h>
-#include <iprt/critsect.h>
-#include <iprt/list.h>
-
-RT_C_DECLS_BEGIN
-
-/** Pointer to a VMM callback table. */
-typedef struct TSTDEVVMMCALLBACKS *PTSTDEVVMMCALLBACKS;
-/** Pointer to a constant VMM callback table. */
-typedef const struct TSTDEVVMMCALLBACKS *PCTSTDEVVMMCALLBACKS;
-
-/** Pointer to the internal device under test instance. */
-typedef struct TSTDEVDUTINT *PTSTDEVDUTINT;
-/** Pointer to a constant device under test instance. */
-typedef const struct TSTDEVDUTINT *PCTSTDEVDUTINT;
-
-/**
- * Private device instance data.
- */
-typedef struct PDMDEVINSINT
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS            pVmmCallbacks;
-    /** Pointer to the device under test the PDM device instance is for. */
-    PTSTDEVDUTINT                   pDut;
-} PDMDEVINSINT;
-AssertCompile(sizeof(PDMDEVINSINT) <= (HC_ARCH_BITS == 32 ? 72 : 112 + 0x28));
-
-/**
- * CFGM node structure.
- */
-typedef struct CFGMNODE
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS pVmmCallbacks;
-    /** Device under test this CFGM node is for. */
-    PTSTDEVDUTINT        pDut;
-    /** @todo: */
-} CFGMNODE;
-
-/**
- * PDM queue structure.
- */
-typedef struct PDMQUEUE
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS pVmmCallbacks;
-    /** @todo: */
-} PDMQUEUE;
-
-/**
- * TM timer structure.
- */
-typedef struct TMTIMER
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS pVmmCallbacks;
-    /** 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;
-    /** @todo: */
-} TMTIMER;
-
-/**
- * Internal VMM structure of VMCPU
- */
-typedef struct VMMCPU
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS pVmmCallbacks;
-    /** @todo: */
-} VMMCPU;
-AssertCompile(sizeof(VMMCPU) <= 704);
-
-/**
- * Internal VMM structure of VM
- */
-typedef struct VMM
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS pVmmCallbacks;
-    /** @todo: */
-} VMM;
-AssertCompile(sizeof(VMM) <= 1600);
-
-/**
- * Internal VM structure of VM
- */
-typedef struct VMINT
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS pVmmCallbacks;
-    /** @todo: */
-} VMINT;
-AssertCompile(sizeof(VMINT) <= 24);
-
-/**
- * Internal per vCPU user VM structure.
- */
-typedef struct VMINTUSERPERVMCPU
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS pVmmCallbacks;
-    /** @todo: */
-} VMINTUSERPERVMCPU;
-AssertCompile(sizeof(VMINTUSERPERVMCPU) <= 512);
-
-/**
- * Internal user VM structure.
- */
-typedef struct VMINTUSERPERVM
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS pVmmCallbacks;
-    /** @todo: */
-} VMINTUSERPERVM;
-AssertCompile(sizeof(VMINTUSERPERVM) <= 512);
-
-/**
- * Internal PDM critical section structure.
- */
-typedef struct PDMCRITSECTINT
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS pVmmCallbacks;
-    /** The actual critical section used for emulation. */
-    RTCRITSECT           CritSect;
-} PDMCRITSECTINT;
-AssertCompile(sizeof(PDMCRITSECTINT) <= (HC_ARCH_BITS == 32 ? 0x80 : 0xc0));
-
-/**
- * Internal PDM thread instance data.
- */
-typedef struct PDMTHREADINT
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS            pVmmCallbacks;
-    /** Pointer to the device under test. */
-    PTSTDEVDUTINT                   pDut;
-    /** Node for the list of PDM threads. */
-    RTLISTNODE                      NdPdmThreads;
-} PDMTHREADINT;
-AssertCompile(sizeof(PDMTHREADINT) <= 64);
-
-/**
- * MM Heap allocation.
- */
-typedef struct TSTDEVMMHEAPALLOC
-{
-    /** Node for the list of allocations. */
-    RTLISTNODE                      NdMmHeap;
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS            pVmmCallbacks;
-    /** Pointer to the device under test the allocation was made for. */
-    PTSTDEVDUTINT                   pDut;
-    /** Size of the allocation. */
-    size_t                          cbAlloc;
-    /** Align the next member on a 16byte boundary. */
-    size_t                          uAlignment0;
-    /** Start of the real allocation. */
-    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);
-
-#if 0
-/**
- * Internal PDM netshaper filter instance data.
- */
-typedef struct PDMNSFILTER
-{
-    /** Pointer to the callback table. */
-    PCTSTDEVVMMCALLBACKS pVmmCallbacks;
-    /** @todo: */
-} PDMNSFILTER;
-#endif
-
-#define PDMCRITSECTINT_DECLARED
-#define PDMTHREADINT_DECLARED
-#define PDMDEVINSINT_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/vm.h>
-#include <VBox/vmm/uvm.h>
-#include <VBox/vmm/cfgm.h>
-#include <VBox/vmm/tm.h>
-#include <VBox/vmm/pdmblkcache.h>
-#include <VBox/vmm/pdmdev.h>
-#include <VBox/vmm/pdmqueue.h>
-#include <VBox/vmm/pdmthread.h>
-#include <VBox/vmm/cfgm.h>
-#include <VBox/vmm/mm.h>
-#include <VBox/vmm/pdmasynccompletion.h>
-#include <VBox/vmm/pdmnetshaper.h>
-#include <VBox/vmm/pgm.h>
-RT_C_DECLS_BEGIN
-
-
-/**
- * Callback table from the VMM shim library to the PDM test framework.
- */
-typedef struct TSTDEVVMMCALLBACKS
-{
-    DECLR3CALLBACKMEMBER(bool, pfnCFGMR3AreValuesValid, (PCFGMNODE pNode, const char *pszzValid));
-    DECLR3CALLBACKMEMBER(void, pfnCFGMR3Dump, (PCFGMNODE pRoot));
-    DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMR3GetChild, (PCFGMNODE pNode, const char *pszPath));
-    DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMR3GetChildFV, (PCFGMNODE pNode, const char *pszPathFormat, va_list Args));
-    DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMR3GetFirstChild, (PCFGMNODE pNode));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3GetName, (PCFGMNODE pCur, char *pszName, size_t cchName));
-    DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMR3GetNextChild, (PCFGMNODE pCur));
-    DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMR3GetParent, (PCFGMNODE pNode));
-    DECLR3CALLBACKMEMBER(PCFGMNODE, pfnCFGMR3GetRoot, (PVM pVM));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3InsertNode, (PCFGMNODE pNode, const char *pszName, PCFGMNODE *ppChild));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3InsertNodeFV, (PCFGMNODE pNode, PCFGMNODE *ppChild,
-                                                     const char *pszNameFormat, va_list Args));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3InsertString, (PCFGMNODE pNode, const char *pszName, const char *pszString));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3QueryBytes, (PCFGMNODE pNode, const char *pszName, void *pvData, size_t cbData));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3QueryInteger, (PCFGMNODE pNode, const char *pszName, uint64_t *pu64));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3QuerySize, (PCFGMNODE pNode, const char *pszName, size_t *pcb));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3QueryString, (PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3QueryStringAlloc, (PCFGMNODE pNode, const char *pszName, char **ppszString));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3QueryStringAllocDef, (PCFGMNODE pNode, const char *pszName, char **ppszString, const char *pszDef));
-    DECLR3CALLBACKMEMBER(void, pfnCFGMR3RemoveNode, (PCFGMNODE pNode));
-    DECLR3CALLBACKMEMBER(int, pfnCFGMR3ValidateConfig, (PCFGMNODE pNode, const char *pszNode,
-                                                        const char *pszValidValues, const char *pszValidNodes,
-                                                        const char *pszWho, uint32_t uInstance));
-
-    DECLR3CALLBACKMEMBER(int, pfnIOMIOPortWrite, (PVM pVM, PVMCPU pVCpu, RTIOPORT Port, uint32_t u32Value, size_t cbValue));
-    DECLR3CALLBACKMEMBER(int, pfnIOMMMIOMapMMIO2Page, (PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysRemapped, uint64_t fPageFlags));
-    DECLR3CALLBACKMEMBER(int, pfnIOMMMIOResetRegion, (PVM pVM, RTGCPHYS GCPhys));
-    DECLR3CALLBACKMEMBER(int, pfnMMHyperAlloc, (PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv));
-    DECLR3CALLBACKMEMBER(int, pfnMMHyperFree, (PVM pVM, void *pv));
-    DECLR3CALLBACKMEMBER(RTR0PTR, pfnMMHyperR3ToR0, (PVM pVM, RTR3PTR R3Ptr));
-    DECLR3CALLBACKMEMBER(RTRCPTR, pfnMMHyperR3ToRC, (PVM pVM, RTR3PTR R3Ptr));
-    DECLR3CALLBACKMEMBER(void, pfnMMR3HeapFree, (void *pv));
-    DECLR3CALLBACKMEMBER(int, pfnMMR3HyperAllocOnceNoRel, (PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv));
-    DECLR3CALLBACKMEMBER(uint64_t, pfnMMR3PhysGetRamSize, (PVM pVM));
-    DECLR3CALLBACKMEMBER(uint64_t, pfnMMR3PhysGetRamSizeAbove4GB, (PVM pVM));
-    DECLR3CALLBACKMEMBER(uint32_t, pfnMMR3PhysGetRamSizeBelow4GB, (PVM pVM));
-    DECLR3CALLBACKMEMBER(int, pfnPDMCritSectEnterDebug, (PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL));
-    DECLR3CALLBACKMEMBER(bool, pfnPDMCritSectIsInitialized, (PCPDMCRITSECT pCritSect));
-    DECLR3CALLBACKMEMBER(bool, pfnPDMCritSectIsOwner, (PCPDMCRITSECT pCritSect));
-    DECLR3CALLBACKMEMBER(int, pfnPDMCritSectLeave, (PPDMCRITSECT pCritSect));
-    DECLR3CALLBACKMEMBER(int, pfnPDMCritSectTryEnterDebug, (PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL));
-    DECLR3CALLBACKMEMBER(int, pfnPDMHCCritSectScheduleExitEvent, (PPDMCRITSECT pCritSect, SUPSEMEVENT hEventToSignal));
-    DECLR3CALLBACKMEMBER(bool, pfnPDMNsAllocateBandwidth, (PPDMNSFILTER pFilter, size_t cbTransfer));
-    DECLR3CALLBACKMEMBER(PPDMQUEUEITEMCORE, pfnPDMQueueAlloc, (PPDMQUEUE pQueue));
-    DECLR3CALLBACKMEMBER(bool, pfnPDMQueueFlushIfNecessary, (PPDMQUEUE pQueue));
-    DECLR3CALLBACKMEMBER(void, pfnPDMQueueInsert, (PPDMQUEUE pQueue, PPDMQUEUEITEMCORE pItem));
-    DECLR3CALLBACKMEMBER(R0PTRTYPE(PPDMQUEUE), pfnPDMQueueR0Ptr, (PPDMQUEUE pQueue));
-    DECLR3CALLBACKMEMBER(RCPTRTYPE(PPDMQUEUE), pfnPDMQueueRCPtr, (PPDMQUEUE pQueue));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3AsyncCompletionEpClose, (PPDMASYNCCOMPLETIONENDPOINT pEndpoint));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3AsyncCompletionEpCreateForFile, (PPPDMASYNCCOMPLETIONENDPOINT ppEndpoint,
-                                                                       const char *pszFilename, uint32_t fFlags,
-                                                                       PPDMASYNCCOMPLETIONTEMPLATE pTemplate));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3AsyncCompletionEpFlush, (PPDMASYNCCOMPLETIONENDPOINT pEndpoint, void *pvUser,
-                                                               PPPDMASYNCCOMPLETIONTASK ppTask));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3AsyncCompletionEpGetSize, (PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t *pcbSize));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3AsyncCompletionEpRead, (PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
-                                                              PCRTSGSEG paSegments, unsigned cSegments,
-                                                              size_t cbRead, void *pvUser,
-                                                              PPPDMASYNCCOMPLETIONTASK ppTask));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3AsyncCompletionEpSetBwMgr, (PPDMASYNCCOMPLETIONENDPOINT pEndpoint, const char *pszBwMgr));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3AsyncCompletionEpSetSize, (PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t cbSize));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3AsyncCompletionEpWrite, (PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
-                                                               PCRTSGSEG paSegments, unsigned cSegments,
-                                                               size_t cbWrite, void *pvUser,
-                                                               PPPDMASYNCCOMPLETIONTASK ppTask));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3AsyncCompletionTemplateDestroy, (PPDMASYNCCOMPLETIONTEMPLATE pTemplate));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3BlkCacheClear, (PPDMBLKCACHE pBlkCache));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3BlkCacheDiscard, (PPDMBLKCACHE pBlkCache, PCRTRANGE paRanges,
-                                                        unsigned cRanges, void *pvUser));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3BlkCacheFlush, (PPDMBLKCACHE pBlkCache, void *pvUser));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3BlkCacheIoXferComplete, (PPDMBLKCACHE pBlkCache, PPDMBLKCACHEIOXFER hIoXfer, int rcIoXfer));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3BlkCacheRead, (PPDMBLKCACHE pBlkCache, uint64_t off, PCRTSGBUF pSgBuf, size_t cbRead, void *pvUser));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3BlkCacheRelease, (PPDMBLKCACHE pBlkCache));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3BlkCacheResume, (PPDMBLKCACHE pBlkCache));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3BlkCacheSuspend, (PPDMBLKCACHE pBlkCache));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3BlkCacheWrite, (PPDMBLKCACHE pBlkCache, uint64_t off, PCRTSGBUF pSgBuf, size_t cbWrite, void *pvUser));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3CritSectDelete, (PPDMCRITSECT pCritSect));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3QueryLun, (PUVM pUVM, const char *pszDevice, unsigned iInstance, unsigned iLun, PPPDMIBASE ppBase));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3ThreadDestroy, (PPDMTHREAD pThread, int *pRcThread));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3ThreadResume, (PPDMTHREAD pThread));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3ThreadSleep, (PPDMTHREAD pThread, RTMSINTERVAL cMillies));
-    DECLR3CALLBACKMEMBER(int, pfnPDMR3ThreadSuspend, (PPDMTHREAD pThread));
-    DECLR3CALLBACKMEMBER(uint64_t, pfnTMCpuTicksPerSecond, (PVM pVM));
-    DECLR3CALLBACKMEMBER(int, pfnTMR3TimerDestroy, (PTMTIMER pTimer));
-    DECLR3CALLBACKMEMBER(int, pfnTMR3TimerLoad, (PTMTIMERR3 pTimer, PSSMHANDLE pSSM));
-    DECLR3CALLBACKMEMBER(int, pfnTMR3TimerSave, (PTMTIMERR3 pTimer, PSSMHANDLE pSSM));
-    DECLR3CALLBACKMEMBER(int, pfnTMR3TimerSetCritSect, (PTMTIMERR3 pTimer, PPDMCRITSECT pCritSect));
-    DECLR3CALLBACKMEMBER(uint64_t, pfnTMTimerFromMilli, (PTMTIMER pTimer, uint64_t cMilliSecs));
-    DECLR3CALLBACKMEMBER(uint64_t, pfnTMTimerFromNano, (PTMTIMER pTimer, uint64_t cNanoSecs));
-    DECLR3CALLBACKMEMBER(uint64_t, pfnTMTimerGet, (PTMTIMER pTimer));
-    DECLR3CALLBACKMEMBER(uint64_t, pfnTMTimerGetFreq, (PTMTIMER pTimer));
-    DECLR3CALLBACKMEMBER(uint64_t, pfnTMTimerGetNano, (PTMTIMER pTimer));
-    DECLR3CALLBACKMEMBER(bool, pfnTMTimerIsActive, (PTMTIMER pTimer));
-    DECLR3CALLBACKMEMBER(bool, pfnTMTimerIsLockOwner, (PTMTIMER pTimer));
-    DECLR3CALLBACKMEMBER(int, pfnTMTimerLock, (PTMTIMER pTimer, int rcBusy));
-    DECLR3CALLBACKMEMBER(PTMTIMERR0, pfnTMTimerR0Ptr, (PTMTIMER pTimer));
-    DECLR3CALLBACKMEMBER(PTMTIMERRC, pfnTMTimerRCPtr, (PTMTIMER pTimer));
-    DECLR3CALLBACKMEMBER(int, pfnTMTimerSet, (PTMTIMER pTimer, uint64_t u64Expire));
-    DECLR3CALLBACKMEMBER(int, pfnTMTimerSetFrequencyHint, (PTMTIMER pTimer, uint32_t uHz));
-    DECLR3CALLBACKMEMBER(int, pfnTMTimerSetMicro, (PTMTIMER pTimer, uint64_t cMicrosToNext));
-    DECLR3CALLBACKMEMBER(int, pfnTMTimerSetMillies, (PTMTIMER pTimer, uint32_t cMilliesToNext));
-    DECLR3CALLBACKMEMBER(int, pfnTMTimerSetNano, (PTMTIMER pTimer, uint64_t cNanosToNext));
-    DECLR3CALLBACKMEMBER(int, pfnTMTimerStop, (PTMTIMER pTimer));
-    DECLR3CALLBACKMEMBER(void, pfnTMTimerUnlock, (PTMTIMER pTimer));
-    DECLR3CALLBACKMEMBER(PVMCPU, pfnVMMGetCpu, (PVM pVM));
-    DECLR3CALLBACKMEMBER(VMCPUID, pfnVMMGetCpuId, (PVM pVM));
-    DECLR3CALLBACKMEMBER(int, pfnVMMR3DeregisterPatchMemory, (PVM pVM, RTGCPTR pPatchMem, unsigned cbPatchMem));
-    DECLR3CALLBACKMEMBER(int, pfnVMMR3RegisterPatchMemory, (PVM pVM, RTGCPTR pPatchMem, unsigned cbPatchMem));
-    DECLR3CALLBACKMEMBER(RTNATIVETHREAD, pfnVMR3GetVMCPUNativeThread, (PVM pVM));
-    DECLR3CALLBACKMEMBER(int, pfnVMR3NotifyCpuDeviceReady, (PVM pVM, VMCPUID idCpu));
-    DECLR3CALLBACKMEMBER(int, pfnVMR3ReqCallNoWait, (PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...));
-    DECLR3CALLBACKMEMBER(int, pfnVMR3ReqCallVoidNoWait, (PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...));
-    DECLR3CALLBACKMEMBER(int, pfnVMR3ReqPriorityCallWait, (PVM pVM, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...));
-    DECLR3CALLBACKMEMBER(int, pfnVMR3WaitForDeviceReady, (PVM pVM, VMCPUID idCpu));
-} TSTDEVVMMCALLBACKS;
-
-
-extern const PDMDEVHLPR3 g_tstDevPdmDevHlpR3;
-extern const TSTDEVVMMCALLBACKS g_tstDevVmmCallbacks;
-
-RT_C_DECLS_END
-
-#endif /* !VBOX_INCLUDED_SRC_testcase_tstDeviceVMMInternal_h */
-
Index: unk/src/VBox/Devices/testcase/tstDeviceVMMStubs.cpp
===================================================================
--- /trunk/src/VBox/Devices/testcase/tstDeviceVMMStubs.cpp	(revision 82882)
+++ 	(revision )
@@ -1,991 +1,0 @@
-/* $Id$ */
-/** @file
- * tstDevice - Test framework for PDM devices/drivers, shim library exporting methods
- *             originally for VBoxVMM for intercepting (we don't want to use the PDM module
- *             to use the originals from VBoxVMM).
- */
-
-/*
- * Copyright (C) 2017-2019 Oracle Corporation
- *
- * This file is part of VirtualBox Open Source Edition (OSE), as
- * available from http://www.virtualbox.org. This file is free software;
- * you can redistribute it and/or modify it under the terms of the GNU
- * General Public License (GPL) as published by the Free Software
- * Foundation, in version 2 as it comes in the "COPYING" file of the
- * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
- */
-/* Methods imported from VBoxVMM by VBoxDD are extracted with:
- *     objdump -T VBoxDD.so | grep "UND" | awk -F ' ' '{print $5}' | grep -E "^TM|^PGM|^PDM|^CFGM|^IOM|^MM|^VM|^PDM|^SUP" | sort
- */
-
-
-/*********************************************************************************************************************************
-*   Header Files                                                                                                                 *
-*********************************************************************************************************************************/
-#define LOG_GROUP LOG_GROUP_DEFAULT /** @todo */
-#include <iprt/assert.h>
-#include <iprt/mem.h>
-
-#include <VBox/err.h>
-#include <VBox/cdefs.h>
-
-#include "tstDeviceVMMInternal.h"
-
-
-/*********************************************************************************************************************************
-*   Defined Constants And Macros                                                                                                 *
-*********************************************************************************************************************************/
-
-
-/*********************************************************************************************************************************
-*   Structures and Typedefs                                                                                                      *
-*********************************************************************************************************************************/
-
-
-/*********************************************************************************************************************************
-*   Global Variables                                                                                                             *
-*********************************************************************************************************************************/
-
-
-/*********************************************************************************************************************************
-*   Internal Functions                                                                                                           *
-*********************************************************************************************************************************/
-
-
-/**
- * @copydoc CFGMR3AreValuesValid
- */
-VMMR3DECL(bool) CFGMR3AreValuesValid(PCFGMNODE pNode, const char *pszzValid)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3AreValuesValid(pNode, pszzValid);
-}
-
-
-/**
- * @copydoc CFGMR3Dump
- */
-VMMR3DECL(void) CFGMR3Dump(PCFGMNODE pRoot)
-{
-    pRoot->pVmmCallbacks->pfnCFGMR3Dump(pRoot);
-}
-
-
-/**
- * @copydoc CFGMR3GetChild
- */
-VMMR3DECL(PCFGMNODE) CFGMR3GetChild(PCFGMNODE pNode, const char *pszPath)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3GetChild(pNode, pszPath);
-}
-
-
-/**
- * @copydoc CFGMR3GetChildF
- */
-VMMR3DECL(PCFGMNODE) CFGMR3GetChildF(PCFGMNODE pNode, const char *pszPathFormat, ...) RT_IPRT_FORMAT_ATTR(2, 3)
-{
-    va_list Args;
-    va_start(Args, pszPathFormat);
-    PCFGMNODE pChild = pNode->pVmmCallbacks->pfnCFGMR3GetChildFV(pNode, pszPathFormat, Args);
-    va_end(Args);
-
-    return pChild;
-}
-
-
-/**
- * @copydoc CFGMR3GetFirstChild
- */
-VMMR3DECL(PCFGMNODE) CFGMR3GetFirstChild(PCFGMNODE pNode)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3GetFirstChild(pNode);
-}
-
-
-/**
- * @copydoc CFGMR3GetName
- */
-VMMR3DECL(int) CFGMR3GetName(PCFGMNODE pCur, char *pszName, size_t cchName)
-{
-    return pCur->pVmmCallbacks->pfnCFGMR3GetName(pCur, pszName, cchName);
-}
-
-
-/**
- * @copydoc CFGMR3GetFirstChild
- */
-VMMR3DECL(PCFGMNODE) CFGMR3GetNextChild(PCFGMNODE pNode)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3GetNextChild(pNode);
-}
-
-
-/**
- * @copydoc CFGMR3GetParent
- */
-VMMR3DECL(PCFGMNODE) CFGMR3GetParent(PCFGMNODE pNode)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3GetParent(pNode);
-}
-
-
-/**
- * @copydoc CFGMR3GetRoot
- */
-VMMR3DECL(PCFGMNODE) CFGMR3GetRoot(PVM pVM)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnCFGMR3GetRoot(pVM);
-}
-
-
-/**
- * @copydoc CFGMR3InsertNode
- */
-VMMR3DECL(int) CFGMR3InsertNode(PCFGMNODE pNode, const char *pszName, PCFGMNODE *ppChild)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3InsertNode(pNode, pszName, ppChild);
-}
-
-
-/**
- * @copydoc CFGMR3InsertNodeF
- */
-VMMR3DECL(int) CFGMR3InsertNodeF(PCFGMNODE pNode, PCFGMNODE *ppChild,
-                                 const char *pszNameFormat, ...) RT_IPRT_FORMAT_ATTR(3, 4)
-{
-    va_list Args;
-    va_start(Args, pszNameFormat);
-    int rc = pNode->pVmmCallbacks->pfnCFGMR3InsertNodeFV(pNode, ppChild, pszNameFormat, Args);
-    va_end(Args);
-
-    return rc;
-}
-
-
-/**
- * @copydoc CFGMR3InsertString
- */
-VMMR3DECL(int) CFGMR3InsertString(PCFGMNODE pNode, const char *pszName, const char *pszString)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3InsertString(pNode, pszName, pszString);
-}
-
-
-/**
- * @copydoc CFGMR3QueryBool
- */
-VMMR3DECL(int) CFGMR3QueryBool(PCFGMNODE pNode, const char *pszName, bool *pf)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryInteger(pNode, pszName, &u64);
-    if (RT_SUCCESS(rc))
-        *pf = u64 ? true : false;
-    return rc;
-}
-
-
-/**
- * @copydoc CFGMR3QueryBoolDef
- */
-VMMR3DECL(int) CFGMR3QueryBoolDef(PCFGMNODE pNode, const char *pszName, bool *pf, bool fDef)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryIntegerDef(pNode, pszName, &u64, fDef);
-    *pf = u64 ? true : false;
-    return rc;
-}
-
-
-/**
- * @copydoc CFGMR3QueryBytes
- */
-VMMR3DECL(int) CFGMR3QueryBytes(PCFGMNODE pNode, const char *pszName, void *pvData, size_t cbData)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3QueryBytes(pNode, pszName, pvData, cbData);
-}
-
-
-/**
- * @copydoc CFGMR3QueryInteger
- */
-VMMR3DECL(int) CFGMR3QueryInteger(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3QueryInteger(pNode, pszName, pu64);
-}
-
-
-/**
- * @copydoc CFGMR3QueryIntegerDef
- */
-VMMR3DECL(int) CFGMR3QueryIntegerDef(PCFGMNODE pNode, const char *pszName, uint64_t *pu64, uint64_t u64Def)
-{
-    int rc = CFGMR3QueryInteger(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;
-}
-
-
-/**
- * @copydoc CFGMR3QueryPortDef
- */
-VMMR3DECL(int) CFGMR3QueryPortDef(PCFGMNODE pNode, const char *pszName, PRTIOPORT pPort, RTIOPORT PortDef)
-{
-    AssertCompileSize(RTIOPORT, 2);
-    return CFGMR3QueryU16Def(pNode, pszName, pPort, PortDef);
-}
-
-
-/**
- * @copydoc CFGMR3QueryPtr
- */
-VMMR3DECL(int) CFGMR3QueryPtr(PCFGMNODE pNode, const char *pszName, void **ppv)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryInteger(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;
-}
-
-
-/**
- * @copydoc CFGMR3QueryS32
- */
-VMMR3DECL(int) CFGMR3QueryS32(PCFGMNODE pNode, const char *pszName, int32_t *pi32)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryInteger(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;
-}
-
-
-/**
- * @copydoc CFGMR3QueryS32Def
- */
-VMMR3DECL(int) CFGMR3QueryS32Def(PCFGMNODE pNode, const char *pszName, int32_t *pi32, int32_t i32Def)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryIntegerDef(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;
-}
-
-
-/**
- * @copydoc CFGMR3QuerySIntDef
- */
-VMMR3DECL(int) CFGMR3QuerySIntDef(PCFGMNODE pNode, const char *pszName, signed int *pi, signed int iDef)
-{
-    AssertCompileSize(signed int, 4);
-    return CFGMR3QueryS32Def(pNode, pszName, (int32_t *)pi, iDef);
-}
-
-
-/**
- * @copydoc CFGMR3QuerySize
- */
-VMMDECL(int) CFGMR3QuerySize(PCFGMNODE pNode, const char *pszName, size_t *pcb)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3QuerySize(pNode, pszName, pcb);
-}
-
-
-/**
- * @copydoc CFGMR3QueryString
- */
-VMMR3DECL(int) CFGMR3QueryString(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3QueryString(pNode, pszName, pszString, cchString);
-}
-
-
-/**
- * @copydoc CFGMR3QueryStringDef
- */
-VMMR3DECL(int) CFGMR3QueryStringDef(PCFGMNODE pNode, const char *pszName, char *pszString, size_t cchString, const char *pszDef)
-{
-    int rc = CFGMR3QueryString(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;
-}
-
-
-/**
- * @copydoc CFGMR3QueryStringAlloc
- */
-VMMR3DECL(int) CFGMR3QueryStringAlloc(PCFGMNODE pNode, const char *pszName, char **ppszString)
-{
-#if 0
-    size_t cbString;
-    int rc = CFGMR3QuerySize(pNode, pszName, &cbString);
-    if (RT_SUCCESS(rc))
-    {
-        char *pszString = cfgmR3StrAlloc(pNode->pVM, MM_TAG_CFGM_USER, cbString);
-        if (pszString)
-        {
-            rc = CFGMR3QueryString(pNode, pszName, pszString, cbString);
-            if (RT_SUCCESS(rc))
-                *ppszString = pszString;
-            else
-                cfgmR3StrFree(pNode->pVM, pszString);
-        }
-        else
-            rc = VERR_NO_MEMORY;
-    }
-    return rc;
-#endif
-    RT_NOREF(pNode, pszName, ppszString);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-/**
- * @copydoc CFGMR3QueryStringAllocDef
- */
-VMMR3DECL(int) CFGMR3QueryStringAllocDef(PCFGMNODE pNode, const char *pszName, char **ppszString, const char *pszDef)
-{
-    RT_NOREF(pNode, pszName, ppszString, pszDef);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-/**
- * @copydoc CFGMR3QueryU16
- */
-VMMR3DECL(int) CFGMR3QueryU16(PCFGMNODE pNode, const char *pszName, uint16_t *pu16)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryInteger(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;
-}
-
-
-/**
- * @copydoc CFGMR3QueryU16Def
- */
-VMMR3DECL(int) CFGMR3QueryU16Def(PCFGMNODE pNode, const char *pszName, uint16_t *pu16, uint16_t u16Def)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryIntegerDef(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;
-}
-
-
-/**
- * @copydoc CFGMR3QueryU32
- */
-VMMR3DECL(int) CFGMR3QueryU32(PCFGMNODE pNode, const char *pszName, uint32_t *pu32)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryInteger(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;
-}
-
-
-/**
- * @copydoc CFGMR3QueryU32Def
- */
-VMMR3DECL(int) CFGMR3QueryU32Def(PCFGMNODE pNode, const char *pszName, uint32_t *pu32, uint32_t u32Def)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryIntegerDef(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;
-}
-
-
-/**
- * @copydoc CFGMR3QueryU64
- */
-VMMR3DECL(int) CFGMR3QueryU64(PCFGMNODE pNode, const char *pszName, uint64_t *pu64)
-{
-    return CFGMR3QueryInteger(pNode, pszName, pu64);
-}
-
-
-/**
- * @copydoc CFGMR3QueryU64Def
- */
-VMMR3DECL(int) CFGMR3QueryU64Def(PCFGMNODE pNode, const char *pszName, uint64_t *pu64, uint64_t u64Def)
-{
-    return CFGMR3QueryIntegerDef(pNode, pszName, pu64, u64Def);
-}
-
-
-/**
- * @copydoc CFGMR3QueryU8
- */
-VMMR3DECL(int) CFGMR3QueryU8(PCFGMNODE pNode, const char *pszName, uint8_t *pu8)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryInteger(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;
-}
-
-
-/**
- * @copydoc CFGMR3QueryU8Def
- */
-VMMR3DECL(int) CFGMR3QueryU8Def(PCFGMNODE pNode, const char *pszName, uint8_t *pu8, uint8_t u8Def)
-{
-    uint64_t u64;
-    int rc = CFGMR3QueryIntegerDef(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;
-}
-
-
-/**
- * @copydoc CFGMR3RemoveNode
- */
-VMMR3DECL(void) CFGMR3RemoveNode(PCFGMNODE pNode)
-{
-    pNode->pVmmCallbacks->pfnCFGMR3RemoveNode(pNode);
-}
-
-
-/**
- * @copydoc CFGMR3ValidateConfig
- */
-VMMR3DECL(int) CFGMR3ValidateConfig(PCFGMNODE pNode, const char *pszNode,
-                                    const char *pszValidValues, const char *pszValidNodes,
-                                    const char *pszWho, uint32_t uInstance)
-{
-    return pNode->pVmmCallbacks->pfnCFGMR3ValidateConfig(pNode, pszNode, pszValidValues, pszValidNodes, pszWho, uInstance);
-}
-
-
-/**
- * @copydoc IOMIOPortWrite
- */
-VMMDECL(VBOXSTRICTRC) IOMIOPortWrite(PVM pVM, PVMCPU pVCpu, RTIOPORT Port, uint32_t u32Value, size_t cbValue)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnIOMIOPortWrite(pVM, pVCpu, Port, u32Value, cbValue);
-}
-
-
-/**
- * @copydoc IOMMMIOMapMMIO2Page
- */
-VMMDECL(int) IOMMMIOMapMMIO2Page(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysRemapped, uint64_t fPageFlags)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnIOMMMIOMapMMIO2Page(pVM, GCPhys, GCPhysRemapped, fPageFlags);
-}
-
-
-/**
- * @copydoc IOMMMIOResetRegion
- */
-VMMDECL(int) IOMMMIOResetRegion(PVM pVM, RTGCPHYS GCPhys)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnIOMMMIOResetRegion(pVM, GCPhys);
-}
-
-
-/**
- * @copydoc MMHyperAlloc
- */
-VMMDECL(int) MMHyperAlloc(PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnMMHyperAlloc(pVM, cb, uAlignment, enmTag, ppv);
-}
-
-
-/**
- * @copydoc MMHyperFree
- */
-VMMDECL(int) MMHyperFree(PVM pVM, void *pv)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnMMHyperFree(pVM, pv);
-}
-
-
-/**
- * @copydoc MMHyperR3ToR0
- */
-VMMDECL(RTR0PTR) MMHyperR3ToR0(PVM pVM, RTR3PTR R3Ptr)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnMMHyperR3ToR0(pVM, R3Ptr);
-}
-
-
-/**
- * @copydoc MMHyperR3ToRC
- */
-VMMDECL(RTRCPTR) MMHyperR3ToRC(PVM pVM, RTR3PTR R3Ptr)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnMMHyperR3ToRC(pVM, R3Ptr);
-}
-
-
-/**
- * @copydoc MMR3HeapFree
- */
-VMMR3DECL(void) MMR3HeapFree(void *pv)
-{
-    PTSTDEVMMHEAPALLOC pHeapAlloc = (PTSTDEVMMHEAPALLOC)((uint8_t *)pv - RT_UOFFSETOF(TSTDEVMMHEAPALLOC, abAlloc[0]));
-    pHeapAlloc->pVmmCallbacks->pfnMMR3HeapFree(pv);
-}
-
-
-/**
- * @copydoc MMR3HyperAllocOnceNoRel
- */
-VMMR3DECL(int) MMR3HyperAllocOnceNoRel(PVM pVM, size_t cb, uint32_t uAlignment, MMTAG enmTag, void **ppv)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnMMR3HyperAllocOnceNoRel(pVM, cb, uAlignment, enmTag, ppv);
-}
-
-
-/**
- * @copydoc MMR3PhysGetRamSize
- */
-VMMR3DECL(uint64_t) MMR3PhysGetRamSize(PVM pVM)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnMMR3PhysGetRamSize(pVM);
-}
-
-
-/**
- * @copydoc MMR3PhysGetRamSizeBelow4GB
- */
-VMMR3DECL(uint32_t) MMR3PhysGetRamSizeBelow4GB(PVM pVM)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnMMR3PhysGetRamSizeBelow4GB(pVM);
-}
-
-
-/**
- * @copydoc MMR3PhysGetRamSizeAbove4GB
- */
-VMMR3DECL(uint64_t) MMR3PhysGetRamSizeAbove4GB(PVM pVM)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnMMR3PhysGetRamSizeAbove4GB(pVM);
-}
-
-
-/**
- * @copydoc PDMCritSectEnterDebug
- */
-VMMDECL(int) PDMCritSectEnterDebug(PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
-{
-    return pCritSect->s.pVmmCallbacks->pfnPDMCritSectEnterDebug(pCritSect, rcBusy, uId, RT_SRC_POS_ARGS);
-}
-
-
-/**
- * @copydoc PDMCritSectIsInitialized
- */
-VMMDECL(bool) PDMCritSectIsInitialized(PCPDMCRITSECT pCritSect)
-{
-    return pCritSect->s.pVmmCallbacks->pfnPDMCritSectIsInitialized(pCritSect);
-}
-
-
-/**
- * @copydoc PDMCritSectIsOwner
- */
-VMMDECL(bool) PDMCritSectIsOwner(PCPDMCRITSECT pCritSect)
-{
-    return pCritSect->s.pVmmCallbacks->pfnPDMCritSectIsOwner(pCritSect);
-}
-
-
-/**
- * @copydoc PDMCritSectLeave
- */
-VMMDECL(int) PDMCritSectLeave(PPDMCRITSECT pCritSect)
-{
-    return pCritSect->s.pVmmCallbacks->pfnPDMCritSectLeave(pCritSect);
-}
-
-
-/**
- * @copydoc PDMCritSectTryEnterDebug
- */
-VMMDECL(int) PDMCritSectTryEnterDebug(PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
-{
-    return pCritSect->s.pVmmCallbacks->pfnPDMCritSectTryEnterDebug(pCritSect, uId, RT_SRC_POS_ARGS);
-}
-
-
-/**
- * @copydoc PDMHCCritSectScheduleExitEvent
- */
-VMMDECL(int) PDMHCCritSectScheduleExitEvent(PPDMCRITSECT pCritSect, SUPSEMEVENT hEventToSignal)
-{
-    return pCritSect->s.pVmmCallbacks->pfnPDMHCCritSectScheduleExitEvent(pCritSect, hEventToSignal);
-}
-
-
-/**
- * @copydoc PDMNsAllocateBandwidth
- */
-VMMDECL(bool) PDMNsAllocateBandwidth(PPDMNSFILTER pFilter, size_t cbTransfer)
-{
-#if 0
-    return pFilter->pVmmCallbacks->pfnPDMNsAllocateBandwidth(pFilter, cbTransfer);
-#endif
-    RT_NOREF(pFilter, cbTransfer);
-    AssertFailed();
-    return false;
-}
-
-
-/**
- * @copydoc PDMQueueAlloc
- */
-VMMDECL(PPDMQUEUEITEMCORE) PDMQueueAlloc(PPDMQUEUE pQueue)
-{
-    return pQueue->pVmmCallbacks->pfnPDMQueueAlloc(pQueue);
-}
-
-
-/**
- * @copydoc PDMQueueFlushIfNecessary
- */
-VMMDECL(bool) PDMQueueFlushIfNecessary(PPDMQUEUE pQueue)
-{
-    return pQueue->pVmmCallbacks->pfnPDMQueueFlushIfNecessary(pQueue);
-}
-
-
-/**
- * @copydoc PDMQueueInsert
- */
-VMMDECL(void) PDMQueueInsert(PPDMQUEUE pQueue, PPDMQUEUEITEMCORE pItem)
-{
-    pQueue->pVmmCallbacks->pfnPDMQueueInsert(pQueue, pItem);
-}
-
-
-/**
- * @copydoc PDMQueueR0Ptr
- */
-VMMDECL(R0PTRTYPE(PPDMQUEUE)) PDMQueueR0Ptr(PPDMQUEUE pQueue)
-{
-    return pQueue->pVmmCallbacks->pfnPDMQueueR0Ptr(pQueue);
-}
-
-
-/**
- * @copydoc PDMQueueRCPtr
- */
-VMMDECL(RCPTRTYPE(PPDMQUEUE)) PDMQueueRCPtr(PPDMQUEUE pQueue)
-{
-    return pQueue->pVmmCallbacks->pfnPDMQueueRCPtr(pQueue);
-}
-
-
-/**
- * @copydoc PGMHandlerPhysicalPageTempOff
- */
-VMMDECL(int) PGMHandlerPhysicalPageTempOff(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage)
-{
-    RT_NOREF(pVM, GCPhys, GCPhysPage);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-/**
- * @copydoc PGMShwMakePageWritable
- */
-VMMDECL(int) PGMShwMakePageWritable(PVMCPU pVCpu, RTGCPTR GCPtr, uint32_t fFlags)
-{
-    RT_NOREF(pVCpu, GCPtr, fFlags);
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
-}
-
-/** @todo PDMR3AsyncCompletion + BlkCache + CritSect + QueryLun + Thread. */
-
-/**
- * @copydoc TMCpuTicksPerSecond
- */
-VMMDECL(uint64_t) TMCpuTicksPerSecond(PVM pVM)
-{
-    return pVM->vm.s.pVmmCallbacks->pfnTMCpuTicksPerSecond(pVM);
-}
-
-
-/**
- * @copydoc TMR3TimerDestroy
- */
-VMMR3DECL(int) TMR3TimerDestroy(PTMTIMER pTimer)
-{
-    return pTimer->pVmmCallbacks->pfnTMR3TimerDestroy(pTimer);
-}
-
-
-/**
- * @copydoc TMR3TimerSave
- */
-VMMR3DECL(int) TMR3TimerSave(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
-{
-    return pTimer->pVmmCallbacks->pfnTMR3TimerSave(pTimer, pSSM);
-}
-
-
-/**
- * @copydoc TMR3TimerLoad
- */
-VMMR3DECL(int) TMR3TimerLoad(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
-{
-    return pTimer->pVmmCallbacks->pfnTMR3TimerLoad(pTimer, pSSM);
-}
-
-
-/**
- * @copydoc TMR3TimerSetCritSect
- */
-VMMR3DECL(int) TMR3TimerSetCritSect(PTMTIMERR3 pTimer, PPDMCRITSECT pCritSect)
-{
-    return pTimer->pVmmCallbacks->pfnTMR3TimerSetCritSect(pTimer, pCritSect);
-}
-
-
-/**
- * @copydoc TMTimerFromMilli
- */
-VMMDECL(uint64_t) TMTimerFromMilli(PTMTIMER pTimer, uint64_t cMilliSecs)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerFromMilli(pTimer, cMilliSecs);
-}
-
-
-/**
- * @copydoc TMTimerFromNano
- */
-VMMDECL(uint64_t) TMTimerFromNano(PTMTIMER pTimer, uint64_t cNanoSecs)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerFromNano(pTimer, cNanoSecs);
-}
-
-
-/**
- * @copydoc TMTimerGet
- */
-VMMDECL(uint64_t) TMTimerGet(PTMTIMER pTimer)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerGet(pTimer);
-}
-
-
-/**
- * @copydoc TMTimerGetFreq
- */
-VMMDECL(uint64_t) TMTimerGetFreq(PTMTIMER pTimer)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerGetFreq(pTimer);
-}
-
-
-/**
- * @copydoc TMTimerGetNano
- */
-VMMDECL(uint64_t) TMTimerGetNano(PTMTIMER pTimer)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerGetNano(pTimer);
-}
-
-
-/**
- * @copydoc TMTimerIsActive
- */
-VMMDECL(bool) TMTimerIsActive(PTMTIMER pTimer)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerIsActive(pTimer);
-}
-
-
-/**
- * @copydoc TMTimerIsLockOwner
- */
-VMMDECL(bool) TMTimerIsLockOwner(PTMTIMER pTimer)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerIsLockOwner(pTimer);
-}
-
-
-/**
- * @copydoc TMTimerLock
- */
-VMMDECL(int) TMTimerLock(PTMTIMER pTimer, int rcBusy)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerLock(pTimer, rcBusy);
-}
-
-
-/**
- * @copydoc TMTimerR0Ptr
- */
-VMMDECL(PTMTIMERR0) TMTimerR0Ptr(PTMTIMER pTimer)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerR0Ptr(pTimer);
-}
-
-
-/**
- * @copydoc TMTimerRCPtr
- */
-VMMDECL(PTMTIMERRC) TMTimerRCPtr(PTMTIMER pTimer)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerRCPtr(pTimer);
-}
-
-
-/**
- * @copydoc TMTimerSet
- */
-VMMDECL(int) TMTimerSet(PTMTIMER pTimer, uint64_t u64Expire)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerSet(pTimer, u64Expire);
-}
-
-
-/**
- * @copydoc TMTimerSetFrequencyHint
- */
-VMMDECL(int) TMTimerSetFrequencyHint(PTMTIMER pTimer, uint32_t uHz)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerSetFrequencyHint(pTimer, uHz);
-}
-
-
-/**
- * @copydoc TMTimerSetMicro
- */
-VMMDECL(int) TMTimerSetMicro(PTMTIMER pTimer, uint64_t cMicrosToNext)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerSetMicro(pTimer, cMicrosToNext);
-}
-
-
-/**
- * @copydoc TMTimerSetMillies
- */
-VMMDECL(int) TMTimerSetMillies(PTMTIMER pTimer, uint32_t cMilliesToNext)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerSetMillies(pTimer, cMilliesToNext);
-}
-
-
-/**
- * @copydoc TMTimerSetNano
- */
-VMMDECL(int) TMTimerSetNano(PTMTIMER pTimer, uint64_t cNanosToNext)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerSetNano(pTimer, cNanosToNext);
-}
-
-
-/**
- * @copydoc TMTimerStop
- */
-VMMDECL(int) TMTimerStop(PTMTIMER pTimer)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerStop(pTimer);
-}
-
-
-/**
- * @copydoc TMTimerUnlock
- */
-VMMDECL(void) TMTimerUnlock(PTMTIMER pTimer)
-{
-    return pTimer->pVmmCallbacks->pfnTMTimerUnlock(pTimer);
-}
-
