Changeset 12970 in vbox for trunk/src/VBox/VMM/PDMDevice.cpp

Timestamp:

Oct 3, 2008 7:04:11 AM (17 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

37403

Message:

#1865: PDMINS.

File:

• trunk/src/VBox/VMM/PDMDevice.cpp (modified) (195 diffs)

trunk/src/VBox/VMM/PDMDevice.cpp

@@ -80 +80 @@
 /* VSlick regex:
 search : \om/\*\*.+?\*\/\nDECLCALLBACKMEMBER\(([^,]*), *pfn([^)]*)\)\(
-replace: \/\*\* @copydoc PDMDEVHLP::pfn\2 \*\/\nstatic DECLCALLBACK\(\1\) pdmR3DevHlp_\2\(
+replace: \/\*\* @copydoc PDMDEVHLPR3::pfn\2 \*\/\nstatic DECLCALLBACK\(\1\) pdmR3DevHlp_\2\(
  */
 
@@ -298 +298 @@
  * The device helper structure for trusted devices.
  */
-const PDMDEVHLP g_pdmR3DevHlpTrusted =
+const PDMDEVHLPR3 g_pdmR3DevHlpTrusted =
 {
     PDM_DEVHLP_VERSION,
@@ -394 +394 @@
  * The device helper structure for non-trusted devices.
  */
-const PDMDEVHLP g_pdmR3DevHlpUnTrusted =
+const PDMDEVHLPR3 g_pdmR3DevHlpUnTrusted =
 {
     PDM_DEVHLP_VERSION,
@@ -601 +601 @@
 
     /*
-     * Get the GC & R0 devhlps and create the devhlp R3 task queue.
-     */
-    RCPTRTYPE(PCPDMDEVHLPGC) pDevHlpGC;
-    int rc = PDMR3GetSymbolGC(pVM, NULL, "g_pdmGCDevHlp", &pDevHlpGC);
+     * Get the RC & R0 devhlps and create the devhlp R3 task queue.
+     */
+    PCPDMDEVHLPRC pDevHlpRC;
+    int rc = PDMR3GetSymbolGC(pVM, NULL, "g_pdmRCDevHlp", &pDevHlpRC);
     AssertReleaseRCReturn(rc, rc);
 
-    R0PTRTYPE(PCPDMDEVHLPR0) pDevHlpR0;
+    PCPDMDEVHLPR0 pDevHlpR0;
     rc = PDMR3GetSymbolR0(pVM, NULL, "g_pdmR0DevHlp", &pDevHlpR0);
     AssertReleaseRCReturn(rc, rc);
@@ -883 +883 @@
          */
         pDevIns->u32Version                     = PDM_DEVINS_VERSION;
-        //pDevIns->Internal.s.pNextHC             = NULL;
-        //pDevIns->Internal.s.pPerDeviceNextHC    = NULL;
-        pDevIns->Internal.s.pDevHC              = paDevs[i].pDev;
-        pDevIns->Internal.s.pVMHC               = pVM;
-        pDevIns->Internal.s.pVMGC               = pVM->pVMGC;
-        //pDevIns->Internal.s.pLunsHC             = NULL;
+        //pDevIns->Internal.s.pNextR3             = NULL;
+        //pDevIns->Internal.s.pPerDeviceNextR3    = NULL;
+        pDevIns->Internal.s.pDevR3              = paDevs[i].pDev;
+        pDevIns->Internal.s.pVMR3               = pVM;
+        pDevIns->Internal.s.pVMR0               = pVM->pVMR0;
+        pDevIns->Internal.s.pVMRC               = pVM->pVMRC;
+        //pDevIns->Internal.s.pLunsR3             = NULL;
         pDevIns->Internal.s.pCfgHandle          = paDevs[i].pNode;
-        //pDevIns->Internal.s.pPciDevice          = NULL;
-        //pDevIns->Internal.s.pPciBus             = NULL; /** @todo pci bus selection. (in 2008 perhaps) */
-        pDevIns->pDevHlp                        = fTrusted ? &g_pdmR3DevHlpTrusted : &g_pdmR3DevHlpUnTrusted;
-        pDevIns->pDevHlpGC                      = pDevHlpGC;
+        //pDevIns->Internal.s.pPciDeviceR3        = NULL;
+        //pDevIns->Internal.s.pPciBusR3           = NULL; /** @todo pci bus selection. (in 2008 perhaps) */
+        //pDevIns->Internal.s.pPciDeviceR0        = 0;
+        //pDevIns->Internal.s.pPciBusR0           = 0;
+        //pDevIns->Internal.s.pPciDeviceRC        = 0;
+        //pDevIns->Internal.s.pPciBusRC           = 0;
+        pDevIns->pDevHlpR3                      = fTrusted ? &g_pdmR3DevHlpTrusted : &g_pdmR3DevHlpUnTrusted;
+        pDevIns->pDevHlpRC                      = pDevHlpRC;
         pDevIns->pDevHlpR0                      = pDevHlpR0;
         pDevIns->pDevReg                        = paDevs[i].pDev->pDevReg;
@@ -899 +904 @@
         pDevIns->iInstance                      = paDevs[i].iInstance;
         pDevIns->pvInstanceDataR3               = &pDevIns->achInstanceData[0];
-        pDevIns->pvInstanceDataGC               =  pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_GC
-                                                   ? MMHyperHC2GC(pVM, pDevIns->pvInstanceDataR3) : 0;
-        pDevIns->pvInstanceDataR0               =  pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0
-                                                   ? MMHyperR3ToR0(pVM, pDevIns->pvInstanceDataR3) : 0;
+        pDevIns->pvInstanceDataRC               = pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_GC
+                                                ? MMHyperR3ToRC(pVM, pDevIns->pvInstanceDataR3) : NIL_RTRCPTR;
+        pDevIns->pvInstanceDataR0               = pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0
+                                                ? MMHyperR3ToR0(pVM, pDevIns->pvInstanceDataR3) : NIL_RTR0PTR;
 
         /*
@@ -913 +918 @@
         else
         {
-            while (pPrev1->Internal.s.pNextHC)
-                pPrev1 = pPrev1->Internal.s.pNextHC;
-            pPrev1->Internal.s.pNextHC = pDevIns;
+            while (pPrev1->Internal.s.pNextR3)
+                pPrev1 = pPrev1->Internal.s.pNextR3;
+            pPrev1->Internal.s.pNextR3 = pDevIns;
         }
 
@@ -924 +929 @@
         else
         {
-            while (pPrev2->Internal.s.pPerDeviceNextHC)
-                pPrev2 = pPrev2->Internal.s.pPerDeviceNextHC;
-            pPrev2->Internal.s.pPerDeviceNextHC = pDevIns;
+            while (pPrev2->Internal.s.pPerDeviceNextR3)
+                pPrev2 = pPrev2->Internal.s.pPerDeviceNextR3;
+            pPrev2->Internal.s.pPerDeviceNextR3 = pDevIns;
         }
 
@@ -967 +972 @@
     }
 
-    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
+    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
     {
         if (pDevIns->pDevReg->pfnInitComplete)
@@ -1222 +1227 @@
 
 
-/** @copydoc PDMDEVHLP::pfnIOPortRegister */
+/** @copydoc PDMDEVHLPR3::pfnIOPortRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegister(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts, RTHCPTR pvUser, PFNIOMIOPORTOUT pfnOut, PFNIOMIOPORTIN pfnIn,
                                                     PFNIOMIOPORTOUTSTRING pfnOutStr, PFNIOMIOPORTINSTRING pfnInStr, const char *pszDesc)
@@ -1229 +1234 @@
     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->pDevReg->szDeviceName, pDevIns->iInstance,
              Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc, pszDesc));
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
-
-    int rc = IOMR3IOPortRegisterR3(pDevIns->Internal.s.pVMHC, pDevIns, Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
+
+    int rc = IOMR3IOPortRegisterR3(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc);
 
     LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -1238 +1243 @@
 
 
-/** @copydoc PDMDEVHLP::pfnIOPortRegisterGC */
+/** @copydoc PDMDEVHLPR3::pfnIOPortRegisterGC */
 static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterGC(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts, RTRCPTR pvUser,
                                                       const char *pszOut, const char *pszIn,
@@ -1244 +1249 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_IOPortRegister: 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->pDevReg->szDeviceName, pDevIns->iInstance,
              Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
@@ -1258 +1263 @@
         if (pszIn)
         {
-            rc = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szGCMod, pszIn, &GCPtrIn);
+            rc = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szGCMod, pszIn, &GCPtrIn);
             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszIn)\n", pDevIns->pDevReg->szGCMod, pszIn));
         }
@@ -1264 +1269 @@
         if (pszOut && VBOX_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szGCMod, pszOut, &GCPtrOut);
+            rc = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szGCMod, pszOut, &GCPtrOut);
             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOut)\n", pDevIns->pDevReg->szGCMod, pszOut));
         }
@@ -1270 +1275 @@
         if (pszInStr && VBOX_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szGCMod, pszInStr, &GCPtrInStr);
+            rc = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szGCMod, pszInStr, &GCPtrInStr);
             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszInStr)\n", pDevIns->pDevReg->szGCMod, pszInStr));
         }
@@ -1276 +1281 @@
         if (pszOutStr && VBOX_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szGCMod, pszOutStr, &GCPtrOutStr);
+            rc = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szGCMod, pszOutStr, &GCPtrOutStr);
             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOutStr)\n", pDevIns->pDevReg->szGCMod, pszOutStr));
         }
 
         if (VBOX_SUCCESS(rc))
-            rc = IOMR3IOPortRegisterRC(pDevIns->Internal.s.pVMHC, pDevIns, Port, cPorts, pvUser, GCPtrOut, GCPtrIn, GCPtrOutStr, GCPtrInStr, pszDesc);
+            rc = IOMR3IOPortRegisterRC(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts, pvUser, GCPtrOut, GCPtrIn, GCPtrOutStr, GCPtrInStr, pszDesc);
     }
     else
@@ -1294 +1299 @@
 
 
-/** @copydoc PDMDEVHLP::pfnIOPortRegisterR0 */
+/** @copydoc PDMDEVHLPR3::pfnIOPortRegisterR0 */
 static DECLCALLBACK(int) pdmR3DevHlp_IOPortRegisterR0(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts, RTR0PTR pvUser,
                                                       const char *pszOut, const char *pszIn,
@@ -1300 +1305 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     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->pDevReg->szDeviceName, pDevIns->iInstance,
              Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
@@ -1314 +1319 @@
         if (pszIn)
         {
-            rc = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szR0Mod, pszIn, &pfnR0PtrIn);
+            rc = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszIn, &pfnR0PtrIn);
             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszIn)\n", pDevIns->pDevReg->szR0Mod, pszIn));
         }
@@ -1320 +1325 @@
         if (pszOut && VBOX_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szR0Mod, pszOut, &pfnR0PtrOut);
+            rc = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszOut, &pfnR0PtrOut);
             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOut)\n", pDevIns->pDevReg->szR0Mod, pszOut));
         }
@@ -1326 +1331 @@
         if (pszInStr && VBOX_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szR0Mod, pszInStr, &pfnR0PtrInStr);
+            rc = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszInStr, &pfnR0PtrInStr);
             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszInStr)\n", pDevIns->pDevReg->szR0Mod, pszInStr));
         }
@@ -1332 +1337 @@
         if (pszOutStr && VBOX_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szR0Mod, pszOutStr, &pfnR0PtrOutStr);
+            rc = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszOutStr, &pfnR0PtrOutStr);
             AssertMsgRC(rc, ("Failed to resolve %s.%s (pszOutStr)\n", pDevIns->pDevReg->szR0Mod, pszOutStr));
         }
 
         if (VBOX_SUCCESS(rc))
-            rc = IOMR3IOPortRegisterR0(pDevIns->Internal.s.pVMHC, pDevIns, Port, cPorts, pvUser, pfnR0PtrOut, pfnR0PtrIn, pfnR0PtrOutStr, pfnR0PtrInStr, pszDesc);
+            rc = IOMR3IOPortRegisterR0(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts, pvUser, pfnR0PtrOut, pfnR0PtrIn, pfnR0PtrOutStr, pfnR0PtrInStr, pszDesc);
     }
     else
@@ -1350 +1355 @@
 
 
-/** @copydoc PDMDEVHLP::pfnIOPortDeregister */
+/** @copydoc PDMDEVHLPR3::pfnIOPortDeregister */
 static DECLCALLBACK(int) pdmR3DevHlp_IOPortDeregister(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: Port=%#x cPorts=%#x\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
              Port, cPorts));
 
-    int rc = IOMR3IOPortDeregister(pDevIns->Internal.s.pVMHC, pDevIns, Port, cPorts);
+    int rc = IOMR3IOPortDeregister(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts);
 
     LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -1365 +1370 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMIORegister */
+/** @copydoc PDMDEVHLPR3::pfnMMIORegister */
 static DECLCALLBACK(int) pdmR3DevHlp_MMIORegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTHCPTR pvUser,
                                                   PFNIOMMMIOWRITE pfnWrite, PFNIOMMMIOREAD pfnRead, PFNIOMMMIOFILL pfnFill,
@@ -1371 +1376 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: GCPhysStart=%VGp cbRange=%#x pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p pszDesc=%p:{%s}\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, pszDesc));
 
-    int rc = IOMR3MMIORegisterR3(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc);
+    int rc = IOMR3MMIORegisterR3(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc);
 
     LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -1382 +1387 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMIORegisterGC */
+/** @copydoc PDMDEVHLPR3::pfnMMIORegisterGC */
 static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterGC(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
                                                     const char *pszWrite, const char *pszRead, const char *pszFill,
@@ -1388 +1393 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_MMIORegisterGC: caller='%s'/%d: GCPhysStart=%VGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
@@ -1402 +1407 @@
         RTGCPTR32 GCPtrWrite = 0;
         if (pszWrite)
-            rc = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szGCMod, pszWrite, &GCPtrWrite);
+            rc = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szGCMod, pszWrite, &GCPtrWrite);
         RTGCPTR32 GCPtrRead = 0;
         int rc2 = VINF_SUCCESS;
         if (pszRead)
-            rc2 = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szGCMod, pszRead, &GCPtrRead);
+            rc2 = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szGCMod, pszRead, &GCPtrRead);
         RTGCPTR32 GCPtrFill = 0;
         int rc3 = VINF_SUCCESS;
         if (pszFill)
-            rc3 = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szGCMod, pszFill, &GCPtrFill);
+            rc3 = PDMR3GetSymbolGCLazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szGCMod, pszFill, &GCPtrFill);
         if (VBOX_SUCCESS(rc) && VBOX_SUCCESS(rc2) && VBOX_SUCCESS(rc3))
-            rc = IOMR3MMIORegisterRC(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange, pvUser, GCPtrWrite, GCPtrRead, GCPtrFill);
+            rc = IOMR3MMIORegisterRC(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvUser, GCPtrWrite, GCPtrRead, GCPtrFill);
         else
         {
@@ -1434 +1439 @@
 }
 
-/** @copydoc PDMDEVHLP::pfnMMIORegisterR0 */
+/** @copydoc PDMDEVHLPR3::pfnMMIORegisterR0 */
 static DECLCALLBACK(int) pdmR3DevHlp_MMIORegisterR0(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
                                                     const char *pszWrite, const char *pszRead, const char *pszFill,
@@ -1440 +1445 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_MMIORegisterHC: caller='%s'/%d: GCPhysStart=%VGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
@@ -1454 +1459 @@
         R0PTRTYPE(PFNIOMMMIOWRITE) pfnR0PtrWrite = 0;
         if (pszWrite)
-            rc = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szR0Mod, pszWrite, &pfnR0PtrWrite);
+            rc = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszWrite, &pfnR0PtrWrite);
         R0PTRTYPE(PFNIOMMMIOREAD) pfnR0PtrRead = 0;
         int rc2 = VINF_SUCCESS;
         if (pszRead)
-            rc2 = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szR0Mod, pszRead, &pfnR0PtrRead);
+            rc2 = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszRead, &pfnR0PtrRead);
         R0PTRTYPE(PFNIOMMMIOFILL) pfnR0PtrFill = 0;
         int rc3 = VINF_SUCCESS;
         if (pszFill)
-            rc3 = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMHC, pDevIns->pDevReg->szR0Mod, pszFill, &pfnR0PtrFill);
+            rc3 = PDMR3GetSymbolR0Lazy(pDevIns->Internal.s.pVMR3, pDevIns->pDevReg->szR0Mod, pszFill, &pfnR0PtrFill);
         if (VBOX_SUCCESS(rc) && VBOX_SUCCESS(rc2) && VBOX_SUCCESS(rc3))
-            rc = IOMR3MMIORegisterR0(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange, pvUser, pfnR0PtrWrite, pfnR0PtrRead, pfnR0PtrFill);
+            rc = IOMR3MMIORegisterR0(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvUser, pfnR0PtrWrite, pfnR0PtrRead, pfnR0PtrFill);
         else
         {
@@ -1487 +1492 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMIODeregister */
+/** @copydoc PDMDEVHLPR3::pfnMMIODeregister */
 static DECLCALLBACK(int) pdmR3DevHlp_MMIODeregister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: GCPhysStart=%VGp cbRange=%#x\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange));
 
-    int rc = IOMR3MMIODeregister(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange);
+    int rc = IOMR3MMIODeregister(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange);
 
     LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -1502 +1507 @@
 
 
-/** @copydoc PDMDEVHLP::pfnROMRegister */
+/** @copydoc PDMDEVHLPR3::pfnROMRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_ROMRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, const void *pvBinary, bool fShadow, const char *pszDesc)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: GCPhysStart=%VGp cbRange=%#x pvBinary=%p fShadow=%RTbool pszDesc=%p:{%s}\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, fShadow, pszDesc, pszDesc));
 
-    int rc = MMR3PhysRomRegister(pDevIns->Internal.s.pVMHC, pDevIns, GCPhysStart, cbRange, pvBinary, fShadow, pszDesc);
+    int rc = MMR3PhysRomRegister(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvBinary, fShadow, pszDesc);
 
     LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -1517 +1522 @@
 
 
-/** @copydoc PDMDEVHLP::pfnSSMRegister */
+/** @copydoc PDMDEVHLPR3::pfnSSMRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_SSMRegister(PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
                                                  PFNSSMDEVSAVEPREP pfnSavePrep, PFNSSMDEVSAVEEXEC pfnSaveExec, PFNSSMDEVSAVEDONE pfnSaveDone,
@@ -1523 +1528 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: pszName=%p:{%s} u32Instance=%#x u32Version=#x cbGuess=%#x pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoaddone=%p\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pszName, pszName, u32Instance, u32Version, cbGuess, pfnSavePrep, pfnSaveExec, pfnSaveDone, pfnLoadPrep, pfnLoadExec, pfnLoadDone));
 
-    int rc = SSMR3Register(pDevIns->Internal.s.pVMHC, pDevIns, pszName, u32Instance, u32Version, cbGuess,
+    int rc = SSMR3Register(pDevIns->Internal.s.pVMR3, pDevIns, pszName, u32Instance, u32Version, cbGuess,
                            pfnSavePrep, pfnSaveExec, pfnSaveDone,
                            pfnLoadPrep, pfnLoadExec, pfnLoadDone);
@@ -1536 +1541 @@
 
 
-/** @copydoc PDMDEVHLP::pfnTMTimerCreate */
+/** @copydoc PDMDEVHLPR3::pfnTMTimerCreate */
 static DECLCALLBACK(int) pdmR3DevHlp_TMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, const char *pszDesc, PPTMTIMERR3 ppTimer)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pszDesc=%p:{%s} ppTimer=%p\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, enmClock, pfnCallback, pszDesc, pszDesc, ppTimer));
 
-    int rc = TMR3TimerCreateDevice(pDevIns->Internal.s.pVMHC, pDevIns, enmClock, pfnCallback, pszDesc, ppTimer);
+    int rc = TMR3TimerCreateDevice(pDevIns->Internal.s.pVMR3, pDevIns, enmClock, pfnCallback, pszDesc, ppTimer);
 
     LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -1551 +1556 @@
 
 
-/** @copydoc PDMDEVHLP::pfnTMTimerCreateExternal */
+/** @copydoc PDMDEVHLPR3::pfnTMTimerCreateExternal */
 static DECLCALLBACK(PTMTIMERR3) pdmR3DevHlp_TMTimerCreateExternal(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMEREXT pfnCallback, void *pvUser, const char *pszDesc)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
-
-    return TMR3TimerCreateExternal(pDevIns->Internal.s.pVMHC, enmClock, pfnCallback, pvUser, pszDesc);
-}
-
-/** @copydoc PDMDEVHLP::pfnPCIRegister */
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
+
+    return TMR3TimerCreateExternal(pDevIns->Internal.s.pVMR3, enmClock, pfnCallback, pvUser, pszDesc);
+}
+
+/** @copydoc PDMDEVHLPR3::pfnPCIRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_PCIRegister(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: pPciDev=%p:{.config={%#.256Vhxs}\n",
@@ -1584 +1589 @@
         return VERR_INVALID_PARAMETER;
     }
-    if (pDevIns->Internal.s.pPciDeviceHC)
+    if (pDevIns->Internal.s.pPciDeviceR3)
     {
         /** @todo the PCI device vs. PDM device designed is a bit flawed if we have to
@@ -1599 +1604 @@
      * already have one. If not, we'll just take the first one.
      */
-    PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusHC;
+    PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusR3;
     if (!pBus)
-        pBus = pDevIns->Internal.s.pPciBusHC = &pVM->pdm.s.aPciBuses[0];
+        pBus = pDevIns->Internal.s.pPciBusR3 = &pVM->pdm.s.aPciBuses[0];
     int rc;
     if (pBus)
     {
         if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_GC)
-            pDevIns->Internal.s.pPciBusGC = MMHyperHC2GC(pVM, pDevIns->Internal.s.pPciBusHC);
+            pDevIns->Internal.s.pPciBusR0 = MMHyperR3ToR0(pVM, pDevIns->Internal.s.pPciBusR3);
+        else
+            pDevIns->Internal.s.pPciBusR0 = NIL_RTR0PTR;
+
+        if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_GC)
+            pDevIns->Internal.s.pPciBusRC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciBusR3);
+        else
+            pDevIns->Internal.s.pPciBusRC = NIL_RTRCPTR;
 
         /*
@@ -1654 +1666 @@
         if (VBOX_SUCCESS(rc))
         {
-            pDevIns->Internal.s.pPciDeviceHC = pPciDev;
+            pPciDev->pDevIns = pDevIns;
+
+            pDevIns->Internal.s.pPciDeviceR3 = pPciDev;
+            if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_R0)
+                pDevIns->Internal.s.pPciDeviceR0 = MMHyperR3ToR0(pVM, pPciDev);
+            else
+                pDevIns->Internal.s.pPciDeviceR0 = NIL_RTR0PTR;
+
             if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_GC)
-                pDevIns->Internal.s.pPciDeviceGC = MMHyperHC2GC(pVM, pPciDev);
+                pDevIns->Internal.s.pPciDeviceRC = MMHyperR3ToRC(pVM, pPciDev);
             else
-                pDevIns->Internal.s.pPciDeviceGC = 0;
-            pPciDev->pDevIns = pDevIns;
+                pDevIns->Internal.s.pPciDeviceRC = NIL_RTRCPTR;
+
             Log(("PDM: Registered device '%s'/%d as PCI device %d on bus %d\n",
-                 pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pPciDev->devfn, pDevIns->Internal.s.pPciBusHC->iBus));
+                 pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pPciDev->devfn, pDevIns->Internal.s.pPciBusR3->iBus));
         }
     }
@@ -1675 +1694 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPCIIORegionRegister */
+/** @copydoc PDMDEVHLPR3::pfnPCIIORegionRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_PCIIORegionRegister(PPDMDEVINS pDevIns, int iRegion, uint32_t cbRegion, PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: iRegion=%d cbRegion=%#x enmType=%d pfnCallback=%p\n",
@@ -1716 +1735 @@
      */
     int rc;
-    PPCIDEVICE pPciDev = pDevIns->Internal.s.pPciDeviceHC;
+    PPCIDEVICE pPciDev = pDevIns->Internal.s.pPciDeviceR3;
     if (pPciDev)
     {
@@ -1730 +1749 @@
         }
 
-        PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusHC;
+        PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusR3;
         Assert(pBus);
         pdmLock(pVM);
@@ -1747 +1766 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPCISetConfigCallbacks */
+/** @copydoc PDMDEVHLPR3::pfnPCISetConfigCallbacks */
 static DECLCALLBACK(void) pdmR3DevHlp_PCISetConfigCallbacks(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PFNPCICONFIGREAD pfnRead, PPFNPCICONFIGREAD ppfnReadOld,
                                                             PFNPCICONFIGWRITE pfnWrite, PPFNPCICONFIGWRITE ppfnWriteOld)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: pPciDev=%p pfnRead=%p ppfnReadOld=%p pfnWrite=%p ppfnWriteOld=%p\n",
@@ -1767 +1786 @@
 
     if (!pPciDev)
-        pPciDev = pDevIns->Internal.s.pPciDeviceHC;
+        pPciDev = pDevIns->Internal.s.pPciDeviceR3;
     AssertReleaseMsg(pPciDev, ("You must register your device first!\n"));
-    PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusHC;
+    PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusR3;
     AssertRelease(pBus);
     AssertRelease(VMR3GetState(pVM) != VMSTATE_RUNNING);
@@ -1784 +1803 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPCISetIrq */
+/** @copydoc PDMDEVHLPR3::pfnPCISetIrq */
 static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
@@ -1798 +1817 @@
      * Must have a PCI device registered!
      */
-    PPCIDEVICE pPciDev = pDevIns->Internal.s.pPciDeviceHC;
+    PPCIDEVICE pPciDev = pDevIns->Internal.s.pPciDeviceR3;
     if (pPciDev)
     {
-        PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusHC; /** @todo the bus should be associated with the PCI device not the PDM device. */
+        PPDMPCIBUS pBus = pDevIns->Internal.s.pPciBusR3; /** @todo the bus should be associated with the PCI device not the PDM device. */
         Assert(pBus);
-        PVM pVM = pDevIns->Internal.s.pVMHC;
+        PVM pVM = pDevIns->Internal.s.pVMR3;
         pdmLock(pVM);
         pBus->pfnSetIrqR3(pBus->pDevInsR3, pPciDev, iIrq, iLevel);
@@ -1815 +1834 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPCISetIrqNoWait */
+/** @copydoc PDMDEVHLPR3::pfnPCISetIrqNoWait */
 static DECLCALLBACK(void) pdmR3DevHlp_PCISetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
@@ -1822 +1841 @@
 
 
-/** @copydoc PDMDEVHLP::pfnISASetIrq */
+/** @copydoc PDMDEVHLPR3::pfnISASetIrq */
 static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
@@ -1833 +1852 @@
     /** @todo iIrq and iLevel checks. */
 
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     PDMIsaSetIrq(pVM, iIrq, iLevel);    /* (The API takes the lock.) */
 
@@ -1840 +1859 @@
 
 
-/** @copydoc PDMDEVHLP::pfnISASetIrqNoWait */
+/** @copydoc PDMDEVHLPR3::pfnISASetIrqNoWait */
 static DECLCALLBACK(void) pdmR3DevHlp_ISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
@@ -1847 +1866 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDriverAttach */
+/** @copydoc PDMDEVHLPR3::pfnDriverAttach */
 static DECLCALLBACK(int) pdmR3DevHlp_DriverAttach(PPDMDEVINS pDevIns, RTUINT iLun, PPDMIBASE pBaseInterface, PPDMIBASE *ppBaseInterface, const char *pszDesc)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
@@ -1860 +1879 @@
      */
     PPDMLUN pLunPrev = NULL;
-    PPDMLUN pLun = pDevIns->Internal.s.pLunsHC;
+    PPDMLUN pLun = pDevIns->Internal.s.pLunsR3;
     for (; pLun; pLunPrev = pLun, pLun = pLun->pNext)
         if (pLun->iLun == iLun)
@@ -1891 +1910 @@
         pLun->pBase     = pBaseInterface;
         if (!pLunPrev)
-            pDevIns->Internal.s.pLunsHC = pLun;
+            pDevIns->Internal.s.pLunsR3 = pLun;
         else
             pLunPrev->pNext = pLun;
@@ -2018 +2037 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMHeapAlloc */
+/** @copydoc PDMDEVHLPR3::pfnMMHeapAlloc */
 static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAlloc(PPDMDEVINS pDevIns, size_t cb)
 {
@@ -2024 +2043 @@
     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, cb));
 
-    void *pv = MMR3HeapAlloc(pDevIns->Internal.s.pVMHC, MM_TAG_PDM_DEVICE_USER, cb);
+    void *pv = MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE_USER, cb);
 
     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pv));
@@ -2031 +2050 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMHeapAllocZ */
+/** @copydoc PDMDEVHLPR3::pfnMMHeapAllocZ */
 static DECLCALLBACK(void *) pdmR3DevHlp_MMHeapAllocZ(PPDMDEVINS pDevIns, size_t cb)
 {
@@ -2037 +2056 @@
     LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, cb));
 
-    void *pv = MMR3HeapAllocZ(pDevIns->Internal.s.pVMHC, MM_TAG_PDM_DEVICE_USER, cb);
+    void *pv = MMR3HeapAllocZ(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE_USER, cb);
 
     LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pv));
@@ -2044 +2063 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMHeapFree */
+/** @copydoc PDMDEVHLPR3::pfnMMHeapFree */
 static DECLCALLBACK(void) pdmR3DevHlp_MMHeapFree(PPDMDEVINS pDevIns, void *pv)
 {
@@ -2056 +2075 @@
 
 
-/** @copydoc PDMDEVHLP::pfnVMSetError */
+/** @copydoc PDMDEVHLPR3::pfnVMSetError */
 static DECLCALLBACK(int) pdmR3DevHlp_VMSetError(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
 {
@@ -2062 +2081 @@
     va_list args;
     va_start(args, pszFormat);
-    int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMHC, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc2 == rc); NOREF(rc2);
+    int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMR3, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc2 == rc); NOREF(rc2);
     va_end(args);
     return rc;
@@ -2068 +2087 @@
 
 
-/** @copydoc PDMDEVHLP::pfnVMSetErrorV */
+/** @copydoc PDMDEVHLPR3::pfnVMSetErrorV */
 static DECLCALLBACK(int) pdmR3DevHlp_VMSetErrorV(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMHC, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
-    return rc;
-}
-
-
-/** @copydoc PDMDEVHLP::pfnVMSetRuntimeError */
+    int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMR3, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
+    return rc;
+}
+
+
+/** @copydoc PDMDEVHLPR3::pfnVMSetRuntimeError */
 static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeError(PPDMDEVINS pDevIns, bool fFatal, const char *pszErrorID, const char *pszFormat, ...)
 {
@@ -2083 +2102 @@
     va_list args;
     va_start(args, pszFormat);
-    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMHC, fFatal, pszErrorID, pszFormat, args);
+    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMR3, fFatal, pszErrorID, pszFormat, args);
     va_end(args);
     return rc;
@@ -2089 +2108 @@
 
 
-/** @copydoc PDMDEVHLP::pfnVMSetRuntimeErrorV */
+/** @copydoc PDMDEVHLPR3::pfnVMSetRuntimeErrorV */
 static DECLCALLBACK(int) pdmR3DevHlp_VMSetRuntimeErrorV(PPDMDEVINS pDevIns, bool fFatal, const char *pszErrorID, const char *pszFormat, va_list va)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMHC, fFatal, pszErrorID, pszFormat, va);
-    return rc;
-}
-
-
-/** @copydoc PDMDEVHLP::pfnAssertEMT */
+    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMR3, fFatal, pszErrorID, pszFormat, va);
+    return rc;
+}
+
+
+/** @copydoc PDMDEVHLPR3::pfnAssertEMT */
 static DECLCALLBACK(bool) pdmR3DevHlp_AssertEMT(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    if (VM_IS_EMT(pDevIns->Internal.s.pVMHC))
+    if (VM_IS_EMT(pDevIns->Internal.s.pVMR3))
         return true;
 
@@ -2113 +2132 @@
 
 
-/** @copydoc PDMDEVHLP::pfnAssertOther */
+/** @copydoc PDMDEVHLPR3::pfnAssertOther */
 static DECLCALLBACK(bool) pdmR3DevHlp_AssertOther(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    if (!VM_IS_EMT(pDevIns->Internal.s.pVMHC))
+    if (!VM_IS_EMT(pDevIns->Internal.s.pVMR3))
         return true;
 
@@ -2128 +2147 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDBGFStopV */
+/** @copydoc PDMDEVHLPR3::pfnDBGFStopV */
 static DECLCALLBACK(int) pdmR3DevHlp_DBGFStopV(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction, const char *pszFormat, va_list args)
 {
@@ -2140 +2159 @@
 #endif
 
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     int rc = DBGFR3EventSrcV(pVM, DBGFEVENT_DEV_STOP, pszFile, iLine, pszFunction, pszFormat, args);
@@ -2149 +2168 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDBGFInfoRegister */
+/** @copydoc PDMDEVHLPR3::pfnDBGFInfoRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_DBGFInfoRegister(PPDMDEVINS pDevIns, const char *pszName, const char *pszDesc, PFNDBGFHANDLERDEV pfnHandler)
 {
@@ -2156 +2175 @@
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
 
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     int rc = DBGFR3InfoRegisterDevice(pVM, pszName, pszDesc, pfnHandler, pDevIns);
@@ -2165 +2184 @@
 
 
-/** @copydoc PDMDEVHLP::pfnSTAMRegister */
+/** @copydoc PDMDEVHLPR3::pfnSTAMRegister */
 static DECLCALLBACK(void) pdmR3DevHlp_STAMRegister(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, const char *pszName, STAMUNIT enmUnit, const char *pszDesc)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
 
@@ -2178 +2197 @@
 
 
-/** @copydoc PDMDEVHLP::pfnSTAMRegisterF */
+/** @copydoc 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);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
 
@@ -2196 +2215 @@
 
 
-/** @copydoc PDMDEVHLP::pfnSTAMRegisterV */
+/** @copydoc PDMDEVHLPR3::pfnSTAMRegisterV */
 static DECLCALLBACK(void) pdmR3DevHlp_STAMRegisterV(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
                                                     STAMUNIT enmUnit, const char *pszDesc, const char *pszName, va_list args)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
 
@@ -2211 +2230 @@
 
 
-/** @copydoc PDMDEVHLP::pfnRTCRegister */
+/** @copydoc PDMDEVHLPR3::pfnRTCRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_RTCRegister(PPDMDEVINS pDevIns, PCPDMRTCREG pRtcReg, PCPDMRTCHLP *ppRtcHlp)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: pRtcReg=%p:{.u32Version=%#x, .pfnWrite=%p, .pfnRead=%p} ppRtcHlp=%p\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
@@ -2252 +2271 @@
      * Only one DMA device.
      */
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     if (pVM->pdm.s.pRtc)
     {
@@ -2265 +2284 @@
      */
     int rc = VINF_SUCCESS;
-    PPDMRTC pRtc = (PPDMRTC)MMR3HeapAlloc(pDevIns->Internal.s.pVMHC, MM_TAG_PDM_DEVICE, sizeof(*pRtc));
+    PPDMRTC pRtc = (PPDMRTC)MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE, sizeof(*pRtc));
     if (pRtc)
     {
@@ -2286 +2305 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPDMQueueCreate */
+/** @copydoc PDMDEVHLPR3::pfnPDMQueueCreate */
 static DECLCALLBACK(int) pdmR3DevHlp_PDMQueueCreate(PPDMDEVINS pDevIns, RTUINT cbItem, RTUINT cItems, uint32_t cMilliesInterval,
                                                     PFNPDMQUEUEDEV pfnCallback, bool fGCEnabled, PPDMQUEUE *ppQueue)
@@ -2294 +2313 @@
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, ppQueue));
 
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     int rc = PDMR3QueueCreateDevice(pVM, pDevIns, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, ppQueue);
@@ -2303 +2322 @@
 
 
-/** @copydoc PDMDEVHLP::pfnCritSectInit */
+/** @copydoc PDMDEVHLPR3::pfnCritSectInit */
 static DECLCALLBACK(int) pdmR3DevHlp_CritSectInit(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, const char *pszName)
 {
@@ -2310 +2329 @@
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pCritSect, pszName, pszName));
 
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     int rc = pdmR3CritSectInitDevice(pVM, pDevIns, pCritSect, pszName);
@@ -2319 +2338 @@
 
 
-/** @copydoc PDMDEVHLP::pfnUTCNow */
+/** @copydoc PDMDEVHLPR3::pfnUTCNow */
 static DECLCALLBACK(PRTTIMESPEC) pdmR3DevHlp_UTCNow(PPDMDEVINS pDevIns, PRTTIMESPEC pTime)
 {
@@ -2326 +2345 @@
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pTime));
 
-    pTime = TMR3UTCNow(pDevIns->Internal.s.pVMHC, pTime);
+    pTime = TMR3UTCNow(pDevIns->Internal.s.pVMR3, pTime);
 
     LogFlow(("pdmR3DevHlp_UTCNow: caller='%s'/%d: returns %RU64\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
@@ -2333 +2352 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPDMThreadCreate */
+/** @copydoc PDMDEVHLPR3::pfnPDMThreadCreate */
 static DECLCALLBACK(int) pdmR3DevHlp_PDMThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
                                                      PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_PDMThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
 
-    int rc = pdmR3ThreadCreateDevice(pDevIns->Internal.s.pVMHC, pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
+    int rc = pdmR3ThreadCreateDevice(pDevIns->Internal.s.pVMR3, pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
 
     LogFlow(("pdmR3DevHlp_PDMThreadCreate: caller='%s'/%d: returns %Vrc *ppThread=%RTthrd\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
@@ -2350 +2369 @@
 
 
-/** @copydoc PDMDEVHLP::pfnGetVM */
+/** @copydoc PDMDEVHLPR3::pfnGetVM */
 static DECLCALLBACK(PVM) pdmR3DevHlp_GetVM(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns->Internal.s.pVMHC));
-    return pDevIns->Internal.s.pVMHC;
-}
-
-
-/** @copydoc PDMDEVHLP::pfnPCIBusRegister */
+    LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns->Internal.s.pVMR3));
+    return pDevIns->Internal.s.pVMR3;
+}
+
+
+/** @copydoc PDMDEVHLPR3::pfnPCIBusRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_PCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREG pPciBusReg, PCPDMPCIHLPR3 *ppPciHlpR3)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: pPciBusReg=%p:{.u32Version=%#x, .pfnRegisterR3=%p, .pfnIORegionRegisterR3=%p, .pfnSetIrqR3=%p, "
@@ -2494 +2513 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPICRegister */
+/** @copydoc PDMDEVHLPR3::pfnPICRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLPR3 *ppPicHlpR3)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     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->pDevReg->szDeviceName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrqR3, pPicReg->pfnGetInterruptR3,
@@ -2557 +2576 @@
      * Only one PIC device.
      */
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     if (pVM->pdm.s.Pic.pDevInsR3)
     {
@@ -2633 +2652 @@
 
 
-/** @copydoc PDMDEVHLP::pfnAPICRegister */
+/** @copydoc PDMDEVHLPR3::pfnAPICRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_APICRegister(PPDMDEVINS pDevIns, PPDMAPICREG pApicReg, PCPDMAPICHLPR3 *ppApicHlpR3)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: pApicReg=%p:{.u32Version=%#x, .pfnGetInterruptR3=%p, .pfnSetBaseR3=%p, .pfnGetBaseR3=%p, "
              ".pfnSetTPRR3=%p, .pfnGetTPRR3=%p, .pfnBusDeliverR3=%p, pszGetInterruptRC=%p:{%s}, pszSetBaseRC=%p:{%s}, pszGetBaseRC=%p:{%s}, "
@@ -2736 +2755 @@
      * Only one APIC device. (malc: only in UP case actually)
      */
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     if (pVM->pdm.s.Apic.pDevInsR3)
     {
@@ -2877 +2896 @@
 
 
-/** @copydoc PDMDEVHLP::pfnIOAPICRegister */
+/** @copydoc PDMDEVHLPR3::pfnIOAPICRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_IOAPICRegister(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLPR3 *ppIoApicHlpR3)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppIoApicHlpR3=%p\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrqR3,
@@ -2926 +2945 @@
      * If the I/O APIC does GC stuff so must the APIC.
      */
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     if (!pVM->pdm.s.Apic.pDevInsR3)
     {
@@ -3006 +3025 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDMACRegister */
+/** @copydoc PDMDEVHLPR3::pfnDMACRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_DMACRegister(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: pDmacReg=%p:{.u32Version=%#x, .pfnRun=%p, .pfnRegister=%p, .pfnReadMemory=%p, .pfnWriteMemory=%p, .pfnSetDREQ=%p, .pfnGetChannelMode=%p} ppDmacHlp=%p\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
@@ -3055 +3074 @@
      * Only one DMA device.
      */
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     if (pVM->pdm.s.pDmac)
     {
@@ -3068 +3087 @@
      */
     int rc = VINF_SUCCESS;
-    PPDMDMAC  pDmac = (PPDMDMAC)MMR3HeapAlloc(pDevIns->Internal.s.pVMHC, MM_TAG_PDM_DEVICE, sizeof(*pDmac));
+    PPDMDMAC  pDmac = (PPDMDMAC)MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE, sizeof(*pDmac));
     if (pDmac)
     {
@@ -3089 +3108 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysRead */
+/** @copydoc PDMDEVHLPR3::pfnPhysRead */
 static DECLCALLBACK(void) pdmR3DevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
 {
@@ -3101 +3120 @@
      */
 #ifdef PDM_PHYS_READWRITE_FROM_ANY_THREAD
-    PGMPhysRead(pDevIns->Internal.s.pVMHC, GCPhys, pvBuf, cbRead);
+    PGMPhysRead(pDevIns->Internal.s.pVMR3, GCPhys, pvBuf, cbRead);
 #else
-    if (VM_IS_EMT(pDevIns->Internal.s.pVMHC) || VMMR3LockIsOwner(pDevIns->Internal.s.pVMHC))
-        PGMPhysRead(pDevIns->Internal.s.pVMHC, GCPhys, pvBuf, cbRead);
+    if (VM_IS_EMT(pDevIns->Internal.s.pVMR3) || VMMR3LockIsOwner(pDevIns->Internal.s.pVMR3))
+        PGMPhysRead(pDevIns->Internal.s.pVMR3, GCPhys, pvBuf, cbRead);
     else
     {
@@ -3110 +3129 @@
         PVMREQ pReq;
         AssertCompileSize(RTGCPHYS, 4);
-        int rc = VMR3ReqCallVoid(pDevIns->Internal.s.pVMHC, &pReq, RT_INDEFINITE_WAIT,
-                                 (PFNRT)PGMPhysRead, 4, pDevIns->Internal.s.pVMHC, GCPhys, pvBuf, cbRead);
+        int rc = VMR3ReqCallVoid(pDevIns->Internal.s.pVMR3, &pReq, RT_INDEFINITE_WAIT,
+                                 (PFNRT)PGMPhysRead, 4, pDevIns->Internal.s.pVMR3, GCPhys, pvBuf, cbRead);
         while (rc == VERR_TIMEOUT)
             rc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
@@ -3122 +3141 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysWrite */
+/** @copydoc PDMDEVHLPR3::pfnPhysWrite */
 static DECLCALLBACK(void) pdmR3DevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
 {
@@ -3134 +3153 @@
      */
 #ifdef PDM_PHYS_READWRITE_FROM_ANY_THREAD
-    PGMPhysWrite(pDevIns->Internal.s.pVMHC, GCPhys, pvBuf, cbWrite);
+    PGMPhysWrite(pDevIns->Internal.s.pVMR3, GCPhys, pvBuf, cbWrite);
 #else
-    if (VM_IS_EMT(pDevIns->Internal.s.pVMHC) || VMMR3LockIsOwner(pDevIns->Internal.s.pVMHC))
-        PGMPhysWrite(pDevIns->Internal.s.pVMHC, GCPhys, pvBuf, cbWrite);
+    if (VM_IS_EMT(pDevIns->Internal.s.pVMR3) || VMMR3LockIsOwner(pDevIns->Internal.s.pVMR3))
+        PGMPhysWrite(pDevIns->Internal.s.pVMR3, GCPhys, pvBuf, cbWrite);
     else
     {
@@ -3143 +3162 @@
         PVMREQ pReq;
         AssertCompileSize(RTGCPHYS, 4);
-        int rc = VMR3ReqCallVoid(pDevIns->Internal.s.pVMHC, &pReq, RT_INDEFINITE_WAIT,
-                                 (PFNRT)PGMPhysWrite, 4, pDevIns->Internal.s.pVMHC, GCPhys, pvBuf, cbWrite);
+        int rc = VMR3ReqCallVoid(pDevIns->Internal.s.pVMR3, &pReq, RT_INDEFINITE_WAIT,
+                                 (PFNRT)PGMPhysWrite, 4, pDevIns->Internal.s.pVMR3, GCPhys, pvBuf, cbWrite);
         while (rc == VERR_TIMEOUT)
             rc = VMR3ReqWait(pReq, RT_INDEFINITE_WAIT);
@@ -3155 +3174 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysReadGCVirt */
+/** @copydoc PDMDEVHLPR3::pfnPhysReadGCVirt */
 static DECLCALLBACK(int) pdmR3DevHlp_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: pvDst=%p GCVirt=%VGv cb=%#x\n",
@@ -3175 +3194 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysWriteGCVirt */
+/** @copydoc PDMDEVHLPR3::pfnPhysWriteGCVirt */
 static DECLCALLBACK(int) pdmR3DevHlp_PhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: GCVirtDst=%VGv pvSrc=%p cb=%#x\n",
@@ -3195 +3214 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysReserve */
+/** @copydoc PDMDEVHLPR3::pfnPhysReserve */
 static DECLCALLBACK(int) pdmR3DevHlp_PhysReserve(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTUINT cbRange, const char *pszDesc)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_PhysReserve: caller='%s'/%d: GCPhys=%VGp cbRange=%#x pszDesc=%p:{%s}\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhys, cbRange, pszDesc, pszDesc));
 
-    int rc = MMR3PhysReserve(pDevIns->Internal.s.pVMHC, GCPhys, cbRange, pszDesc);
+    int rc = MMR3PhysReserve(pDevIns->Internal.s.pVMR3, GCPhys, cbRange, pszDesc);
 
     LogFlow(("pdmR3DevHlp_PhysReserve: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -3211 +3230 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysGCPtr2GCPhys */
+/** @copydoc PDMDEVHLPR3::pfnPhysGCPtr2GCPhys */
 static DECLCALLBACK(int) pdmR3DevHlp_PhysGCPtr2GCPhys(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: GCPtr=%VGv pGCPhys=%p\n",
@@ -3231 +3250 @@
 
 
-/** @copydoc PDMDEVHLP::pfnVMState */
+/** @copydoc PDMDEVHLPR3::pfnVMState */
 static DECLCALLBACK(VMSTATE) pdmR3DevHlp_VMState(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
 
-    VMSTATE enmVMState = VMR3GetState(pDevIns->Internal.s.pVMHC);
+    VMSTATE enmVMState = VMR3GetState(pDevIns->Internal.s.pVMR3);
 
     LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d (%s)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance,
@@ -3244 +3263 @@
 
 
-/** @copydoc PDMDEVHLP::pfnA20IsEnabled */
+/** @copydoc PDMDEVHLPR3::pfnA20IsEnabled */
 static DECLCALLBACK(bool) pdmR3DevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
-
-    bool fRc = PGMPhysIsA20Enabled(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
+
+    bool fRc = PGMPhysIsA20Enabled(pDevIns->Internal.s.pVMR3);
 
     LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, fRc));
@@ -3257 +3276 @@
 
 
-/** @copydoc PDMDEVHLP::pfnA20Set */
+/** @copydoc PDMDEVHLPR3::pfnA20Set */
 static DECLCALLBACK(void) pdmR3DevHlp_A20Set(PPDMDEVINS pDevIns, bool fEnable)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, fEnable));
     //Assert(*(unsigned *)&fEnable <= 1);
-    PGMR3PhysSetA20(pDevIns->Internal.s.pVMHC, fEnable);
-}
-
-
-/** @copydoc PDMDEVHLP::pfnVMReset */
+    PGMR3PhysSetA20(pDevIns->Internal.s.pVMR3, fEnable);
+}
+
+
+/** @copydoc PDMDEVHLPR3::pfnVMReset */
 static DECLCALLBACK(int) pdmR3DevHlp_VMReset(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: VM_FF_RESET %d -> 1\n",
@@ -3300 +3319 @@
 
 
-/** @copydoc PDMDEVHLP::pfnVMSuspend */
+/** @copydoc PDMDEVHLPR3::pfnVMSuspend */
 static DECLCALLBACK(int) pdmR3DevHlp_VMSuspend(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d:\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
 
-    int rc = VMR3Suspend(pDevIns->Internal.s.pVMHC);
+    int rc = VMR3Suspend(pDevIns->Internal.s.pVMR3);
 
     LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -3315 +3334 @@
 
 
-/** @copydoc PDMDEVHLP::pfnVMPowerOff */
+/** @copydoc PDMDEVHLPR3::pfnVMPowerOff */
 static DECLCALLBACK(int) pdmR3DevHlp_VMPowerOff(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d:\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
 
-    int rc = VMR3PowerOff(pDevIns->Internal.s.pVMHC);
+    int rc = VMR3PowerOff(pDevIns->Internal.s.pVMR3);
 
     LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -3330 +3349 @@
 
 
-/** @copydoc PDMDEVHLP::pfnLockVM */
+/** @copydoc PDMDEVHLPR3::pfnLockVM */
 static DECLCALLBACK(int) pdmR3DevHlp_LockVM(PPDMDEVINS pDevIns)
 {
-    return VMMR3Lock(pDevIns->Internal.s.pVMHC);
-}
-
-
-/** @copydoc PDMDEVHLP::pfnUnlockVM */
+    return VMMR3Lock(pDevIns->Internal.s.pVMR3);
+}
+
+
+/** @copydoc PDMDEVHLPR3::pfnUnlockVM */
 static DECLCALLBACK(int) pdmR3DevHlp_UnlockVM(PPDMDEVINS pDevIns)
 {
-    return VMMR3Unlock(pDevIns->Internal.s.pVMHC);
-}
-
-
-/** @copydoc PDMDEVHLP::pfnAssertVMLock */
+    return VMMR3Unlock(pDevIns->Internal.s.pVMR3);
+}
+
+
+/** @copydoc PDMDEVHLPR3::pfnAssertVMLock */
 static DECLCALLBACK(bool) pdmR3DevHlp_AssertVMLock(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction)
 {
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     if (VMMR3LockIsOwner(pVM))
         return true;
@@ -3362 +3381 @@
 }
 
-/** @copydoc PDMDEVHLP::pfnDMARegister */
+/** @copydoc PDMDEVHLPR3::pfnDMARegister */
 static DECLCALLBACK(int) pdmR3DevHlp_DMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: uChannel=%d pfnTransferHandler=%p pvUser=%p\n",
@@ -3383 +3402 @@
 }
 
-/** @copydoc PDMDEVHLP::pfnDMAReadMemory */
+/** @copydoc PDMDEVHLPR3::pfnDMAReadMemory */
 static DECLCALLBACK(int) pdmR3DevHlp_DMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbRead)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbRead=%p\n",
@@ -3408 +3427 @@
 }
 
-/** @copydoc PDMDEVHLP::pfnDMAWriteMemory */
+/** @copydoc PDMDEVHLPR3::pfnDMAWriteMemory */
 static DECLCALLBACK(int) pdmR3DevHlp_DMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbWritten)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbWritten=%p\n",
@@ -3433 +3452 @@
 }
 
-/** @copydoc PDMDEVHLP::pfnDMASetDREQ */
+/** @copydoc PDMDEVHLPR3::pfnDMASetDREQ */
 static DECLCALLBACK(int) pdmR3DevHlp_DMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: uChannel=%d uLevel=%d\n",
@@ -3454 +3473 @@
 }
 
-/** @copydoc PDMDEVHLP::pfnDMAGetChannelMode */
+/** @copydoc PDMDEVHLPR3::pfnDMAGetChannelMode */
 static DECLCALLBACK(uint8_t) pdmR3DevHlp_DMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: uChannel=%d\n",
@@ -3475 +3494 @@
 }
 
-/** @copydoc PDMDEVHLP::pfnDMASchedule */
+/** @copydoc PDMDEVHLPR3::pfnDMASchedule */
 static DECLCALLBACK(void) pdmR3DevHlp_DMASchedule(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
     LogFlow(("pdmR3DevHlp_DMASchedule: caller='%s'/%d: VM_FF_PDM_DMA %d -> 1\n",
@@ -3491 +3510 @@
 
 
-/** @copydoc PDMDEVHLP::pfnCMOSWrite */
+/** @copydoc PDMDEVHLPR3::pfnCMOSWrite */
 static DECLCALLBACK(int) pdmR3DevHlp_CMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
 
@@ -3512 +3531 @@
 
 
-/** @copydoc PDMDEVHLP::pfnCMOSRead */
+/** @copydoc PDMDEVHLPR3::pfnCMOSRead */
 static DECLCALLBACK(int) pdmR3DevHlp_CMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     VM_ASSERT_EMT(pVM);
 
@@ -3533 +3552 @@
 
 
-/** @copydoc PDMDEVHLP::pfnGetCpuId */
+/** @copydoc PDMDEVHLPR3::pfnGetCpuId */
 static DECLCALLBACK(void) pdmR3DevHlp_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
                                                uint32_t *pEax, uint32_t *pEbx, uint32_t *pEcx, uint32_t *pEdx)
@@ -3542 +3561 @@
     AssertPtr(pEax); AssertPtr(pEbx); AssertPtr(pEcx); AssertPtr(pEdx);
 
-    CPUMGetGuestCpuId(pDevIns->Internal.s.pVMHC, iLeaf, pEax, pEbx, pEcx, pEdx);
+    CPUMGetGuestCpuId(pDevIns->Internal.s.pVMR3, iLeaf, pEax, pEbx, pEcx, pEdx);
 
     LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - *pEax=%#x *pEbx=%#x *pEcx=%#x *pEdx=%#x\n",
@@ -3549 +3568 @@
 
 
-/** @copydoc PDMDEVHLP::pfnROMProtectShadow */
+/** @copydoc PDMDEVHLPR3::pfnROMProtectShadow */
 static DECLCALLBACK(int) pdmR3DevHlp_ROMProtectShadow(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange)
 {
@@ -3556 +3575 @@
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange));
 
-    int rc = MMR3PhysRomProtect(pDevIns->Internal.s.pVMHC, GCPhysStart, cbRange);
+    int rc = MMR3PhysRomProtect(pDevIns->Internal.s.pVMR3, GCPhysStart, cbRange);
 
     LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Vrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -3564 +3583 @@
 
 /**
- * @copydoc PDMDEVHLP::pfnMMIO2Register
+ * @copydoc PDMDEVHLPR3::pfnMMIO2Register
  */
 static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Register(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cb, uint32_t fFlags, void **ppv, const char *pszDesc)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: iRegion=#x cb=%#RGp fFlags=%RX32 ppv=%p pszDescp=%p:{%s}\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion, cb, fFlags, ppv, pszDesc, pszDesc));
 
-    int rc = PGMR3PhysMMIO2Register(pDevIns->Internal.s.pVMHC, pDevIns, iRegion, cb, fFlags, ppv, pszDesc);
+    int rc = PGMR3PhysMMIO2Register(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, cb, fFlags, ppv, pszDesc);
 
     LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -3581 +3600 @@
 
 /**
- * @copydoc PDMDEVHLP::pfnMMIO2Deregister
+ * @copydoc PDMDEVHLPR3::pfnMMIO2Deregister
  */
 static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Deregister(PPDMDEVINS pDevIns, uint32_t iRegion)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_MMIO2Deregister: caller='%s'/%d: iRegion=#x\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion));
@@ -3592 +3611 @@
     AssertReturn(iRegion == UINT32_MAX, VERR_INVALID_PARAMETER);
 
-    int rc = PGMR3PhysMMIO2Deregister(pDevIns->Internal.s.pVMHC, pDevIns, iRegion);
+    int rc = PGMR3PhysMMIO2Deregister(pDevIns->Internal.s.pVMR3, pDevIns, iRegion);
 
     LogFlow(("pdmR3DevHlp_MMIO2Deregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -3600 +3619 @@
 
 /**
- * @copydoc PDMDEVHLP::pfnMMIO2Map
+ * @copydoc PDMDEVHLPR3::pfnMMIO2Map
  */
 static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Map(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_MMIO2Map: caller='%s'/%d: iRegion=#x GCPhys=%#RGp\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion, GCPhys));
 
-    int rc = PGMR3PhysMMIO2Map(pDevIns->Internal.s.pVMHC, pDevIns, iRegion, GCPhys);
+    int rc = PGMR3PhysMMIO2Map(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, GCPhys);
 
     LogFlow(("pdmR3DevHlp_MMIO2Map: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -3617 +3636 @@
 
 /**
- * @copydoc PDMDEVHLP::pfnMMIO2Unmap
+ * @copydoc PDMDEVHLPR3::pfnMMIO2Unmap
  */
 static DECLCALLBACK(int) pdmR3DevHlp_MMIO2Unmap(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_MMIO2Unmap: caller='%s'/%d: iRegion=#x GCPhys=%#RGp\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion, GCPhys));
 
-    int rc = PGMR3PhysMMIO2Unmap(pDevIns->Internal.s.pVMHC, pDevIns, iRegion, GCPhys);
+    int rc = PGMR3PhysMMIO2Unmap(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, GCPhys);
 
     LogFlow(("pdmR3DevHlp_MMIO2Unmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
@@ -3634 +3653 @@
 
 /**
- * @copydoc PDMDEVHLP::pfnMMHyperMapMMIO2
+ * @copydoc PDMDEVHLPR3::pfnMMHyperMapMMIO2
  */
 static DECLCALLBACK(int) pdmR3DevHlp_MMHyperMapMMIO2(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, RTGCPHYS cb,
@@ -3640 +3659 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: iRegion=#x off=%RGp cb=%RGp pszDesc=%p:{%s} pRCPtr=%p\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
 
-    int rc = MMR3HyperMapMMIO2(pDevIns->Internal.s.pVMHC, pDevIns, iRegion, off, cb, pszDesc, pRCPtr);
+    int rc = MMR3HyperMapMMIO2(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, off, cb, pszDesc, pRCPtr);
 
     LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: returns %Rrc *pRCPtr=%RRv\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc, *pRCPtr));
@@ -3652 +3671 @@
 
 /**
- * @copydoc PDMDEVHLP::pfnRegisterVMMDevHeap
+ * @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
  */
 static DECLCALLBACK(int) pdmR3DevHlp_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
-
-    int rc = PDMR3RegisterVMMDevHeap(pDevIns->Internal.s.pVMHC, GCPhys, pvHeap, cbSize);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
+
+    int rc = PDMR3RegisterVMMDevHeap(pDevIns->Internal.s.pVMR3, GCPhys, pvHeap, cbSize);
     return rc;
 }
@@ -3665 +3684 @@
 
 /**
- * @copydoc PDMDEVHLP::pfnUnregisterVMMDevHeap
+ * @copydoc PDMDEVHLPR3::pfnUnregisterVMMDevHeap
  */
 static DECLCALLBACK(int) pdmR3DevHlp_UnregisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
-
-    int rc = PDMR3UnregisterVMMDevHeap(pDevIns->Internal.s.pVMHC, GCPhys);
-    return rc;
-}
-
-
-
-
-
-/** @copydoc PDMDEVHLP::pfnGetVM */
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
+
+    int rc = PDMR3UnregisterVMMDevHeap(pDevIns->Internal.s.pVMR3, GCPhys);
+    return rc;
+}
+
+
+
+
+
+/** @copydoc PDMDEVHLPR3::pfnGetVM */
 static DECLCALLBACK(PVM) pdmR3DevHlp_Untrusted_GetVM(PPDMDEVINS pDevIns)
 {
@@ -3689 +3708 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPCIBusRegister */
+/** @copydoc PDMDEVHLPR3::pfnPCIBusRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_PCIBusRegister(PPDMDEVINS pDevIns, PPDMPCIBUSREG pPciBusReg, PCPDMPCIHLPR3 *ppPciHlpR3)
 {
@@ -3700 +3719 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPICRegister */
+/** @copydoc PDMDEVHLPR3::pfnPICRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_PICRegister(PPDMDEVINS pDevIns, PPDMPICREG pPicReg, PCPDMPICHLPR3 *ppPicHlpR3)
 {
@@ -3711 +3730 @@
 
 
-/** @copydoc PDMDEVHLP::pfnAPICRegister */
+/** @copydoc PDMDEVHLPR3::pfnAPICRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_APICRegister(PPDMDEVINS pDevIns, PPDMAPICREG pApicReg, PCPDMAPICHLPR3 *ppApicHlpR3)
 {
@@ -3722 +3741 @@
 
 
-/** @copydoc PDMDEVHLP::pfnIOAPICRegister */
+/** @copydoc PDMDEVHLPR3::pfnIOAPICRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_IOAPICRegister(PPDMDEVINS pDevIns, PPDMIOAPICREG pIoApicReg, PCPDMIOAPICHLPR3 *ppIoApicHlpR3)
 {
@@ -3733 +3752 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDMACRegister */
+/** @copydoc PDMDEVHLPR3::pfnDMACRegister */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_DMACRegister(PPDMDEVINS pDevIns, PPDMDMACREG pDmacReg, PCPDMDMACHLP *ppDmacHlp)
 {
@@ -3744 +3763 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysRead */
+/** @copydoc PDMDEVHLPR3::pfnPhysRead */
 static DECLCALLBACK(void) pdmR3DevHlp_Untrusted_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
 {
@@ -3755 +3774 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysWrite */
+/** @copydoc PDMDEVHLPR3::pfnPhysWrite */
 static DECLCALLBACK(void) pdmR3DevHlp_Untrusted_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
 {
@@ -3766 +3785 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysReadGCVirt */
+/** @copydoc PDMDEVHLPR3::pfnPhysReadGCVirt */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_PhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
 {
@@ -3778 +3797 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysWriteGCVirt */
+/** @copydoc PDMDEVHLPR3::pfnPhysWriteGCVirt */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_PhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
 {
@@ -3790 +3809 @@
 
 
-/** @copydoc PDMDEVHLP::pfnPhysReserve */
+/** @copydoc PDMDEVHLPR3::pfnPhysReserve */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_PhysReserve(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTUINT cbRange, const char *pszDesc)
 {
@@ -3801 +3820 @@
 
 
-/** @copydoc PDMDEVHLP::pfnObsoletePhys2HCVirt */
+/** @copydoc PDMDEVHLPR3::pfnObsoletePhys2HCVirt */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_Obsolete_Phys2HCVirt(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTUINT cbRange, PRTHCPTR ppvHC)
 {
@@ -3813 +3832 @@
 
 
-/** @copydoc PDMDEVHLP::pfnObsoletePhysGCPtr2HCPtr */
+/** @copydoc PDMDEVHLPR3::pfnObsoletePhysGCPtr2HCPtr */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_Obsolete_PhysGCPtr2HCPtr(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTHCPTR pHCPtr)
 {
@@ -3824 +3843 @@
 
 
-/** @copydoc PDMDEVHLP::pfnA20IsEnabled */
+/** @copydoc PDMDEVHLPR3::pfnA20IsEnabled */
 static DECLCALLBACK(bool) pdmR3DevHlp_Untrusted_A20IsEnabled(PPDMDEVINS pDevIns)
 {
@@ -3833 +3852 @@
 
 
-/** @copydoc PDMDEVHLP::pfnA20Set */
+/** @copydoc PDMDEVHLPR3::pfnA20Set */
 static DECLCALLBACK(void) pdmR3DevHlp_Untrusted_A20Set(PPDMDEVINS pDevIns, bool fEnable)
 {
@@ -3842 +3861 @@
 
 
-/** @copydoc PDMDEVHLP::pfnVMReset */
+/** @copydoc PDMDEVHLPR3::pfnVMReset */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMReset(PPDMDEVINS pDevIns)
 {
@@ -3851 +3870 @@
 
 
-/** @copydoc PDMDEVHLP::pfnVMSuspend */
+/** @copydoc PDMDEVHLPR3::pfnVMSuspend */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMSuspend(PPDMDEVINS pDevIns)
 {
@@ -3860 +3879 @@
 
 
-/** @copydoc PDMDEVHLP::pfnVMPowerOff */
+/** @copydoc PDMDEVHLPR3::pfnVMPowerOff */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMPowerOff(PPDMDEVINS pDevIns)
 {
@@ -3869 +3888 @@
 
 
-/** @copydoc PDMDEVHLP::pfnLockVM */
+/** @copydoc PDMDEVHLPR3::pfnLockVM */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_LockVM(PPDMDEVINS pDevIns)
 {
@@ -3878 +3897 @@
 
 
-/** @copydoc PDMDEVHLP::pfnUnlockVM */
+/** @copydoc PDMDEVHLPR3::pfnUnlockVM */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_UnlockVM(PPDMDEVINS pDevIns)
 {
@@ -3887 +3906 @@
 
 
-/** @copydoc PDMDEVHLP::pfnAssertVMLock */
+/** @copydoc PDMDEVHLPR3::pfnAssertVMLock */
 static DECLCALLBACK(bool) pdmR3DevHlp_Untrusted_AssertVMLock(PPDMDEVINS pDevIns, const char *pszFile, unsigned iLine, const char *pszFunction)
 {
@@ -3896 +3915 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDMARegister */
+/** @copydoc PDMDEVHLPR3::pfnDMARegister */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_DMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
 {
@@ -3905 +3924 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDMAReadMemory */
+/** @copydoc PDMDEVHLPR3::pfnDMAReadMemory */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_DMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbRead)
 {
@@ -3916 +3935 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDMAWriteMemory */
+/** @copydoc PDMDEVHLPR3::pfnDMAWriteMemory */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_DMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbWritten)
 {
@@ -3927 +3946 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDMASetDREQ */
+/** @copydoc PDMDEVHLPR3::pfnDMASetDREQ */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_DMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
 {
@@ -3936 +3955 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDMAGetChannelMode */
+/** @copydoc PDMDEVHLPR3::pfnDMAGetChannelMode */
 static DECLCALLBACK(uint8_t) pdmR3DevHlp_Untrusted_DMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
 {
@@ -3945 +3964 @@
 
 
-/** @copydoc PDMDEVHLP::pfnDMASchedule */
+/** @copydoc PDMDEVHLPR3::pfnDMASchedule */
 static DECLCALLBACK(void) pdmR3DevHlp_Untrusted_DMASchedule(PPDMDEVINS pDevIns)
 {
@@ -3953 +3972 @@
 
 
-/** @copydoc PDMDEVHLP::pfnCMOSWrite */
+/** @copydoc PDMDEVHLPR3::pfnCMOSWrite */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_CMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
 {
@@ -3962 +3981 @@
 
 
-/** @copydoc PDMDEVHLP::pfnCMOSRead */
+/** @copydoc PDMDEVHLPR3::pfnCMOSRead */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_CMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
 {
@@ -3971 +3990 @@
 
 
-/** @copydoc PDMDEVHLP::pfnGetCpuId */
+/** @copydoc PDMDEVHLPR3::pfnGetCpuId */
 static DECLCALLBACK(void) pdmR3DevHlp_Untrusted_GetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf,
                                                          uint32_t *pEax, uint32_t *pEbx, uint32_t *pEcx, uint32_t *pEdx)
@@ -3980 +3999 @@
 
 
-/** @copydoc PDMDEVHLP::pfnROMProtectShadow */
+/** @copydoc PDMDEVHLPR3::pfnROMProtectShadow */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_ROMProtectShadow(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange)
 {
@@ -3989 +4008 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMIO2Register */
+/** @copydoc PDMDEVHLPR3::pfnMMIO2Register */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_MMIO2Register(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cb, uint32_t fFlags, void **ppv, const char *pszDesc)
 {
@@ -3998 +4017 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMIO2Deregister */
+/** @copydoc PDMDEVHLPR3::pfnMMIO2Deregister */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_MMIO2Deregister(PPDMDEVINS pDevIns, uint32_t iRegion)
 {
@@ -4007 +4026 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMIO2Map */
+/** @copydoc PDMDEVHLPR3::pfnMMIO2Map */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_MMIO2Map(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys)
 {
@@ -4016 +4035 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMIO2Unmap */
+/** @copydoc PDMDEVHLPR3::pfnMMIO2Unmap */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_MMIO2Unmap(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys)
 {
@@ -4025 +4044 @@
 
 
-/** @copydoc PDMDEVHLP::pfnMMHyperMapMMIO2 */
+/** @copydoc PDMDEVHLPR3::pfnMMHyperMapMMIO2 */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_MMHyperMapMMIO2(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, RTGCPHYS cb, const char *pszDesc, PRTRCPTR pRCPtr)
 {
@@ -4034 +4053 @@
 
 
-/** @copydoc PDMDEVHLP::pfnRegisterVMMDevHeap */
+/** @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_RegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize)
 {
@@ -4043 +4062 @@
 
 
-/** @copydoc PDMDEVHLP::pfnUnregisterVMMDevHeap */
+/** @copydoc PDMDEVHLPR3::pfnUnregisterVMMDevHeap */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_UnregisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
 {
@@ -4059 +4078 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     LogFlow(("pdmR3PicHlp_SetInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT_PIC %d -> 1\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pVM, 0, VM_FF_INTERRUPT_PIC)));
@@ -4074 +4093 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     LogFlow(("pdmR3PicHlp_ClearInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT_PIC %d -> 0\n",
-             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMHC, 0, VM_FF_INTERRUPT_PIC)));
+             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMR3, 0, VM_FF_INTERRUPT_PIC)));
     /* for PIC we always deliver to CPU 0, MP use APIC */
-    VMCPU_FF_CLEAR(pDevIns->Internal.s.pVMHC, 0, VM_FF_INTERRUPT_PIC);
-    REMR3NotifyInterruptClear(pDevIns->Internal.s.pVMHC);
+    VMCPU_FF_CLEAR(pDevIns->Internal.s.pVMR3, 0, VM_FF_INTERRUPT_PIC);
+    REMR3NotifyInterruptClear(pDevIns->Internal.s.pVMR3);
 }
 
@@ -4085 +4104 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMHC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMR3, rc);
 }
 
@@ -4093 +4112 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMHC);
+    pdmUnlock(pDevIns->Internal.s.pVMR3);
 }
 
@@ -4101 +4120 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     RTRCPTR pRCHelpers = 0;
-    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMHC, NULL, "g_pdmRCPicHlp", &pRCHelpers);
+    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMR3, NULL, "g_pdmRCPicHlp", &pRCHelpers);
     AssertReleaseRC(rc);
     AssertRelease(pRCHelpers);
@@ -4116 +4135 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     PCPDMPICHLPR0 pR0Helpers = 0;
-    int rc = PDMR3GetSymbolR0(pDevIns->Internal.s.pVMHC, NULL, "g_pdmR0PicHlp", &pR0Helpers);
+    int rc = PDMR3GetSymbolR0(pDevIns->Internal.s.pVMR3, NULL, "g_pdmR0PicHlp", &pR0Helpers);
     AssertReleaseRC(rc);
     AssertRelease(pR0Helpers);
@@ -4131 +4150 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     LogFlow(("pdmR3ApicHlp_SetInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT %d -> 1\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pVM, idCpu, VM_FF_INTERRUPT_APIC)));
@@ -4145 +4164 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     LogFlow(("pdmR3ApicHlp_ClearInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT %d -> 0\n",
-             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMHC, idCpu, VM_FF_INTERRUPT_APIC)));
-    VMCPU_FF_CLEAR(pDevIns->Internal.s.pVMHC, idCpu, VM_FF_INTERRUPT_APIC);
-    REMR3NotifyInterruptClear(pDevIns->Internal.s.pVMHC);
+             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMR3, idCpu, VM_FF_INTERRUPT_APIC)));
+    VMCPU_FF_CLEAR(pDevIns->Internal.s.pVMR3, idCpu, VM_FF_INTERRUPT_APIC);
+    REMR3NotifyInterruptClear(pDevIns->Internal.s.pVMR3);
 }
 
@@ -4158 +4177 @@
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, fEnabled));
     if (fEnabled)
-        CPUMSetGuestCpuIdFeature(pDevIns->Internal.s.pVMHC, CPUMCPUIDFEATURE_APIC);
+        CPUMSetGuestCpuIdFeature(pDevIns->Internal.s.pVMR3, CPUMCPUIDFEATURE_APIC);
     else
-        CPUMClearGuestCpuIdFeature(pDevIns->Internal.s.pVMHC, CPUMCPUIDFEATURE_APIC);
+        CPUMClearGuestCpuIdFeature(pDevIns->Internal.s.pVMR3, CPUMCPUIDFEATURE_APIC);
 }
 
@@ -4167 +4186 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMHC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMR3, rc);
 }
 
@@ -4175 +4194 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMHC);
+    pdmUnlock(pDevIns->Internal.s.pVMR3);
 }
 
@@ -4183 +4202 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return VMMGetCpuId(pDevIns->Internal.s.pVMHC);
+    return VMMGetCpuId(pDevIns->Internal.s.pVMR3);
 }
 
@@ -4191 +4210 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     RTRCPTR pRCHelpers = 0;
-    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMHC, NULL, "g_pdmRCApicHlp", &pRCHelpers);
+    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMR3, NULL, "g_pdmRCApicHlp", &pRCHelpers);
     AssertReleaseRC(rc);
     AssertRelease(pRCHelpers);
@@ -4206 +4225 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     PCPDMAPICHLPR0 pR0Helpers = 0;
-    int rc = PDMR3GetSymbolR0(pDevIns->Internal.s.pVMHC, NULL, "g_pdmR0ApicHlp", &pR0Helpers);
+    int rc = PDMR3GetSymbolR0(pDevIns->Internal.s.pVMR3, NULL, "g_pdmR0ApicHlp", &pR0Helpers);
     AssertReleaseRC(rc);
     AssertRelease(pR0Helpers);
@@ -4222 +4241 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR3;
     LogFlow(("pdmR3IoApicHlp_ApicBusDeliver: caller='%s'/%d: u8Dest=%RX8 u8DestMode=%RX8 u8DeliveryMode=%RX8 iVector=%RX8 u8Polarity=%RX8 u8TriggerMode=%RX8\n",
              pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode));
@@ -4234 +4253 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMHC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMR3, rc);
 }
 
@@ -4242 +4261 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMHC);
+    pdmUnlock(pDevIns->Internal.s.pVMR3);
 }
 
@@ -4250 +4269 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     RTRCPTR pRCHelpers = 0;
-    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMHC, NULL, "g_pdmRCIoApicHlp", &pRCHelpers);
+    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMR3, NULL, "g_pdmRCIoApicHlp", &pRCHelpers);
     AssertReleaseRC(rc);
     AssertRelease(pRCHelpers);
@@ -4265 +4284 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     PCPDMIOAPICHLPR0 pR0Helpers = 0;
-    int rc = PDMR3GetSymbolR0(pDevIns->Internal.s.pVMHC, NULL, "g_pdmR0IoApicHlp", &pR0Helpers);
+    int rc = PDMR3GetSymbolR0(pDevIns->Internal.s.pVMR3, NULL, "g_pdmR0IoApicHlp", &pR0Helpers);
     AssertReleaseRC(rc);
     AssertRelease(pR0Helpers);
@@ -4281 +4300 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     Log4(("pdmR3PciHlp_IsaSetIrq: iIrq=%d iLevel=%d\n", iIrq, iLevel));
-    PDMIsaSetIrq(pDevIns->Internal.s.pVMHC, iIrq, iLevel);
+    PDMIsaSetIrq(pDevIns->Internal.s.pVMR3, iIrq, iLevel);
 }
 
@@ -4290 +4309 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     Log4(("pdmR3PciHlp_IsaSetIrq: iIrq=%d iLevel=%d\n", iIrq, iLevel));
-    PDMIoApicSetIrq(pDevIns->Internal.s.pVMHC, iIrq, iLevel);
+    PDMIoApicSetIrq(pDevIns->Internal.s.pVMR3, iIrq, iLevel);
 }
 
@@ -4298 +4317 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
-    bool fRc = PGMR3PhysMMIO2IsBase(pDevIns->Internal.s.pVMHC, pOwner, GCPhys);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
+    bool fRc = PGMR3PhysMMIO2IsBase(pDevIns->Internal.s.pVMR3, pOwner, GCPhys);
     Log4(("pdmR3PciHlp_IsMMIO2Base: pOwner=%p GCPhys=%RGp -> %RTbool\n", pOwner, GCPhys, fRc));
     return fRc;
@@ -4309 +4328 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMHC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMR3, rc);
 }
 
@@ -4317 +4336 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMHC);
+    pdmUnlock(pDevIns->Internal.s.pVMR3);
 }
 
@@ -4325 +4344 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     RTRCPTR pRCHelpers = 0;
-    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMHC, NULL, "g_pdmRCPciHlp", &pRCHelpers);
+    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMR3, NULL, "g_pdmRCPciHlp", &pRCHelpers);
     AssertReleaseRC(rc);
     AssertRelease(pRCHelpers);
@@ -4340 +4359 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
+    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     PCPDMPCIHLPR0 pR0Helpers = 0;
-    int rc = PDMR3GetSymbolR0(pDevIns->Internal.s.pVMHC, NULL, "g_pdmR0PciHlp", &pR0Helpers);
+    int rc = PDMR3GetSymbolR0(pDevIns->Internal.s.pVMR3, NULL, "g_pdmR0PciHlp", &pR0Helpers);
     AssertReleaseRC(rc);
     AssertRelease(pR0Helpers);
@@ -4376 +4395 @@
              * Iterate device instances.
              */
-            for (PPDMDEVINS pDevIns = pDev->pInstances; pDevIns; pDevIns = pDevIns->Internal.s.pPerDeviceNextHC)
+            for (PPDMDEVINS pDevIns = pDev->pInstances; pDevIns; pDevIns = pDevIns->Internal.s.pPerDeviceNextR3)
             {
                 if (pDevIns->iInstance == iInstance)
@@ -4383 +4402 @@
                      * Iterate luns.
                      */
-                    for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
+                    for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
                     {
                         if (pLun->iLun == iLun)