Changeset 12970 in vbox

Timestamp:

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

Author:

vboxsync

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

37403

Message:

#1865: PDMINS.

Location:

trunk

Files:

• include/VBox/pdmdev.h (modified) (27 diffs)
• include/VBox/pdmins.h (modified) (1 diff)
• src/VBox/VMM/PDM.cpp (modified) (10 diffs)
• src/VBox/VMM/PDMDevice.cpp (modified) (195 diffs)
• src/VBox/VMM/PDMDriver.cpp (modified) (1 diff)
• src/VBox/VMM/PDMInternal.h (modified) (6 diffs)
• src/VBox/VMM/VMMGC/PDMGCDevice.cpp (modified) (37 diffs)
• src/VBox/VMM/VMMR0/PDMR0Device.cpp (modified) (27 diffs)
• src/VBox/VMM/testcase/tstVMStructGC.cpp (modified) (1 diff)
• src/VBox/VMM/testcase/tstVMStructSize.cpp (modified) (1 diff)

trunk/include/VBox/pdmdev.h

@@ -1660 +1660 @@
  * PDM Device API.
  */
-typedef struct PDMDEVHLP
+typedef struct PDMDEVHLPR3
 {
     /** Structure version. PDM_DEVHLP_VERSION defines the current version. */
@@ -1780 +1780 @@
      * @param   pszFill             Name of the GC function which is gonna handle Fill/memset operations. (optional)
      * @param   pszDesc             Obsolete. NULL is fine.
-     * @todo    Remove pszDesc in the next major revision of PDMDEVHLP.
+     * @todo    Remove pszDesc in the next major revision of PDMDEVHLPR3.
      */
     DECLR3CALLBACKMEMBER(int, pfnMMIORegisterGC,(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
@@ -1801 +1801 @@
      * @param   pszFill             Name of the GC function which is gonna handle Fill/memset operations. (optional)
      * @param   pszDesc             Obsolete. NULL is fine.
-     * @todo    Remove pszDesc in the next major revision of PDMDEVHLP.
+     * @todo    Remove pszDesc in the next major revision of PDMDEVHLPR3.
      */
     DECLR3CALLBACKMEMBER(int, pfnMMIORegisterR0,(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
@@ -2716 +2716 @@
     /** Just a safety precaution. (PDM_DEVHLP_VERSION) */
     uint32_t                        u32TheEnd;
-} PDMDEVHLP;
+} PDMDEVHLPR3;
 #endif /* !IN_RING3 */
-/** Pointer PDM Device API. */
-typedef R3PTRTYPE(struct PDMDEVHLP *) PPDMDEVHLP;
-/** Pointer PDM Device API. */
-typedef R3PTRTYPE(const struct PDMDEVHLP *) PCPDMDEVHLP;
+/** Pointer to the R3 PDM Device API. */
+typedef R3PTRTYPE(struct PDMDEVHLPR3 *) PPDMDEVHLPR3;
+/** Pointer to the R3 PDM Device API, const variant. */
+typedef R3PTRTYPE(const struct PDMDEVHLPR3 *) PCPDMDEVHLPR3;
 
 /** Current PDMDEVHLP version number. */
@@ -2728 +2728 @@
 
 /**
- * PDM Device API - GC Variant.
- */
-typedef struct PDMDEVHLPGC
-{
-    /** Structure version. PDM_DEVHLPGC_VERSION defines the current version. */
+ * PDM Device API - RC Variant.
+ */
+typedef struct PDMDEVHLPRC
+{
+    /** Structure version. PDM_DEVHLPRC_VERSION defines the current version. */
     uint32_t                    u32Version;
 
@@ -2845 +2845 @@
     /** Just a safety precaution. */
     uint32_t                        u32TheEnd;
-} PDMDEVHLPGC;
-/** Pointer PDM Device GC API. */
-typedef RCPTRTYPE(struct PDMDEVHLPGC *) PPDMDEVHLPGC;
-/** Pointer PDM Device GC API. */
-typedef RCPTRTYPE(const struct PDMDEVHLPGC *) PCPDMDEVHLPGC;
+} PDMDEVHLPRC;
+/** Pointer PDM Device RC API. */
+typedef RCPTRTYPE(struct PDMDEVHLPRC *) PPDMDEVHLPRC;
+/** Pointer PDM Device RC API. */
+typedef RCPTRTYPE(const struct PDMDEVHLPRC *) PCPDMDEVHLPRC;
 
 /** Current PDMDEVHLP version number. */
-#define PDM_DEVHLPGC_VERSION  0xfb010000
+#define PDM_DEVHLPRC_VERSION  0xfb010000
 
 
@@ -2993 +2993 @@
     /** Device instance number. */
     RTUINT                      iInstance;
+
+    /** Pointer the GC PDM Device API. */
+    PCPDMDEVHLPRC               pDevHlpRC;
+    /** Pointer to device instance data. */
+    RTRCPTR                     pvInstanceDataRC;
+
+    /** Pointer the R0 PDM Device API. */
+    PCPDMDEVHLPR0               pDevHlpR0;
+    /** Pointer to device instance data (R0). */
+    RTR0PTR                     pvInstanceDataR0;
+
+    /** Pointer the HC PDM Device API. */
+    PCPDMDEVHLPR3               pDevHlpR3;
+    /** Pointer to device instance data. */
+    RTR3PTR                     pvInstanceDataR3;
+
+    /** Pointer to device registration structure.  */
+    R3PTRTYPE(PCPDMDEVREG)      pDevReg;
+    /** Configuration handle. */
+    R3PTRTYPE(PCFGMNODE)        pCfgHandle;
+
     /** The base interface of the device.
      * The device constructor initializes this if it has any
@@ -2998 +3019 @@
      * call PDMR3QueryDevice(). */
     PDMIBASE                    IBase;
+    /** Align the internal data more naturally. */
+    RTR3PTR                     R3PtrPadding;
 
     /** Internal data. */
@@ -3005 +3028 @@
         PDMDEVINSINT            s;
 #endif
-        uint8_t                 padding[HC_ARCH_BITS == 32 ? 48 : 96];
+        uint8_t                 padding[HC_ARCH_BITS == 32 ? 64 + 16 : 112];
     } Internal;
 
-    /** Pointer the HC PDM Device API. */
-    R3PTRTYPE(PCPDMDEVHLP)      pDevHlp;
-    /** Pointer the R0 PDM Device API. */
-    R0PTRTYPE(PCPDMDEVHLPR0)    pDevHlpR0;
-    /** Pointer to device registration structure.  */
-    R3PTRTYPE(PCPDMDEVREG)      pDevReg;
-    /** Configuration handle. */
-    R3PTRTYPE(PCFGMNODE)        pCfgHandle;
-    /** Pointer to device instance data. */
-    R3PTRTYPE(void *)           pvInstanceDataR3;
-    /** Pointer to device instance data. */
-    R0PTRTYPE(void *)           pvInstanceDataR0;
-    /** Pointer the GC PDM Device API. */
-    RCPTRTYPE(PCPDMDEVHLPGC)    pDevHlpGC;
-    /** Pointer to device instance data. */
-    RCPTRTYPE(void *)           pvInstanceDataGC;
-    /* padding to make achInstanceData aligned at 32 byte boundrary. */
-    uint32_t                    au32Padding[HC_ARCH_BITS == 32 ? 1 : 6];
     /** Device instance data. The size of this area is defined
      * in the PDMDEVREG::cbInstanceData field. */
@@ -3031 +3036 @@
 } PDMDEVINS;
 
-/** Current DEVREG version number. */
-#define PDM_DEVINS_VERSION  0xf3010000
+/** Current PDMDEVINS version number. */
+#define PDM_DEVINS_VERSION  0xf3020000
 
 /** Converts a pointer to the PDMDEVINS::IBase to a pointer to PDMDEVINS. */
@@ -3042 +3047 @@
  */
 #ifdef VBOX_STRICT
-# define PDMDEV_ASSERT_EMT(pDevIns)  pDevIns->pDevHlp->pfnAssertEMT(pDevIns, __FILE__, __LINE__, __FUNCTION__)
+# define PDMDEV_ASSERT_EMT(pDevIns)  pDevIns->pDevHlpR3->pfnAssertEMT(pDevIns, __FILE__, __LINE__, __FUNCTION__)
 #else
 # define PDMDEV_ASSERT_EMT(pDevIns)  do { } while (0)
@@ -3051 +3056 @@
  */
 #ifdef VBOX_STRICT
-# define PDMDEV_ASSERT_OTHER(pDevIns)  pDevIns->pDevHlp->pfnAssertOther(pDevIns, __FILE__, __LINE__, __FUNCTION__)
+# define PDMDEV_ASSERT_OTHER(pDevIns)  pDevIns->pDevHlpR3->pfnAssertOther(pDevIns, __FILE__, __LINE__, __FUNCTION__)
 #else
 # define PDMDEV_ASSERT_OTHER(pDevIns)  do { } while (0)
@@ -3060 +3065 @@
  */
 #ifdef VBOX_STRICT
-# define PDMDEV_ASSERT_VMLOCK_OWNER(pDevIns)  pDevIns->pDevHlp->pfnAssertVMLock(pDevIns, __FILE__, __LINE__, __FUNCTION__)
+# define PDMDEV_ASSERT_VMLOCK_OWNER(pDevIns)  pDevIns->pDevHlpR3->pfnAssertVMLock(pDevIns, __FILE__, __LINE__, __FUNCTION__)
 #else
 # define PDMDEV_ASSERT_VMLOCK_OWNER(pDevIns)  do { } while (0)
@@ -3080 +3085 @@
  * Converts a PDM Device instance pointer a RC PDM Device instance pointer.
  */
-#define PDMDEVINS_2_RCPTR(pDevIns)  ( (RCPTRTYPE(PPDMDEVINS))((RTGCUINTPTR)(pDevIns)->pvInstanceDataGC - RT_OFFSETOF(PDMDEVINS, achInstanceData)) )
+#define PDMDEVINS_2_RCPTR(pDevIns)  ( (RCPTRTYPE(PPDMDEVINS))((RTGCUINTPTR)(pDevIns)->pvInstanceDataRC - RT_OFFSETOF(PDMDEVINS, achInstanceData)) )
 
 /** @def PDMDEVINS_2_R3PTR
@@ -3109 +3114 @@
     va_list args;
     va_start(args, pszFormat);
-    rc = pDevIns->pDevHlp->pfnDBGFStopV(pDevIns, RT_SRC_POS_ARGS, pszFormat, args);
+    rc = pDevIns->pDevHlpR3->pfnDBGFStopV(pDevIns, RT_SRC_POS_ARGS, pszFormat, args);
     va_end(args);
     return rc;
@@ -3128 +3133 @@
 #ifdef IN_RING3
 /**
- * @copydoc PDMDEVHLP::pfnIOPortRegister
+ * @copydoc PDMDEVHLPR3::pfnIOPortRegister
  */
 DECLINLINE(int) PDMDevHlpIOPortRegister(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts, RTHCPTR pvUser,
@@ -3134 +3139 @@
                                         PFNIOMIOPORTOUTSTRING pfnOutStr, PFNIOMIOPORTINSTRING pfnInStr, const char *pszDesc)
 {
-    return pDevIns->pDevHlp->pfnIOPortRegister(pDevIns, Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnIOPortRegisterGC
+    return pDevIns->pDevHlpR3->pfnIOPortRegister(pDevIns, Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnIOPortRegisterGC
  */
 DECLINLINE(int) PDMDevHlpIOPortRegisterGC(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts, RTRCPTR pvUser,
@@ -3144 +3149 @@
                                           const char *pszInStr, const char *pszDesc)
 {
-    return pDevIns->pDevHlp->pfnIOPortRegisterGC(pDevIns, Port, cPorts, pvUser, pszOut, pszIn, pszOutStr, pszInStr, pszDesc);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnIOPortRegisterR0
+    return pDevIns->pDevHlpR3->pfnIOPortRegisterGC(pDevIns, Port, cPorts, pvUser, pszOut, pszIn, pszOutStr, pszInStr, pszDesc);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnIOPortRegisterR0
  */
 DECLINLINE(int) PDMDevHlpIOPortRegisterR0(PPDMDEVINS pDevIns, RTIOPORT Port, RTUINT cPorts, RTR0PTR pvUser,
@@ -3154 +3159 @@
                                           const char *pszInStr, const char *pszDesc)
 {
-    return pDevIns->pDevHlp->pfnIOPortRegisterR0(pDevIns, Port, cPorts, pvUser, pszOut, pszIn, pszOutStr, pszInStr, pszDesc);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMIORegister
+    return pDevIns->pDevHlpR3->pfnIOPortRegisterR0(pDevIns, Port, cPorts, pvUser, pszOut, pszIn, pszOutStr, pszInStr, pszDesc);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMIORegister
  */
 DECLINLINE(int) PDMDevHlpMMIORegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTHCPTR pvUser,
@@ -3164 +3169 @@
                                       const char *pszDesc)
 {
-    return pDevIns->pDevHlp->pfnMMIORegister(pDevIns, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMIORegisterGC
+    return pDevIns->pDevHlpR3->pfnMMIORegister(pDevIns, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMIORegisterGC
  */
 DECLINLINE(int) PDMDevHlpMMIORegisterGC(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTGCPTR pvUser,
                                         const char *pszWrite, const char *pszRead, const char *pszFill)
 {
-    return pDevIns->pDevHlp->pfnMMIORegisterGC(pDevIns, GCPhysStart, cbRange, pvUser, pszWrite, pszRead, pszFill, NULL);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMIORegisterR0
+    return pDevIns->pDevHlpR3->pfnMMIORegisterGC(pDevIns, GCPhysStart, cbRange, pvUser, pszWrite, pszRead, pszFill, NULL);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMIORegisterR0
  */
 DECLINLINE(int) PDMDevHlpMMIORegisterR0(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
                                         const char *pszWrite, const char *pszRead, const char *pszFill)
 {
-    return pDevIns->pDevHlp->pfnMMIORegisterR0(pDevIns, GCPhysStart, cbRange, pvUser, pszWrite, pszRead, pszFill, NULL);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnROMRegister
+    return pDevIns->pDevHlpR3->pfnMMIORegisterR0(pDevIns, GCPhysStart, cbRange, pvUser, pszWrite, pszRead, pszFill, NULL);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnROMRegister
  */
 DECLINLINE(int) PDMDevHlpROMRegister(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, const void *pvBinary, bool fShadow, const char *pszDesc)
 {
-    return pDevIns->pDevHlp->pfnROMRegister(pDevIns, GCPhysStart, cbRange, pvBinary, fShadow, pszDesc);
-}
-/**
- * @copydoc PDMDEVHLP::pfnROMProtectShadow
+    return pDevIns->pDevHlpR3->pfnROMRegister(pDevIns, GCPhysStart, cbRange, pvBinary, fShadow, pszDesc);
+}
+/**
+ * @copydoc PDMDEVHLPR3::pfnROMProtectShadow
  */
 DECLINLINE(int) PDMDevHlpROMProtectShadow(PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange)
 {
-    return pDevIns->pDevHlp->pfnROMProtectShadow(pDevIns, GCPhysStart, cbRange);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMIO2Register
+    return pDevIns->pDevHlpR3->pfnROMProtectShadow(pDevIns, GCPhysStart, cbRange);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMIO2Register
  */
 DECLINLINE(int) PDMDevHlpMMIO2Register(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cb, uint32_t fFlags, void **ppv, const char *pszDesc)
 {
-    return pDevIns->pDevHlp->pfnMMIO2Register(pDevIns, iRegion, cb, fFlags, ppv, pszDesc);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMIO2Deregister
+    return pDevIns->pDevHlpR3->pfnMMIO2Register(pDevIns, iRegion, cb, fFlags, ppv, pszDesc);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMIO2Deregister
  */
 DECLINLINE(int) PDMDevHlpMMIO2Deregister(PPDMDEVINS pDevIns, uint32_t iRegion)
 {
-    return pDevIns->pDevHlp->pfnMMIO2Deregister(pDevIns, iRegion);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMIO2Map
+    return pDevIns->pDevHlpR3->pfnMMIO2Deregister(pDevIns, iRegion);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMIO2Map
  */
 DECLINLINE(int) PDMDevHlpMMIO2Map(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys)
 {
-    return pDevIns->pDevHlp->pfnMMIO2Map(pDevIns, iRegion, GCPhys);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMIO2Unmap
+    return pDevIns->pDevHlpR3->pfnMMIO2Map(pDevIns, iRegion, GCPhys);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMIO2Unmap
  */
 DECLINLINE(int) PDMDevHlpMMIO2Unmap(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS GCPhys)
 {
-    return pDevIns->pDevHlp->pfnMMIO2Unmap(pDevIns, iRegion, GCPhys);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMHyperMapMMIO2
+    return pDevIns->pDevHlpR3->pfnMMIO2Unmap(pDevIns, iRegion, GCPhys);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMHyperMapMMIO2
  */
 DECLINLINE(int) PDMDevHlpMMHyperMapMMIO2(PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS off, RTGCPHYS cb,
                                          const char *pszDesc, PRTRCPTR pRCPtr)
 {
-    return pDevIns->pDevHlp->pfnMMHyperMapMMIO2(pDevIns, iRegion, off, cb, pszDesc, pRCPtr);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnRegisterVMMDevHeap
+    return pDevIns->pDevHlpR3->pfnMMHyperMapMMIO2(pDevIns, iRegion, off, cb, pszDesc, pRCPtr);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnRegisterVMMDevHeap
  */
 DECLINLINE(int) PDMDevHlpRegisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTR3PTR pvHeap, unsigned cbSize)
 {
-    return pDevIns->pDevHlp->pfnRegisterVMMDevHeap(pDevIns, GCPhys, pvHeap, cbSize);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnUnregisterVMMDevHeap
+    return pDevIns->pDevHlpR3->pfnRegisterVMMDevHeap(pDevIns, GCPhys, pvHeap, cbSize);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnUnregisterVMMDevHeap
  */
 DECLINLINE(int) PDMDevHlpUnregisterVMMDevHeap(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
 {
-    return pDevIns->pDevHlp->pfnUnregisterVMMDevHeap(pDevIns, GCPhys);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnSSMRegister
+    return pDevIns->pDevHlpR3->pfnUnregisterVMMDevHeap(pDevIns, GCPhys);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnSSMRegister
  */
 DECLINLINE(int) PDMDevHlpSSMRegister(PPDMDEVINS pDevIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
@@ -3264 +3269 @@
                                      PFNSSMDEVLOADPREP pfnLoadPrep, PFNSSMDEVLOADEXEC pfnLoadExec, PFNSSMDEVLOADDONE pfnLoadDone)
 {
-    return pDevIns->pDevHlp->pfnSSMRegister(pDevIns, pszName, u32Instance, u32Version, cbGuess,
+    return pDevIns->pDevHlpR3->pfnSSMRegister(pDevIns, pszName, u32Instance, u32Version, cbGuess,
                                             pfnSavePrep, pfnSaveExec, pfnSaveDone,
                                             pfnLoadPrep, pfnLoadExec, pfnLoadDone);
@@ -3270 +3275 @@
 
 /**
- * @copydoc PDMDEVHLP::pfnTMTimerCreate
+ * @copydoc PDMDEVHLPR3::pfnTMTimerCreate
  */
 DECLINLINE(int) PDMDevHlpTMTimerCreate(PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, const char *pszDesc, PPTMTIMERR3 ppTimer)
 {
-    return pDevIns->pDevHlp->pfnTMTimerCreate(pDevIns, enmClock, pfnCallback, pszDesc, ppTimer);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPCIRegister
+    return pDevIns->pDevHlpR3->pfnTMTimerCreate(pDevIns, enmClock, pfnCallback, pszDesc, ppTimer);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPCIRegister
  */
 DECLINLINE(int) PDMDevHlpPCIRegister(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev)
 {
-    return pDevIns->pDevHlp->pfnPCIRegister(pDevIns, pPciDev);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPCIIORegionRegister
+    return pDevIns->pDevHlpR3->pfnPCIRegister(pDevIns, pPciDev);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPCIIORegionRegister
  */
 DECLINLINE(int) PDMDevHlpPCIIORegionRegister(PPDMDEVINS pDevIns, int iRegion, uint32_t cbRegion, PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback)
 {
-    return pDevIns->pDevHlp->pfnPCIIORegionRegister(pDevIns, iRegion, cbRegion, enmType, pfnCallback);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPCISetConfigCallbacks
+    return pDevIns->pDevHlpR3->pfnPCIIORegionRegister(pDevIns, iRegion, cbRegion, enmType, pfnCallback);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPCISetConfigCallbacks
  */
 DECLINLINE(void) PDMDevHlpPCISetConfigCallbacks(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PFNPCICONFIGREAD pfnRead, PPFNPCICONFIGREAD ppfnReadOld,
                                                 PFNPCICONFIGWRITE pfnWrite, PPFNPCICONFIGWRITE ppfnWriteOld)
 {
-    pDevIns->pDevHlp->pfnPCISetConfigCallbacks(pDevIns, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnDriverAttach
+    pDevIns->pDevHlpR3->pfnPCISetConfigCallbacks(pDevIns, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnDriverAttach
  */
 DECLINLINE(int) PDMDevHlpDriverAttach(PPDMDEVINS pDevIns, RTUINT iLun, PPDMIBASE pBaseInterface, PPDMIBASE *ppBaseInterface, const char *pszDesc)
 {
-    return pDevIns->pDevHlp->pfnDriverAttach(pDevIns, iLun, pBaseInterface, ppBaseInterface, pszDesc);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMHeapAlloc
+    return pDevIns->pDevHlpR3->pfnDriverAttach(pDevIns, iLun, pBaseInterface, ppBaseInterface, pszDesc);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMHeapAlloc
  */
 DECLINLINE(void *) PDMDevHlpMMHeapAlloc(PPDMDEVINS pDevIns, size_t cb)
 {
-    return pDevIns->pDevHlp->pfnMMHeapAlloc(pDevIns, cb);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMHeapAllocZ
+    return pDevIns->pDevHlpR3->pfnMMHeapAlloc(pDevIns, cb);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMHeapAllocZ
  */
 DECLINLINE(void *) PDMDevHlpMMHeapAllocZ(PPDMDEVINS pDevIns, size_t cb)
 {
-    return pDevIns->pDevHlp->pfnMMHeapAllocZ(pDevIns, cb);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnMMHeapFree
+    return pDevIns->pDevHlpR3->pfnMMHeapAllocZ(pDevIns, cb);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnMMHeapFree
  */
 DECLINLINE(void) PDMDevHlpMMHeapFree(PPDMDEVINS pDevIns, void *pv)
 {
-    pDevIns->pDevHlp->pfnMMHeapFree(pDevIns, pv);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnDBGFInfoRegister
+    pDevIns->pDevHlpR3->pfnMMHeapFree(pDevIns, pv);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnDBGFInfoRegister
  */
 DECLINLINE(int) PDMDevHlpDBGFInfoRegister(PPDMDEVINS pDevIns, const char *pszName, const char *pszDesc, PFNDBGFHANDLERDEV pfnHandler)
 {
-    return pDevIns->pDevHlp->pfnDBGFInfoRegister(pDevIns, pszName, pszDesc, pfnHandler);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnSTAMRegister
+    return pDevIns->pDevHlpR3->pfnDBGFInfoRegister(pDevIns, pszName, pszDesc, pfnHandler);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnSTAMRegister
  */
 DECLINLINE(void) PDMDevHlpSTAMRegister(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, const char *pszName, STAMUNIT enmUnit, const char *pszDesc)
 {
-    pDevIns->pDevHlp->pfnSTAMRegister(pDevIns, pvSample, enmType, pszName, enmUnit, pszDesc);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnSTAMRegisterF
+    pDevIns->pDevHlpR3->pfnSTAMRegister(pDevIns, pvSample, enmType, pszName, enmUnit, pszDesc);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnSTAMRegisterF
  */
 DECLINLINE(void) PDMDevHlpSTAMRegisterF(PPDMDEVINS pDevIns, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility, STAMUNIT enmUnit,
@@ -3358 +3363 @@
     va_list va;
     va_start(va, pszName);
-    pDevIns->pDevHlp->pfnSTAMRegisterV(pDevIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, va);
+    pDevIns->pDevHlpR3->pfnSTAMRegisterV(pDevIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, va);
     va_end(va);
 }
 
 /**
- * @copydoc PDMDEVHLP::pfnPDMQueueCreate
+ * @copydoc PDMDEVHLPR3::pfnPDMQueueCreate
  */
 DECLINLINE(int) PDMDevHlpPDMQueueCreate(PPDMDEVINS pDevIns, RTUINT cbItem, RTUINT cItems, uint32_t cMilliesInterval,
                                         PFNPDMQUEUEDEV pfnCallback, bool fGCEnabled, PPDMQUEUE *ppQueue)
 {
-    return pDevIns->pDevHlp->pfnPDMQueueCreate(pDevIns, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, ppQueue);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnCritSectInit
+    return pDevIns->pDevHlpR3->pfnPDMQueueCreate(pDevIns, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, ppQueue);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnCritSectInit
  */
 DECLINLINE(int) PDMDevHlpCritSectInit(PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, const char *pszName)
 {
-    return pDevIns->pDevHlp->pfnCritSectInit(pDevIns, pCritSect, pszName);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnUTCNow
+    return pDevIns->pDevHlpR3->pfnCritSectInit(pDevIns, pCritSect, pszName);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnUTCNow
  */
 DECLINLINE(PRTTIMESPEC) PDMDevHlpUTCNow(PPDMDEVINS pDevIns, PRTTIMESPEC pTime)
 {
-    return pDevIns->pDevHlp->pfnUTCNow(pDevIns, pTime);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnGetVM
+    return pDevIns->pDevHlpR3->pfnUTCNow(pDevIns, pTime);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnGetVM
  */
 DECLINLINE(PVM) PDMDevHlpGetVM(PPDMDEVINS pDevIns)
 {
-    return pDevIns->pDevHlp->pfnGetVM(pDevIns);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPhysReadGCVirt
+    return pDevIns->pDevHlpR3->pfnGetVM(pDevIns);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPhysReadGCVirt
  */
 DECLINLINE(int) PDMDevHlpPhysReadGCVirt(PPDMDEVINS pDevIns, void *pvDst, RTGCPTR GCVirtSrc, size_t cb)
 {
-    return pDevIns->pDevHlp->pfnPhysReadGCVirt(pDevIns, pvDst, GCVirtSrc, cb);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPhysWriteGCVirt
+    return pDevIns->pDevHlpR3->pfnPhysReadGCVirt(pDevIns, pvDst, GCVirtSrc, cb);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPhysWriteGCVirt
  */
 DECLINLINE(int) PDMDevHlpPhysWriteGCVirt(PPDMDEVINS pDevIns, RTGCPTR GCVirtDst, const void *pvSrc, size_t cb)
 {
-    return pDevIns->pDevHlp->pfnPhysWriteGCVirt(pDevIns, GCVirtDst, pvSrc, cb);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPhysReserve
+    return pDevIns->pDevHlpR3->pfnPhysWriteGCVirt(pDevIns, GCVirtDst, pvSrc, cb);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPhysReserve
  */
 DECLINLINE(int) PDMDevHlpPhysReserve(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTUINT cbRange, const char *pszDesc)
 {
-    return pDevIns->pDevHlp->pfnPhysReserve(pDevIns, GCPhys, cbRange, pszDesc);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPhysGCPtr2GCPhys
+    return pDevIns->pDevHlpR3->pfnPhysReserve(pDevIns, GCPhys, cbRange, pszDesc);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPhysGCPtr2GCPhys
  */
 DECLINLINE(int) PDMDevHlpPhysGCPtr2GCPhys(PPDMDEVINS pDevIns, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
 {
-    return pDevIns->pDevHlp->pfnPhysGCPtr2GCPhys(pDevIns, GCPtr, pGCPhys);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnVMState
+    return pDevIns->pDevHlpR3->pfnPhysGCPtr2GCPhys(pDevIns, GCPtr, pGCPhys);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnVMState
  */
 DECLINLINE(VMSTATE) PDMDevHlpVMState(PPDMDEVINS pDevIns)
 {
-    return pDevIns->pDevHlp->pfnVMState(pDevIns);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnA20Set
+    return pDevIns->pDevHlpR3->pfnVMState(pDevIns);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnA20Set
  */
 DECLINLINE(void) PDMDevHlpA20Set(PPDMDEVINS pDevIns, bool fEnable)
 {
-    pDevIns->pDevHlp->pfnA20Set(pDevIns, fEnable);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnVMReset
+    pDevIns->pDevHlpR3->pfnA20Set(pDevIns, fEnable);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnVMReset
  */
 DECLINLINE(int) PDMDevHlpVMReset(PPDMDEVINS pDevIns)
 {
-    return pDevIns->pDevHlp->pfnVMReset(pDevIns);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnVMSuspend
+    return pDevIns->pDevHlpR3->pfnVMReset(pDevIns);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnVMSuspend
  */
 DECLINLINE(int) PDMDevHlpVMSuspend(PPDMDEVINS pDevIns)
 {
-    return pDevIns->pDevHlp->pfnVMSuspend(pDevIns);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnVMPowerOff
+    return pDevIns->pDevHlpR3->pfnVMSuspend(pDevIns);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnVMPowerOff
  */
 DECLINLINE(int) PDMDevHlpVMPowerOff(PPDMDEVINS pDevIns)
 {
-    return pDevIns->pDevHlp->pfnVMPowerOff(pDevIns);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnDMARegister
+    return pDevIns->pDevHlpR3->pfnVMPowerOff(pDevIns);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnDMARegister
  */
 DECLINLINE(int) PDMDevHlpDMARegister(PPDMDEVINS pDevIns, unsigned uChannel, PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
 {
-    return pDevIns->pDevHlp->pfnDMARegister(pDevIns, uChannel, pfnTransferHandler, pvUser);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnDMAReadMemory
+    return pDevIns->pDevHlpR3->pfnDMARegister(pDevIns, uChannel, pfnTransferHandler, pvUser);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnDMAReadMemory
  */
 DECLINLINE(int) PDMDevHlpDMAReadMemory(PPDMDEVINS pDevIns, unsigned uChannel, void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbRead)
 {
-    return pDevIns->pDevHlp->pfnDMAReadMemory(pDevIns, uChannel, pvBuffer, off, cbBlock, pcbRead);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnDMAWriteMemory
+    return pDevIns->pDevHlpR3->pfnDMAReadMemory(pDevIns, uChannel, pvBuffer, off, cbBlock, pcbRead);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnDMAWriteMemory
  */
 DECLINLINE(int) PDMDevHlpDMAWriteMemory(PPDMDEVINS pDevIns, unsigned uChannel, const void *pvBuffer, uint32_t off, uint32_t cbBlock, uint32_t *pcbWritten)
 {
-    return pDevIns->pDevHlp->pfnDMAWriteMemory(pDevIns, uChannel, pvBuffer, off, cbBlock, pcbWritten);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnDMASetDREQ
+    return pDevIns->pDevHlpR3->pfnDMAWriteMemory(pDevIns, uChannel, pvBuffer, off, cbBlock, pcbWritten);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnDMASetDREQ
  */
 DECLINLINE(int) PDMDevHlpDMASetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
 {
-    return pDevIns->pDevHlp->pfnDMASetDREQ(pDevIns, uChannel, uLevel);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnDMAGetChannelMode
+    return pDevIns->pDevHlpR3->pfnDMASetDREQ(pDevIns, uChannel, uLevel);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnDMAGetChannelMode
  */
 DECLINLINE(uint8_t) PDMDevHlpDMAGetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
 {
-    return pDevIns->pDevHlp->pfnDMAGetChannelMode(pDevIns, uChannel);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnDMASchedule
+    return pDevIns->pDevHlpR3->pfnDMAGetChannelMode(pDevIns, uChannel);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnDMASchedule
  */
 DECLINLINE(void) PDMDevHlpDMASchedule(PPDMDEVINS pDevIns)
 {
-    pDevIns->pDevHlp->pfnDMASchedule(pDevIns);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnCMOSWrite
+    pDevIns->pDevHlpR3->pfnDMASchedule(pDevIns);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnCMOSWrite
  */
 DECLINLINE(int) PDMDevHlpCMOSWrite(PPDMDEVINS pDevIns, unsigned iReg, uint8_t u8Value)
 {
-    return pDevIns->pDevHlp->pfnCMOSWrite(pDevIns, iReg, u8Value);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnCMOSRead
+    return pDevIns->pDevHlpR3->pfnCMOSWrite(pDevIns, iReg, u8Value);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnCMOSRead
  */
 DECLINLINE(int) PDMDevHlpCMOSRead(PPDMDEVINS pDevIns, unsigned iReg, uint8_t *pu8Value)
 {
-    return pDevIns->pDevHlp->pfnCMOSRead(pDevIns, iReg, pu8Value);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnGetCpuId
+    return pDevIns->pDevHlpR3->pfnCMOSRead(pDevIns, iReg, pu8Value);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnGetCpuId
  */
 DECLINLINE(void) PDMDevHlpGetCpuId(PPDMDEVINS pDevIns, uint32_t iLeaf, uint32_t *pEax, uint32_t *pEbx, uint32_t *pEcx, uint32_t *pEdx)
 {
-    pDevIns->pDevHlp->pfnGetCpuId(pDevIns, iLeaf, pEax, pEbx, pEcx, pEdx);
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPDMThreadCreate
+    pDevIns->pDevHlpR3->pfnGetCpuId(pDevIns, iLeaf, pEax, pEbx, pEcx, pEdx);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPDMThreadCreate
  */
 DECLINLINE(int) PDMDevHlpPDMThreadCreate(PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
                                          PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
 {
-    return pDevIns->pDevHlp->pfnPDMThreadCreate(pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
+    return pDevIns->pDevHlpR3->pfnPDMThreadCreate(pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
 }
 #endif /* IN_RING3 */
@@ -3551 +3556 @@
 
 /**
- * @copydoc PDMDEVHLP::pfnPCISetIrq
+ * @copydoc PDMDEVHLPR3::pfnPCISetIrq
  */
 DECLINLINE(void) PDMDevHlpPCISetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
-#ifdef IN_GC
-    pDevIns->pDevHlpGC->pfnPCISetIrq(pDevIns, iIrq, iLevel);
-#elif defined(IN_RING0)
-    pDevIns->pDevHlpR0->pfnPCISetIrq(pDevIns, iIrq, iLevel);
-#else
-    pDevIns->pDevHlp->pfnPCISetIrq(pDevIns, iIrq, iLevel);
-#endif
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPCISetIrqNoWait
+    pDevIns->CTX_SUFF(pDevHlp)->pfnPCISetIrq(pDevIns, iIrq, iLevel);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPCISetIrqNoWait
  */
 DECLINLINE(void) PDMDevHlpPCISetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
-#ifdef IN_GC
-    pDevIns->pDevHlpGC->pfnPCISetIrq(pDevIns, iIrq, iLevel);
-#elif defined(IN_RING0)
-    pDevIns->pDevHlpR0->pfnPCISetIrq(pDevIns, iIrq, iLevel);
-#else
-    pDevIns->pDevHlp->pfnPCISetIrqNoWait(pDevIns, iIrq, iLevel);
-#endif
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnISASetIrq
+    pDevIns->CTX_SUFF(pDevHlp)->pfnPCISetIrq(pDevIns, iIrq, iLevel);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnISASetIrq
  */
 DECLINLINE(void) PDMDevHlpISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
-#ifdef IN_GC
-    pDevIns->pDevHlpGC->pfnISASetIrq(pDevIns, iIrq, iLevel);
-#elif defined(IN_RING0)
-    pDevIns->pDevHlpR0->pfnISASetIrq(pDevIns, iIrq, iLevel);
-#else
-    pDevIns->pDevHlp->pfnISASetIrq(pDevIns, iIrq, iLevel);
-#endif
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnISASetIrqNoWait
+    pDevIns->CTX_SUFF(pDevHlp)->pfnISASetIrq(pDevIns, iIrq, iLevel);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnISASetIrqNoWait
  */
 DECLINLINE(void) PDMDevHlpISASetIrqNoWait(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
-#ifdef IN_GC
-    pDevIns->pDevHlpGC->pfnISASetIrq(pDevIns, iIrq, iLevel);
-#elif defined(IN_RING0)
-    pDevIns->pDevHlpR0->pfnISASetIrq(pDevIns, iIrq, iLevel);
-#else
-    pDevIns->pDevHlp->pfnISASetIrqNoWait(pDevIns, iIrq, iLevel);
-#endif
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPhysRead
+    pDevIns->CTX_SUFF(pDevHlp)->pfnISASetIrq(pDevIns, iIrq, iLevel);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPhysRead
  */
 DECLINLINE(void) PDMDevHlpPhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
 {
-#ifdef IN_GC
-    pDevIns->pDevHlpGC->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead);
-#elif defined(IN_RING0)
-    pDevIns->pDevHlpR0->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead);
-#else
-    pDevIns->pDevHlp->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead);
-#endif
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnPhysWrite
+    pDevIns->CTX_SUFF(pDevHlp)->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnPhysWrite
  */
 DECLINLINE(void) PDMDevHlpPhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
 {
-#ifdef IN_GC
-    pDevIns->pDevHlpGC->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);
-#elif defined(IN_RING0)
-    pDevIns->pDevHlpR0->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);
-#else
-    pDevIns->pDevHlp->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);
-#endif
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnA20IsEnabled
+    pDevIns->CTX_SUFF(pDevHlp)->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnA20IsEnabled
  */
 DECLINLINE(bool) PDMDevHlpA20IsEnabled(PPDMDEVINS pDevIns)
 {
-#ifdef IN_GC
-    return pDevIns->pDevHlpGC->pfnA20IsEnabled(pDevIns);
-#elif defined(IN_RING0)
-    return pDevIns->pDevHlpR0->pfnA20IsEnabled(pDevIns);
-#else
-    return pDevIns->pDevHlp->pfnA20IsEnabled(pDevIns);
-#endif
-}
-
-/**
- * @copydoc PDMDEVHLP::pfnVMSetError
+    return pDevIns->CTX_SUFF(pDevHlp)->pfnA20IsEnabled(pDevIns);
+}
+
+/**
+ * @copydoc PDMDEVHLPR3::pfnVMSetError
  */
 DECLINLINE(int) PDMDevHlpVMSetError(PPDMDEVINS pDevIns, const int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
@@ -3655 +3618 @@
     va_list va;
     va_start(va, pszFormat);
-#ifdef IN_GC
-    pDevIns->pDevHlpGC->pfnVMSetErrorV(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
-#elif defined(IN_RING0)
-    pDevIns->pDevHlpR0->pfnVMSetErrorV(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
-#else
-    pDevIns->pDevHlp->pfnVMSetErrorV(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
-#endif
+    pDevIns->CTX_SUFF(pDevHlp)->pfnVMSetErrorV(pDevIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
     va_end(va);
     return rc;
@@ -3667 +3624 @@
 
 /**
- * @copydoc PDMDEVHLP::pfnVMSetRuntimeError
+ * @copydoc PDMDEVHLPR3::pfnVMSetRuntimeError
  */
 DECLINLINE(int) PDMDevHlpVMSetRuntimeError(PPDMDEVINS pDevIns, bool fFatal, const char *pszErrorID, const char *pszFormat, ...)
@@ -3674 +3631 @@
     int rc;
     va_start(va, pszFormat);
-#ifdef IN_GC
-    rc = pDevIns->pDevHlpGC->pfnVMSetRuntimeErrorV(pDevIns, fFatal, pszErrorID, pszFormat, va);
-#elif defined(IN_RING0)
-    rc = pDevIns->pDevHlpR0->pfnVMSetRuntimeErrorV(pDevIns, fFatal, pszErrorID, pszFormat, va);
-#else
-    rc = pDevIns->pDevHlp->pfnVMSetRuntimeErrorV(pDevIns, fFatal, pszErrorID, pszFormat, va);
-#endif
+    rc = pDevIns->CTX_SUFF(pDevHlp)->pfnVMSetRuntimeErrorV(pDevIns, fFatal, pszErrorID, pszFormat, va);
     va_end(va);
     return rc;

trunk/include/VBox/pdmins.h

@@ -53 +53 @@
  * Converts a PDM Device, USB Device, or Driver instance pointer to a RC pointer to the instance data.
  */
-#define PDMINS_2_DATA_RCPTR(pIns)   ( (pIns)->pvInstanceDataGC )
+#define PDMINS_2_DATA_RCPTR(pIns)   ( (pIns)->pvInstanceDataRC )
 
 /** @def PDMINS_2_DATA_R3PTR

trunk/src/VBox/VMM/PDM.cpp

@@ -311 +311 @@
      * Devices.
      */
-    RCPTRTYPE(PCPDMDEVHLPGC) pDevHlpGC;
-    int rc = PDMR3GetSymbolGC(pVM, NULL, "g_pdmGCDevHlp", &pDevHlpGC);
-    AssertReleaseMsgRC(rc, ("rc=%Vrc when resolving g_pdmGCDevHlp\n", rc));
-    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
+    PCPDMDEVHLPRC pDevHlpRC;
+    int rc = PDMR3GetSymbolGC(pVM, NULL, "g_pdmRCDevHlp", &pDevHlpRC);
+    AssertReleaseMsgRC(rc, ("rc=%Vrc when resolving g_pdmRCDevHlp\n", rc));
+    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
     {
         if (pDevIns->pDevReg->fFlags & PDM_DEVREG_FLAGS_GC)
         {
-            pDevIns->pDevHlpGC = pDevHlpGC;
-            pDevIns->pvInstanceDataGC = MMHyperR3ToRC(pVM, pDevIns->pvInstanceDataR3);
-            pDevIns->pvInstanceDataR0 = MMHyperR3ToR0(pVM, pDevIns->pvInstanceDataR3);
-            pDevIns->Internal.s.pVMGC = pVM->pVMGC;
-            if (pDevIns->Internal.s.pPciBusHC)
-                pDevIns->Internal.s.pPciBusGC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciBusHC);
-            if (pDevIns->Internal.s.pPciDeviceHC)
-                pDevIns->Internal.s.pPciDeviceGC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciDeviceHC);
+            pDevIns->pDevHlpRC = pDevHlpRC;
+            pDevIns->pvInstanceDataRC = MMHyperR3ToRC(pVM, pDevIns->pvInstanceDataR3);
+            pDevIns->Internal.s.pVMRC = pVM->pVMRC;
+            if (pDevIns->Internal.s.pPciBusR3)
+                pDevIns->Internal.s.pPciBusRC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciBusR3);
+            if (pDevIns->Internal.s.pPciDeviceR3)
+                pDevIns->Internal.s.pPciDeviceRC = MMHyperR3ToRC(pVM, pDevIns->Internal.s.pPciDeviceR3);
             if (pDevIns->pDevReg->pfnRelocate)
             {
@@ -416 +415 @@
 
     /* then the 'normal' ones. */
-    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
-    {
-        pdmR3TermLuns(pVM, pDevIns->Internal.s.pLunsHC, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance);
+    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
+    {
+        pdmR3TermLuns(pVM, pDevIns->Internal.s.pLunsR3, pDevIns->pDevReg->szDeviceName, pDevIns->iInstance);
 
         if (pDevIns->pDevReg->pfnDestruct)
@@ -508 +507 @@
     /** @todo We might have to filter out some device classes, like USB attached devices. */
     uint32_t i = 0;
-    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC, i++)
+    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3, i++)
     {
         SSMR3PutU32(pSSM, i);
@@ -626 +625 @@
     uint32_t i = 0;
     PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances;
-    for (;;pDevIns = pDevIns->Internal.s.pNextHC, i++)
+    for (;;pDevIns = pDevIns->Internal.s.pNextR3, i++)
     {
         /* Get the separator / terminator. */
@@ -694 +693 @@
      * The attached drivers are processed first.
      */
-    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
-    {
-        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
+    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
+    {
+        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
             /** @todo Inverse the order here? */
             for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
@@ -767 +766 @@
      * The attached drivers are processed first.
      */
-    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
-    {
-        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
+    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
+    {
+        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
             /** @todo Inverse the order here? */
             for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
@@ -826 +825 @@
      * The attached drivers are processed first.
      */
-    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
-    {
-        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
+    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
+    {
+        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
             for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
                 if (pDrvIns->pDrvReg->pfnSuspend)
@@ -889 +888 @@
      * The attached drivers are processed first.
      */
-    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
-    {
-        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
+    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
+    {
+        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
             for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
                 if (pDrvIns->pDrvReg->pfnResume)
@@ -952 +951 @@
      * The attached drivers are processed first.
      */
-    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextHC)
-    {
-        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsHC; pLun; pLun = pLun->pNext)
+    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
+    {
+        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
             for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
                 if (pDrvIns->pDrvReg->pfnPowerOff)
@@ -1031 +1030 @@
              * 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)

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)

trunk/src/VBox/VMM/PDMDriver.cpp

@@ -1087 +1087 @@
 
 
-/** @copydoc PDMDEVHLP::pfnVMState */
+/** @copydoc PDMDEVHLPR3::pfnVMState */
 static DECLCALLBACK(VMSTATE) pdmR3DrvHlp_VMState(PPDMDRVINS pDrvIns)
 {

trunk/src/VBox/VMM/PDMInternal.h

@@ -85 +85 @@
     /** Pointer to the next instance (HC Ptr).
      * (Head is pointed to by PDM::pDevInstances.) */
-    R3PTRTYPE(PPDMDEVINS)           pNextHC;
+    R3PTRTYPE(PPDMDEVINS)           pNextR3;
     /** Pointer to the next per device instance (HC Ptr).
      * (Head is pointed to by PDMDEV::pInstances.) */
-    R3PTRTYPE(PPDMDEVINS)           pPerDeviceNextHC;
-
+    R3PTRTYPE(PPDMDEVINS)           pPerDeviceNextR3;
     /** Pointer to device structure - HC Ptr. */
-    R3PTRTYPE(PPDMDEV)              pDevHC;
-
-    /** Pointer to the VM this instance was created for - HC Ptr. */
-    R3R0PTRTYPE(PVM)                pVMHC;
+    R3PTRTYPE(PPDMDEV)              pDevR3;
     /** Pointer to the list of logical units associated with the device. (FIFO) */
-    R3PTRTYPE(PPDMLUN)              pLunsHC;
+    R3PTRTYPE(PPDMLUN)              pLunsR3;
     /** Configuration handle to the instance node. */
     R3PTRTYPE(PCFGMNODE)            pCfgHandle;
-    /** HC pointer to associated PCI device structure. */
-    R3R0PTRTYPE(struct PCIDevice *) pPciDeviceHC;
-    /** HC pointer to associated PCI bus structure. */
-    R3R0PTRTYPE(PPDMPCIBUS)         pPciBusHC;
-
-    /** GC pointer to associated PCI device structure. */
-    RCPTRTYPE(struct PCIDevice *)   pPciDeviceGC;
-    /** Pointer to the VM this instance was created for - GC Ptr. */
-    RCPTRTYPE(PVM)                  pVMGC;
-    /** GC pointer to associated PCI bus structure. */
-    RCPTRTYPE(PPDMPCIBUS)           pPciBusGC;
+
+    /** R3 pointer to the VM this instance was created for. */
+    PVMR3                           pVMR3;
+    /** R3 pointer to associated PCI device structure. */
+    R3PTRTYPE(struct PCIDevice *)   pPciDeviceR3;
+    /** R3 pointer to associated PCI bus structure. */
+    R3PTRTYPE(PPDMPCIBUS)           pPciBusR3;
+
+    /** R0 pointer to the VM this instance was created for. */
+    PVMR0                           pVMR0;
+    /** R0 pointer to associated PCI device structure. */
+    R0PTRTYPE(struct PCIDevice *)   pPciDeviceR0;
+    /** R0 pointer to associated PCI bus structure. */
+    R0PTRTYPE(PPDMPCIBUS)           pPciBusR0;
     /** Alignment padding. */
-    uint32_t                        Alignment0;
+    RTR0PTR                         Alignment0;
+
+    /** RC pointer to the VM this instance was created for. */
+    PVMRC                           pVMRC;
+    /** RC pointer to associated PCI device structure. */
+    RCPTRTYPE(struct PCIDevice *)   pPciDeviceRC;
+    /** RC pointer to associated PCI bus structure. */
+    RCPTRTYPE(PPDMPCIBUS)           pPciBusRC;
+    /** Alignment padding. */
+    RTRCPTR                         Alignment1;
 } PDMDEVINSINT;
 
@@ -161 +169 @@
     /** Pointer to the driver instance above.
      * This is NULL for the topmost drive. */
-    PPDMDRVINS          pUp;
+    PPDMDRVINS                      pUp;
     /** Pointer to the driver instance below.
      * This is NULL for the bottommost driver. */
-    PPDMDRVINS          pDown;
+    PPDMDRVINS                      pDown;
     /** Pointer to the logical unit this driver chained on. */
-    PPDMLUN             pLun;
+    PPDMLUN                         pLun;
     /** Pointer to driver structure from which this was instantiated. */
-    PPDMDRV             pDrv;
+    PPDMDRV                         pDrv;
     /** Pointer to the VM this instance was created for. */
-    PVM                 pVM;
+    PVM                             pVM;
     /** Flag indicating that the driver is being detached and destroyed.
      * (Helps detect potential recursive detaching.) */
-    bool                fDetaching;
+    bool                            fDetaching;
     /** Configuration handle to the instance node. */
-    PCFGMNODE           pCfgHandle;
+    PCFGMNODE                       pCfgHandle;
 
 } PDMDRVINSINT;
@@ -186 +194 @@
 {
     /** The critical section core which is shared with IPRT. */
-    RTCRITSECT          Core;
+    RTCRITSECT                      Core;
     /** Pointer to the next critical section.
      * This chain is used for relocating pVMGC and device cleanup. */
@@ -193 +201 @@
      * This is pDevIns if the owner is a device. Similarily for a driver or service.
      * PDMR3CritSectInit() sets this to point to the critsect itself. */
-    RTR3PTR             pvKey;
+    RTR3PTR                         pvKey;
     /** Pointer to the VM - R3Ptr. */
-    R3PTRTYPE(PVM)      pVMR3;
+    R3PTRTYPE(PVM)                  pVMR3;
     /** Pointer to the VM - R0Ptr. */
-    R0PTRTYPE(PVM)      pVMR0;
+    R0PTRTYPE(PVM)                  pVMR0;
     /** Pointer to the VM - GCPtr. */
-    RCPTRTYPE(PVM)      pVMGC;
+    RCPTRTYPE(PVM)                  pVMGC;
 #if HC_ARCH_BITS == 64
     uint32_t            padding;
@@ -205 +213 @@
     /** Event semaphore that is scheduled to be signaled upon leaving the
      * critical section. This is Ring-3 only of course. */
-    RTSEMEVENT          EventToSignal;
+    RTSEMEVENT                      EventToSignal;
     /** R0/GC lock contention. */
-    STAMCOUNTER         StatContentionR0GCLock;
+    STAMCOUNTER                     StatContentionR0GCLock;
     /** R0/GC unlock contention. */
-    STAMCOUNTER         StatContentionR0GCUnlock;
+    STAMCOUNTER                     StatContentionR0GCUnlock;
     /** R3 lock contention. */
-    STAMCOUNTER         StatContentionR3;
+    STAMCOUNTER                     StatContentionR3;
     /** Profiling the time the section is locked. */
-    STAMPROFILEADV      StatLocked;
+    STAMPROFILEADV                  StatLocked;
 } PDMCRITSECTINT, *PPDMCRITSECTINT;
 
@@ -277 +285 @@
  * device, like for instance the PS/2 keyboard port on the
  * keyboard controller device. The LUNs are chained on the
- * device the belong to (PDMDEVINSINT::pLunsHC).
+ * device the belong to (PDMDEVINSINT::pLunsR3).
  */
 typedef struct PDMLUN

trunk/src/VBox/VMM/VMMGC/PDMGCDevice.cpp

@@ -48 +48 @@
 # define PDMDEV_ASSERT_DEVINS(pDevIns)   do { Assert(VALID_PTR(pDevIns)); \
                                               Assert(pDevIns->u32Version == PDM_DEVINS_VERSION); \
-                                              Assert(pDevIns->pvInstanceDataGC == (void *)&pDevIns->achInstanceData[0]); \
+                                              Assert(pDevIns->pvInstanceDataRC == (void *)&pDevIns->achInstanceData[0]); \
                                          } while (0)
 #else
@@ -59 +59 @@
 *******************************************************************************/
 __BEGIN_DECLS
-extern DECLEXPORT(const PDMDEVHLPGC)    g_pdmGCDevHlp;
+extern DECLEXPORT(const PDMDEVHLPRC)    g_pdmRCDevHlp;
 extern DECLEXPORT(const PDMPICHLPRC)    g_pdmRCPicHlp;
 extern DECLEXPORT(const PDMAPICHLPRC)   g_pdmRCApicHlp;
@@ -136 +136 @@
  * The Guest Context Device Helper Callbacks.
  */
-extern DECLEXPORT(const PDMDEVHLPGC) g_pdmGCDevHlp =
-{
-    PDM_DEVHLPGC_VERSION,
+extern DECLEXPORT(const PDMDEVHLPRC) g_pdmRCDevHlp =
+{
+    PDM_DEVHLPRC_VERSION,
     pdmGCDevHlp_PCISetIrq,
     pdmGCDevHlp_ISASetIrq,
@@ -149 +149 @@
     pdmGCDevHlp_VMSetRuntimeErrorV,
     pdmGCDevHlp_PATMSetMMIOPatchInfo,
-    PDM_DEVHLPGC_VERSION
+    PDM_DEVHLPRC_VERSION
 };
 
@@ -211 +211 @@
 
 
-/** @copydoc PDMDEVHLPGC::pfnPCISetIrq */
+/** @copydoc PDMDEVHLPRC::pfnPCISetIrq */
 static DECLCALLBACK(void) pdmGCDevHlp_PCISetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
@@ -217 +217 @@
     LogFlow(("pdmGCDevHlp_PCISetIrq: caller=%p/%d: iIrq=%d iLevel=%d\n", pDevIns, pDevIns->iInstance, iIrq, iLevel));
 
-    PVM         pVM     = pDevIns->Internal.s.pVMGC;
-    PPCIDEVICE  pPciDev = pDevIns->Internal.s.pPciDeviceGC;
-    PPDMPCIBUS  pPciBus = pDevIns->Internal.s.pPciBusGC;
+    PVM         pVM     = pDevIns->Internal.s.pVMRC;
+    PPCIDEVICE  pPciDev = pDevIns->Internal.s.pPciDeviceRC;
+    PPDMPCIBUS  pPciBus = pDevIns->Internal.s.pPciBusRC;
     if (    pPciDev
         &&  pPciBus
@@ -249 +249 @@
 
 
-/** @copydoc PDMDEVHLPGC::pfnPCISetIrq */
+/** @copydoc PDMDEVHLPRC::pfnPCISetIrq */
 static DECLCALLBACK(void) pdmGCDevHlp_ISASetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
 {
@@ -255 +255 @@
     LogFlow(("pdmGCDevHlp_ISASetIrq: caller=%p/%d: iIrq=%d iLevel=%d\n", pDevIns, pDevIns->iInstance, iIrq, iLevel));
 
-    pdmGCIsaSetIrq(pDevIns->Internal.s.pVMGC, iIrq, iLevel);
+    pdmGCIsaSetIrq(pDevIns->Internal.s.pVMRC, iIrq, iLevel);
 
     LogFlow(("pdmGCDevHlp_ISASetIrq: caller=%p/%d: returns void\n", pDevIns, pDevIns->iInstance));
@@ -261 +261 @@
 
 
-/** @copydoc PDMDEVHLPGC::pfnPhysRead */
+/** @copydoc PDMDEVHLPRC::pfnPhysRead */
 static DECLCALLBACK(void) pdmGCDevHlp_PhysRead(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
 {
@@ -268 +268 @@
              pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
 
-    PGMPhysRead(pDevIns->Internal.s.pVMGC, GCPhys, pvBuf, cbRead);
+    PGMPhysRead(pDevIns->Internal.s.pVMRC, GCPhys, pvBuf, cbRead);
 
     Log(("pdmGCDevHlp_PhysRead: caller=%p/%d: returns void\n", pDevIns, pDevIns->iInstance));
@@ -274 +274 @@
 
 
-/** @copydoc PDMDEVHLPGC::pfnPhysWrite */
+/** @copydoc PDMDEVHLPRC::pfnPhysWrite */
 static DECLCALLBACK(void) pdmGCDevHlp_PhysWrite(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
 {
@@ -281 +281 @@
              pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
 
-    PGMPhysWrite(pDevIns->Internal.s.pVMGC, GCPhys, pvBuf, cbWrite);
+    PGMPhysWrite(pDevIns->Internal.s.pVMRC, GCPhys, pvBuf, cbWrite);
 
     Log(("pdmGCDevHlp_PhysWrite: caller=%p/%d: returns void\n", pDevIns, pDevIns->iInstance));
@@ -287 +287 @@
 
 
-/** @copydoc PDMDEVHLPGC::pfnA20IsEnabled */
+/** @copydoc PDMDEVHLPRC::pfnA20IsEnabled */
 static DECLCALLBACK(bool) pdmGCDevHlp_A20IsEnabled(PPDMDEVINS pDevIns)
 {
@@ -293 +293 @@
     LogFlow(("pdmGCDevHlp_A20IsEnabled: caller=%p/%d:\n", pDevIns, pDevIns->iInstance));
 
-    bool fEnabled = PGMPhysIsA20Enabled(pDevIns->Internal.s.pVMGC);
+    bool fEnabled = PGMPhysIsA20Enabled(pDevIns->Internal.s.pVMRC);
 
     Log(("pdmGCDevHlp_A20IsEnabled: caller=%p/%d: returns %RTbool\n", pDevIns, pDevIns->iInstance, fEnabled));
@@ -300 +300 @@
 
 
-/** @copydoc PDMDEVHLPGC::pfnVMSetError */
+/** @copydoc PDMDEVHLPRC::pfnVMSetError */
 static DECLCALLBACK(int) pdmGCDevHlp_VMSetError(PPDMDEVINS pDevIns, int rc, RT_SRC_POS_DECL, const char *pszFormat, ...)
 {
@@ -306 +306 @@
     va_list args;
     va_start(args, pszFormat);
-    int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMGC, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc2 == rc); NOREF(rc2);
+    int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMRC, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc2 == rc); NOREF(rc2);
     va_end(args);
     return rc;
@@ -312 +312 @@
 
 
-/** @copydoc PDMDEVHLPGC::pfnVMSetErrorV */
+/** @copydoc PDMDEVHLPRC::pfnVMSetErrorV */
 static DECLCALLBACK(int) pdmGCDevHlp_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.pVMGC, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
+    int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMRC, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
     return rc;
 }
 
 
-/** @copydoc PDMDEVHLPGC::pfnVMSetRuntimeError */
+/** @copydoc PDMDEVHLPRC::pfnVMSetRuntimeError */
 static DECLCALLBACK(int) pdmGCDevHlp_VMSetRuntimeError(PPDMDEVINS pDevIns, bool fFatal, const char *pszErrorID, const char *pszFormat, ...)
 {
@@ -327 +327 @@
     va_list args;
     va_start(args, pszFormat);
-    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMGC, fFatal, pszErrorID, pszFormat, args);
+    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMRC, fFatal, pszErrorID, pszFormat, args);
     va_end(args);
     return rc;
@@ -333 +333 @@
 
 
-/** @copydoc PDMDEVHLPGC::pfnVMSetErrorV */
+/** @copydoc PDMDEVHLPRC::pfnVMSetErrorV */
 static DECLCALLBACK(int) pdmGCDevHlp_VMSetRuntimeErrorV(PPDMDEVINS pDevIns, bool fFatal, const char *pszErrorID, const char *pszFormat, va_list va)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMGC, fFatal, pszErrorID, pszFormat, va);
+    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMRC, fFatal, pszErrorID, pszFormat, va);
     return rc;
 }
 
 
-/** @copydoc PDMDEVHLPGC::pfnPATMSetMMIOPatchInfo */
+/** @copydoc PDMDEVHLPRC::pfnPATMSetMMIOPatchInfo */
 static DECLCALLBACK(int) pdmGCDevHlp_PATMSetMMIOPatchInfo(PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPTR pCachedData)
 {
@@ -348 +348 @@
     LogFlow(("pdmGCDevHlp_PATMSetMMIOPatchInfo: caller=%p/%d:\n", pDevIns, pDevIns->iInstance));
 
-    return PATMSetMMIOPatchInfo(pDevIns->Internal.s.pVMGC, GCPhys, (RTRCPTR)pCachedData);
+    return PATMSetMMIOPatchInfo(pDevIns->Internal.s.pVMRC, GCPhys, (RTRCPTR)pCachedData);
 }
 
@@ -359 +359 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     LogFlow(("pdmRCPicHlp_SetInterruptFF: caller=%p/%d: VM_FF_INTERRUPT_PIC %d -> 1\n",
-             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMGC, 0, VM_FF_INTERRUPT_PIC)));
+             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMRC, 0, VM_FF_INTERRUPT_PIC)));
     /* for PIC we always deliver to CPU 0, MP use APIC */
-    VMCPU_FF_SET(pDevIns->Internal.s.pVMGC, 0, VM_FF_INTERRUPT_PIC);
+    VMCPU_FF_SET(pDevIns->Internal.s.pVMRC, 0, VM_FF_INTERRUPT_PIC);
 }
 
@@ -370 +370 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     LogFlow(("pdmRCPicHlp_ClearInterruptFF: caller=%p/%d: VM_FF_INTERRUPT_PIC %d -> 0\n",
-             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMGC, 0, VM_FF_INTERRUPT_PIC)));
+             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMRC, 0, VM_FF_INTERRUPT_PIC)));
     /* for PIC we always deliver to CPU 0, MP use APIC */
-    VMCPU_FF_CLEAR(pDevIns->Internal.s.pVMGC, 0, VM_FF_INTERRUPT_PIC);
+    VMCPU_FF_CLEAR(pDevIns->Internal.s.pVMRC, 0, VM_FF_INTERRUPT_PIC);
 }
 
@@ -380 +380 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMGC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMRC, rc);
 }
 
@@ -388 +388 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMGC);
+    pdmUnlock(pDevIns->Internal.s.pVMRC);
 }
 
@@ -399 +399 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     LogFlow(("pdmRCApicHlp_SetInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 1\n",
-             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMGC, idCpu, VM_FF_INTERRUPT_APIC)));
-    VMCPU_FF_SET(pDevIns->Internal.s.pVMGC, idCpu, VM_FF_INTERRUPT_APIC);
+             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMRC, idCpu, VM_FF_INTERRUPT_APIC)));
+    VMCPU_FF_SET(pDevIns->Internal.s.pVMRC, idCpu, VM_FF_INTERRUPT_APIC);
 }
 
@@ -409 +409 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     LogFlow(("pdmRCApicHlp_ClearInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 0\n",
-             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMGC, idCpu, VM_FF_INTERRUPT_APIC)));
-    VMCPU_FF_CLEAR(pDevIns->Internal.s.pVMGC, idCpu, VM_FF_INTERRUPT_APIC);
+             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMRC, idCpu, VM_FF_INTERRUPT_APIC)));
+    VMCPU_FF_CLEAR(pDevIns->Internal.s.pVMRC, idCpu, VM_FF_INTERRUPT_APIC);
 }
 
@@ -420 +420 @@
     LogFlow(("pdmRCApicHlp_ChangeFeature: caller=%p/%d: fEnabled=%RTbool\n", pDevIns, pDevIns->iInstance, fEnabled));
     if (fEnabled)
-        CPUMSetGuestCpuIdFeature(pDevIns->Internal.s.pVMGC, CPUMCPUIDFEATURE_APIC);
+        CPUMSetGuestCpuIdFeature(pDevIns->Internal.s.pVMRC, CPUMCPUIDFEATURE_APIC);
     else
-        CPUMClearGuestCpuIdFeature(pDevIns->Internal.s.pVMGC, CPUMCPUIDFEATURE_APIC);
+        CPUMClearGuestCpuIdFeature(pDevIns->Internal.s.pVMRC, CPUMCPUIDFEATURE_APIC);
 }
 
@@ -430 +430 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMGC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMRC, rc);
 }
 
@@ -438 +438 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMGC);
+    pdmUnlock(pDevIns->Internal.s.pVMRC);
 }
 
@@ -446 +446 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return VMMGetCpuId(pDevIns->Internal.s.pVMGC);
+    return VMMGetCpuId(pDevIns->Internal.s.pVMRC);
 }
 
@@ -454 +454 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMGC;
+    PVM pVM = pDevIns->Internal.s.pVMRC;
     LogFlow(("pdmRCIoApicHlp_ApicBusDeliver: caller=%p/%d: u8Dest=%RX8 u8DestMode=%RX8 u8DeliveryMode=%RX8 iVector=%RX8 u8Polarity=%RX8 u8TriggerMode=%RX8\n",
              pDevIns, pDevIns->iInstance, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode));
@@ -466 +466 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMGC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMRC, rc);
 }
 
@@ -474 +474 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMGC);
+    pdmUnlock(pDevIns->Internal.s.pVMRC);
 }
 
@@ -485 +485 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     Log4(("pdmRCPciHlp_IsaSetIrq: iIrq=%d iLevel=%d\n", iIrq, iLevel));
-    pdmGCIsaSetIrq(pDevIns->Internal.s.pVMGC, iIrq, iLevel);
+    pdmGCIsaSetIrq(pDevIns->Internal.s.pVMRC, iIrq, iLevel);
 }
 
@@ -494 +494 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     Log4(("pdmRCPciHlp_IsaSetIrq: iIrq=%d iLevel=%d\n", iIrq, iLevel));
-    pdmGCIoApicSetIrq(pDevIns->Internal.s.pVMGC, iIrq, iLevel);
+    pdmGCIoApicSetIrq(pDevIns->Internal.s.pVMRC, iIrq, iLevel);
 }
 
@@ -502 +502 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMGC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMRC, rc);
 }
 
@@ -510 +510 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMGC);
+    pdmUnlock(pDevIns->Internal.s.pVMRC);
 }
 

trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp

@@ -217 +217 @@
     LogFlow(("pdmR0DevHlp_PCISetIrq: caller=%p/%d: iIrq=%d iLevel=%d\n", pDevIns, pDevIns->iInstance, iIrq, iLevel));
 
-    PVM          pVM     = pDevIns->Internal.s.pVMHC;
-    PPCIDEVICE   pPciDev = pDevIns->Internal.s.pPciDeviceHC;
-    PPDMPCIBUS   pPciBus = pDevIns->Internal.s.pPciBusHC;
+    PVM          pVM     = pDevIns->Internal.s.pVMR0;
+    PPCIDEVICE   pPciDev = pDevIns->Internal.s.pPciDeviceR0;
+    PPDMPCIBUS   pPciBus = pDevIns->Internal.s.pPciBusR0;
     if (    pPciDev
         &&  pPciBus
@@ -255 +255 @@
     LogFlow(("pdmR0DevHlp_ISASetIrq: caller=%p/%d: iIrq=%d iLevel=%d\n", pDevIns, pDevIns->iInstance, iIrq, iLevel));
 
-    pdmR0IsaSetIrq(pDevIns->Internal.s.pVMHC, iIrq, iLevel);
+    pdmR0IsaSetIrq(pDevIns->Internal.s.pVMR0, iIrq, iLevel);
 
     LogFlow(("pdmR0DevHlp_ISASetIrq: caller=%p/%d: returns void\n", pDevIns, pDevIns->iInstance));
@@ -268 +268 @@
              pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
 
-    PGMPhysRead(pDevIns->Internal.s.pVMHC, GCPhys, pvBuf, cbRead);
+    PGMPhysRead(pDevIns->Internal.s.pVMR0, GCPhys, pvBuf, cbRead);
 
     Log(("pdmR0DevHlp_PhysRead: caller=%p/%d: returns void\n", pDevIns, pDevIns->iInstance));
@@ -281 +281 @@
              pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
 
-    PGMPhysWrite(pDevIns->Internal.s.pVMHC, GCPhys, pvBuf, cbWrite);
+    PGMPhysWrite(pDevIns->Internal.s.pVMR0, GCPhys, pvBuf, cbWrite);
 
     Log(("pdmR0DevHlp_PhysWrite: caller=%p/%d: returns void\n", pDevIns, pDevIns->iInstance));
@@ -293 +293 @@
     LogFlow(("pdmR0DevHlp_A20IsEnabled: caller=%p/%d:\n", pDevIns, pDevIns->iInstance));
 
-    bool fEnabled = PGMPhysIsA20Enabled(pDevIns->Internal.s.pVMHC);
+    bool fEnabled = PGMPhysIsA20Enabled(pDevIns->Internal.s.pVMR0);
 
     Log(("pdmR0DevHlp_A20IsEnabled: caller=%p/%d: returns %RTbool\n", pDevIns, pDevIns->iInstance, fEnabled));
@@ -306 +306 @@
     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.pVMR0, rc, RT_SRC_POS_ARGS, pszFormat, args); Assert(rc2 == rc); NOREF(rc2);
     va_end(args);
     return rc;
@@ -316 +316 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMHC, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
+    int rc2 = VMSetErrorV(pDevIns->Internal.s.pVMR0, rc, RT_SRC_POS_ARGS, pszFormat, va); Assert(rc2 == rc); NOREF(rc2);
     return rc;
 }
@@ -327 +327 @@
     va_list args;
     va_start(args, pszFormat);
-    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMHC, fFatal, pszErrorID, pszFormat, args);
+    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMR0, fFatal, pszErrorID, pszFormat, args);
     va_end(args);
     return rc;
@@ -337 +337 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMHC, fFatal, pszErrorID, pszFormat, va);
+    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMR0, fFatal, pszErrorID, pszFormat, va);
     return rc;
 }
@@ -350 +350 @@
     AssertFailed();
 
-/*    return PATMSetMMIOPatchInfo(pDevIns->Internal.s.pVMHC, GCPhys, pCachedData); */
+/*    return PATMSetMMIOPatchInfo(pDevIns->Internal.s.pVMR0, GCPhys, pCachedData); */
     return VINF_SUCCESS;
 }
@@ -363 +363 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     LogFlow(("pdmR0PicHlp_SetInterruptFF: caller=%p/%d: VM_FF_INTERRUPT_PIC %d -> 1\n",
-             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMHC, 0, VM_FF_INTERRUPT_PIC)));
+             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMR0, 0, VM_FF_INTERRUPT_PIC)));
     /* for PIC we always deliver to CPU 0, MP use APIC */
-    VMCPU_FF_SET(pDevIns->Internal.s.pVMHC, 0, VM_FF_INTERRUPT_PIC);
+    VMCPU_FF_SET(pDevIns->Internal.s.pVMR0, 0, VM_FF_INTERRUPT_PIC);
 }
 
@@ -374 +374 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     LogFlow(("pdmR0PicHlp_ClearInterruptFF: caller=%p/%d: VM_FF_INTERRUPT_PIC %d -> 0\n",
-             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMHC, 0, VM_FF_INTERRUPT_PIC)));
+             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMR0, 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);
+    VMCPU_FF_CLEAR(pDevIns->Internal.s.pVMR0, 0, VM_FF_INTERRUPT_PIC);
 }
 
@@ -384 +384 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMHC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMR0, rc);
 }
 
@@ -392 +392 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMHC);
+    pdmUnlock(pDevIns->Internal.s.pVMR0);
 }
 
@@ -403 +403 @@
 
     LogFlow(("pdmR0ApicHlp_SetInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 1\n",
-             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMHC, idCpu, VM_FF_INTERRUPT_APIC)));
-    VMCPU_FF_SET(pDevIns->Internal.s.pVMHC, idCpu, VM_FF_INTERRUPT_APIC);
+             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMR0, idCpu, VM_FF_INTERRUPT_APIC)));
+    VMCPU_FF_SET(pDevIns->Internal.s.pVMR0, idCpu, VM_FF_INTERRUPT_APIC);
 }
 
@@ -414 +414 @@
 
     LogFlow(("pdmR0ApicHlp_ClearInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 0\n",
-             pDevIns, 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);
+             pDevIns, pDevIns->iInstance, VMCPU_FF_ISSET(pDevIns->Internal.s.pVMR0, idCpu, VM_FF_INTERRUPT_APIC)));
+    VMCPU_FF_CLEAR(pDevIns->Internal.s.pVMR0, idCpu, VM_FF_INTERRUPT_APIC);
 }
 
@@ -425 +425 @@
     LogFlow(("pdmR0ApicHlp_ChangeFeature: caller=%p/%d: fEnabled=%RTbool\n", pDevIns, pDevIns->iInstance, fEnabled));
     if (fEnabled)
-        CPUMSetGuestCpuIdFeature(pDevIns->Internal.s.pVMHC, CPUMCPUIDFEATURE_APIC);
+        CPUMSetGuestCpuIdFeature(pDevIns->Internal.s.pVMR0, CPUMCPUIDFEATURE_APIC);
     else
-        CPUMClearGuestCpuIdFeature(pDevIns->Internal.s.pVMHC, CPUMCPUIDFEATURE_APIC);
+        CPUMClearGuestCpuIdFeature(pDevIns->Internal.s.pVMR0, CPUMCPUIDFEATURE_APIC);
 }
 
@@ -435 +435 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMHC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMR0, rc);
 }
 
@@ -443 +443 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMHC);
+    pdmUnlock(pDevIns->Internal.s.pVMR0);
 }
 
@@ -451 +451 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return VMMGetCpuId(pDevIns->Internal.s.pVMHC);
+    return VMMGetCpuId(pDevIns->Internal.s.pVMR0);
 }
 
@@ -460 +460 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVM pVM = pDevIns->Internal.s.pVMHC;
+    PVM pVM = pDevIns->Internal.s.pVMR0;
     LogFlow(("pdmR0IoApicHlp_ApicBusDeliver: caller=%p/%d: u8Dest=%RX8 u8DestMode=%RX8 u8DeliveryMode=%RX8 iVector=%RX8 u8Polarity=%RX8 u8TriggerMode=%RX8\n",
              pDevIns, pDevIns->iInstance, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode));
@@ -473 +473 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMHC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMR0, rc);
 }
 
@@ -481 +481 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMHC);
+    pdmUnlock(pDevIns->Internal.s.pVMR0);
 }
 
@@ -493 +493 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     Log4(("pdmR0PciHlp_IsaSetIrq: iIrq=%d iLevel=%d\n", iIrq, iLevel));
-    pdmR0IsaSetIrq(pDevIns->Internal.s.pVMHC, iIrq, iLevel);
+    pdmR0IsaSetIrq(pDevIns->Internal.s.pVMR0, iIrq, iLevel);
 }
 
@@ -502 +502 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     Log4(("pdmR0PciHlp_IsaSetIrq: iIrq=%d iLevel=%d\n", iIrq, iLevel));
-    pdmR0IoApicSetIrq(pDevIns->Internal.s.pVMHC, iIrq, iLevel);
+    pdmR0IoApicSetIrq(pDevIns->Internal.s.pVMR0, iIrq, iLevel);
 }
 
@@ -510 +510 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return pdmLockEx(pDevIns->Internal.s.pVMHC, rc);
+    return pdmLockEx(pDevIns->Internal.s.pVMR0, rc);
 }
 
@@ -518 +518 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    pdmUnlock(pDevIns->Internal.s.pVMHC);
+    pdmUnlock(pDevIns->Internal.s.pVMR0);
 }
 

trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp

@@ -318 +318 @@
     GEN_CHECK_OFF(PDM, StatQueuedCritSectLeaves);
     GEN_CHECK_SIZE(PDMDEVINSINT);
-    GEN_CHECK_OFF(PDMDEVINSINT, pNextHC);
-    GEN_CHECK_OFF(PDMDEVINSINT, pPerDeviceNextHC);
-    GEN_CHECK_OFF(PDMDEVINSINT, pDevHC);
-    GEN_CHECK_OFF(PDMDEVINSINT, pVMHC);
-    GEN_CHECK_OFF(PDMDEVINSINT, pVMGC);
-    GEN_CHECK_OFF(PDMDEVINSINT, pLunsHC);
+    GEN_CHECK_OFF(PDMDEVINSINT, pNextR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pPerDeviceNextR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pDevR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pVMR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pVMR0);
+    GEN_CHECK_OFF(PDMDEVINSINT, pVMRC);
+    GEN_CHECK_OFF(PDMDEVINSINT, pLunsR3);
     GEN_CHECK_OFF(PDMDEVINSINT, pCfgHandle);
-    GEN_CHECK_OFF(PDMDEVINSINT, pPciDeviceHC);
-    GEN_CHECK_OFF(PDMDEVINSINT, pPciDeviceGC);
-    GEN_CHECK_OFF(PDMDEVINSINT, pPciBusHC);
-    GEN_CHECK_OFF(PDMDEVINSINT, pPciBusGC);
+    GEN_CHECK_OFF(PDMDEVINSINT, pPciDeviceR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pPciDeviceR0);
+    GEN_CHECK_OFF(PDMDEVINSINT, pPciDeviceRC);
+    GEN_CHECK_OFF(PDMDEVINSINT, pPciBusR3);
+    GEN_CHECK_OFF(PDMDEVINSINT, pPciBusR0);
+    GEN_CHECK_OFF(PDMDEVINSINT, pPciBusRC);
     GEN_CHECK_SIZE(PDMCRITSECTINT);
     GEN_CHECK_OFF(PDMCRITSECTINT, Core);

trunk/src/VBox/VMM/testcase/tstVMStructSize.cpp

@@ -224 +224 @@
 
     /* pdm */
-    CHECK_MEMBER_ALIGNMENT(PDMDEVINS, achInstanceData, 16);
+    CHECK_MEMBER_ALIGNMENT(PDMDEVINS, achInstanceData, 64);
     CHECK_PADDING(PDMDEVINS, Internal);
     CHECK_MEMBER_ALIGNMENT(PDMUSBINS, achInstanceData, 16);