Index: /trunk/include/VBox/pdmdrv.h
===================================================================
--- /trunk/include/VBox/pdmdrv.h	(revision 26167)
+++ /trunk/include/VBox/pdmdrv.h	(revision 26168)
@@ -350,15 +350,15 @@
 
     /** Pointer the PDM Driver API. */
-    RCPTRTYPE(PCPDMDRVHLPRC)    pDrvHlpRC;
+    RCPTRTYPE(PCPDMDRVHLPRC)    pHlpRC;
     /** Pointer to driver instance data. */
     RCPTRTYPE(void *)           pvInstanceDataRC;
 
     /** Pointer the PDM Driver API. */
-    R0PTRTYPE(PCPDMDRVHLPR0)    pDrvHlpR0;
+    R0PTRTYPE(PCPDMDRVHLPR0)    pHlpR0;
     /** Pointer to driver instance data. */
     R0PTRTYPE(void *)           pvInstanceDataR0;
 
     /** Pointer the PDM Driver API. */
-    R3PTRTYPE(PCPDMDRVHLPR3)    pDrvHlpR3;
+    R3PTRTYPE(PCPDMDRVHLPR3)    pHlpR3;
     /** Pointer to driver instance data. */
     R3PTRTYPE(void *)           pvInstanceDataR3;
@@ -415,6 +415,6 @@
                               ("DrvIns=%#x  mine=%#x\n", (pDrvIns)->u32Version, PDM_DRVINS_VERSION), \
                               VERR_VERSION_MISMATCH); \
-        AssertLogRelMsgReturn(PDM_VERSION_ARE_COMPATIBLE((pDrvIns)->pDrvHlpR3->u32Version, PDM_DRVHLPR3_VERSION), \
-                              ("DrvHlp=%#x  mine=%#x\n", (pDrvIns)->pDrvHlpR3->u32Version, PDM_DRVHLPR3_VERSION), \
+        AssertLogRelMsgReturn(PDM_VERSION_ARE_COMPATIBLE((pDrvIns)->pHlpR3->u32Version, PDM_DRVHLPR3_VERSION), \
+                              ("DrvHlp=%#x  mine=%#x\n", (pDrvIns)->pHlpR3->u32Version, PDM_DRVHLPR3_VERSION), \
                               VERR_VERSION_MISMATCH); \
     } while (0)
@@ -433,5 +433,5 @@
         PPDMDRVINS pDrvInsTypeCheck = (pDrvIns); NOREF(pDrvInsTypeCheck); \
         if (RT_UNLIKELY(   !PDM_VERSION_ARE_COMPATIBLE((pDrvIns)->u32Version, PDM_DRVINS_VERSION) \
-                        || !PDM_VERSION_ARE_COMPATIBLE((pDrvIns)->pDrvHlpR3->u32Version, PDM_DRVHLPR3_VERSION)) ) \
+                        || !PDM_VERSION_ARE_COMPATIBLE((pDrvIns)->pHlpR3->u32Version, PDM_DRVHLPR3_VERSION)) ) \
             return; \
     } while (0)
@@ -943,5 +943,5 @@
     va_list va;
     va_start(va, pszFormat);
-    pDrvIns->CTX_SUFF(pDrvHlp)->pfnVMSetErrorV(pDrvIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
+    pDrvIns->CTX_SUFF(pHlp)->pfnVMSetErrorV(pDrvIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
     va_end(va);
     return rc;
@@ -959,5 +959,5 @@
 DECLINLINE(int) PDMDrvHlpVMSetErrorV(PPDMDRVINS pDrvIns, const int rc, RT_SRC_POS_DECL, const char *pszFormat, va_list va)
 {
-    return pDrvIns->CTX_SUFF(pDrvHlp)->pfnVMSetErrorV(pDrvIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
+    return pDrvIns->CTX_SUFF(pHlp)->pfnVMSetErrorV(pDrvIns, rc, RT_SRC_POS_ARGS, pszFormat, va);
 }
 
@@ -971,5 +971,5 @@
     int rc;
     va_start(va, pszFormat);
-    rc = pDrvIns->CTX_SUFF(pDrvHlp)->pfnVMSetRuntimeErrorV(pDrvIns, fFlags, pszErrorId, pszFormat, va);
+    rc = pDrvIns->CTX_SUFF(pHlp)->pfnVMSetRuntimeErrorV(pDrvIns, fFlags, pszErrorId, pszFormat, va);
     va_end(va);
     return rc;
@@ -987,5 +987,5 @@
 DECLINLINE(int) PDMDrvHlpVMSetRuntimeErrorV(PPDMDRVINS pDrvIns, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va)
 {
-    return pDrvIns->CTX_SUFF(pDrvHlp)->pfnVMSetRuntimeErrorV(pDrvIns, fFlags, pszErrorId, pszFormat, va);
+    return pDrvIns->CTX_SUFF(pHlp)->pfnVMSetRuntimeErrorV(pDrvIns, fFlags, pszErrorId, pszFormat, va);
 }
 
@@ -997,5 +997,5 @@
  */
 #ifdef VBOX_STRICT
-# define PDMDRV_ASSERT_EMT(pDrvIns)  pDrvIns->CTX_SUFF(pDrvHlp)->pfnAssertEMT(pDrvIns, __FILE__, __LINE__, __FUNCTION__)
+# define PDMDRV_ASSERT_EMT(pDrvIns)  pDrvIns->CTX_SUFF(pHlp)->pfnAssertEMT(pDrvIns, __FILE__, __LINE__, __FUNCTION__)
 #else
 # define PDMDRV_ASSERT_EMT(pDrvIns)  do { } while (0)
@@ -1006,5 +1006,5 @@
  */
 #ifdef VBOX_STRICT
-# define PDMDRV_ASSERT_OTHER(pDrvIns)  pDrvIns->CTX_SUFF(pDrvHlp)->pfnAssertOther(pDrvIns, __FILE__, __LINE__, __FUNCTION__)
+# define PDMDRV_ASSERT_OTHER(pDrvIns)  pDrvIns->CTX_SUFF(pHlp)->pfnAssertOther(pDrvIns, __FILE__, __LINE__, __FUNCTION__)
 #else
 # define PDMDRV_ASSERT_OTHER(pDrvIns)  do { } while (0)
@@ -1019,5 +1019,5 @@
 DECLINLINE(int) PDMDrvHlpAttach(PPDMDRVINS pDrvIns, uint32_t fFlags, PPDMIBASE *ppBaseInterface)
 {
-    return pDrvIns->pDrvHlpR3->pfnAttach(pDrvIns, fFlags, ppBaseInterface);
+    return pDrvIns->pHlpR3->pfnAttach(pDrvIns, fFlags, ppBaseInterface);
 }
 
@@ -1030,5 +1030,5 @@
 DECLINLINE(int) PDMDrvHlpNoAttach(PPDMDRVINS pDrvIns)
 {
-    return pDrvIns->pDrvHlpR3->pfnAttach(pDrvIns, 0, NULL);
+    return pDrvIns->pHlpR3->pfnAttach(pDrvIns, 0, NULL);
 }
 
@@ -1038,5 +1038,5 @@
 DECLINLINE(int) PDMDrvHlpDetach(PPDMDRVINS pDrvIns, uint32_t fFlags)
 {
-    return pDrvIns->pDrvHlpR3->pfnDetach(pDrvIns, fFlags);
+    return pDrvIns->pHlpR3->pfnDetach(pDrvIns, fFlags);
 }
 
@@ -1046,5 +1046,5 @@
 DECLINLINE(int) PDMDrvHlpDetachSelf(PPDMDRVINS pDrvIns, uint32_t fFlags)
 {
-    return pDrvIns->pDrvHlpR3->pfnDetachSelf(pDrvIns, fFlags);
+    return pDrvIns->pHlpR3->pfnDetachSelf(pDrvIns, fFlags);
 }
 
@@ -1054,5 +1054,5 @@
 DECLINLINE(int) PDMDrvHlpMountPrepare(PPDMDRVINS pDrvIns, const char *pszFilename, const char *pszCoreDriver)
 {
-    return pDrvIns->pDrvHlpR3->pfnMountPrepare(pDrvIns, pszFilename, pszCoreDriver);
+    return pDrvIns->pHlpR3->pfnMountPrepare(pDrvIns, pszFilename, pszCoreDriver);
 }
 
@@ -1062,5 +1062,5 @@
 DECLINLINE(VMSTATE) PDMDrvHlpVMState(PPDMDRVINS pDrvIns)
 {
-    return pDrvIns->CTX_SUFF(pDrvHlp)->pfnVMState(pDrvIns);
+    return pDrvIns->CTX_SUFF(pHlp)->pfnVMState(pDrvIns);
 }
 
@@ -1070,5 +1070,5 @@
 DECLINLINE(bool) PDMDrvHlpVMTeleportedAndNotFullyResumedYet(PPDMDRVINS pDrvIns)
 {
-    return pDrvIns->pDrvHlpR3->pfnVMTeleportedAndNotFullyResumedYet(pDrvIns);
+    return pDrvIns->pHlpR3->pfnVMTeleportedAndNotFullyResumedYet(pDrvIns);
 }
 
@@ -1079,5 +1079,5 @@
                                         PFNPDMQUEUEDRV pfnCallback, const char *pszName, PPDMQUEUE *ppQueue)
 {
-    return pDrvIns->pDrvHlpR3->pfnPDMQueueCreate(pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, ppQueue);
+    return pDrvIns->pHlpR3->pfnPDMQueueCreate(pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, ppQueue);
 }
 
@@ -1087,5 +1087,5 @@
 DECLINLINE(uint64_t) PDMDrvHlpTMGetVirtualFreq(PPDMDRVINS pDrvIns)
 {
-    return pDrvIns->pDrvHlpR3->pfnTMGetVirtualFreq(pDrvIns);
+    return pDrvIns->pHlpR3->pfnTMGetVirtualFreq(pDrvIns);
 }
 
@@ -1095,5 +1095,5 @@
 DECLINLINE(uint64_t) PDMDrvHlpTMGetVirtualTime(PPDMDRVINS pDrvIns)
 {
-    return pDrvIns->pDrvHlpR3->pfnTMGetVirtualTime(pDrvIns);
+    return pDrvIns->pHlpR3->pfnTMGetVirtualTime(pDrvIns);
 }
 
@@ -1103,5 +1103,5 @@
 DECLINLINE(int) PDMDrvHlpTMTimerCreate(PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
 {
-    return pDrvIns->pDrvHlpR3->pfnTMTimerCreate(pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);
+    return pDrvIns->pHlpR3->pfnTMTimerCreate(pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);
 }
 
@@ -1120,5 +1120,5 @@
                                      PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVLOADEXEC pfnLoadExec)
 {
-    return pDrvIns->pDrvHlpR3->pfnSSMRegister(pDrvIns, uVersion, cbGuess,
+    return pDrvIns->pHlpR3->pfnSSMRegister(pDrvIns, uVersion, cbGuess,
                                               NULL /*pfnLivePrep*/, NULL /*pfnLiveExec*/, NULL /*pfnLiveVote*/,
                                               NULL /*pfnSavePrep*/, pfnSaveExec,          NULL /*pfnSaveDone*/,
@@ -1134,5 +1134,5 @@
                                        PFNSSMDRVLOADPREP pfnLoadPrep, PFNSSMDRVLOADEXEC pfnLoadExec, PFNSSMDRVLOADDONE pfnLoadDone)
 {
-    return pDrvIns->pDrvHlpR3->pfnSSMRegister(pDrvIns, uVersion, cbGuess,
+    return pDrvIns->pHlpR3->pfnSSMRegister(pDrvIns, uVersion, cbGuess,
                                               pfnLivePrep, pfnLiveExec, pfnLiveVote,
                                               pfnSavePrep, pfnSaveExec, pfnSaveDone,
@@ -1149,5 +1149,5 @@
 DECLINLINE(int) PDMDrvHlpSSMRegisterLoadDone(PPDMDRVINS pDrvIns, PFNSSMDRVLOADDONE pfnLoadDone)
 {
-    return pDrvIns->pDrvHlpR3->pfnSSMRegister(pDrvIns, 0 /*uVersion*/, 0 /*cbGuess*/,
+    return pDrvIns->pHlpR3->pfnSSMRegister(pDrvIns, 0 /*uVersion*/, 0 /*cbGuess*/,
                                               NULL /*pfnLivePrep*/, NULL /*pfnLiveExec*/, NULL /*pfnLiveVote*/,
                                               NULL /*pfnSavePrep*/, NULL /*pfnSaveExec*/, NULL /*pfnSaveDone*/,
@@ -1160,5 +1160,5 @@
 DECLINLINE(void) PDMDrvHlpSTAMRegister(PPDMDRVINS pDrvIns, void *pvSample, STAMTYPE enmType, const char *pszName, STAMUNIT enmUnit, const char *pszDesc)
 {
-    pDrvIns->pDrvHlpR3->pfnSTAMRegister(pDrvIns, pvSample, enmType, pszName, enmUnit, pszDesc);
+    pDrvIns->pHlpR3->pfnSTAMRegister(pDrvIns, pvSample, enmType, pszName, enmUnit, pszDesc);
 }
 
@@ -1171,5 +1171,5 @@
     va_list va;
     va_start(va, pszName);
-    pDrvIns->pDrvHlpR3->pfnSTAMRegisterV(pDrvIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, va);
+    pDrvIns->pHlpR3->pfnSTAMRegisterV(pDrvIns, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, va);
     va_end(va);
 }
@@ -1180,5 +1180,5 @@
 DECLINLINE(int) PDMDrvHlpSTAMDeregister(PPDMDRVINS pDrvIns, void *pvSample)
 {
-    return pDrvIns->pDrvHlpR3->pfnSTAMDeregister(pDrvIns, pvSample);
+    return pDrvIns->pHlpR3->pfnSTAMDeregister(pDrvIns, pvSample);
 }
 
@@ -1188,5 +1188,5 @@
 DECLINLINE(int) PDMDrvHlpSUPCallVMMR0Ex(PPDMDRVINS pDrvIns, unsigned uOperation, void *pvArg, unsigned cbArg)
 {
-    return pDrvIns->pDrvHlpR3->pfnSUPCallVMMR0Ex(pDrvIns, uOperation, pvArg, cbArg);
+    return pDrvIns->pHlpR3->pfnSUPCallVMMR0Ex(pDrvIns, uOperation, pvArg, cbArg);
 }
 
@@ -1196,5 +1196,5 @@
 DECLINLINE(int) PDMDrvHlpUSBRegisterHub(PPDMDRVINS pDrvIns, uint32_t fVersions, uint32_t cPorts, PCPDMUSBHUBREG pUsbHubReg, PPCPDMUSBHUBHLP ppUsbHubHlp)
 {
-    return pDrvIns->pDrvHlpR3->pfnUSBRegisterHub(pDrvIns, fVersions, cPorts, pUsbHubReg, ppUsbHubHlp);
+    return pDrvIns->pHlpR3->pfnUSBRegisterHub(pDrvIns, fVersions, cPorts, pUsbHubReg, ppUsbHubHlp);
 }
 
@@ -1204,5 +1204,5 @@
 DECLINLINE(int) PDMDrvHlpSetAsyncNotification(PPDMDRVINS pDrvIns, PFNPDMDRVASYNCNOTIFY pfnAsyncNotify)
 {
-    return pDrvIns->pDrvHlpR3->pfnSetAsyncNotification(pDrvIns, pfnAsyncNotify);
+    return pDrvIns->pHlpR3->pfnSetAsyncNotification(pDrvIns, pfnAsyncNotify);
 }
 
@@ -1212,5 +1212,5 @@
 DECLINLINE(void) PDMDrvHlpAsyncNotificationCompleted(PPDMDRVINS pDrvIns)
 {
-    pDrvIns->pDrvHlpR3->pfnAsyncNotificationCompleted(pDrvIns);
+    pDrvIns->pHlpR3->pfnAsyncNotificationCompleted(pDrvIns);
 }
 
@@ -1221,5 +1221,5 @@
                                          PFNPDMTHREADWAKEUPDRV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName)
 {
-    return pDrvIns->pDrvHlpR3->pfnPDMThreadCreate(pDrvIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
+    return pDrvIns->pHlpR3->pfnPDMThreadCreate(pDrvIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
 }
 
@@ -1231,5 +1231,5 @@
                                                           PFNPDMASYNCCOMPLETEDRV pfnCompleted, void *pvTemplateUser, const char *pszDesc)
 {
-    return pDrvIns->pDrvHlpR3->pfnPDMAsyncCompletionTemplateCreate(pDrvIns, ppTemplate, pfnCompleted, pvTemplateUser, pszDesc);
+    return pDrvIns->pHlpR3->pfnPDMAsyncCompletionTemplateCreate(pDrvIns, ppTemplate, pfnCompleted, pvTemplateUser, pszDesc);
 }
 # endif
Index: /trunk/src/VBox/VMM/PDMDriver.cpp
===================================================================
--- /trunk/src/VBox/VMM/PDMDriver.cpp	(revision 26167)
+++ /trunk/src/VBox/VMM/PDMDriver.cpp	(revision 26168)
@@ -455,10 +455,10 @@
                     //pNew->pDownBase                 = NULL;
                     //pNew->IBase.pfnQueryInterface   = NULL;
-                    pNew->pDrvHlpR3                 = &g_pdmR3DrvHlp;
+                    pNew->pHlpR3                 = &g_pdmR3DrvHlp;
                     pNew->pvInstanceDataR3          = &pNew->achInstanceData[0];
                     if (pDrv->pReg->fFlags & PDM_DRVREG_FLAGS_R0)
                     {
                         pNew->pvInstanceDataR0      = MMHyperR3ToR0(pVM, &pNew->achInstanceData[0]);
-                        rc = PDMR3LdrGetSymbolR0(pVM, NULL, "g_pdmR0DrvHlp", &pNew->pDrvHlpR0);
+                        rc = PDMR3LdrGetSymbolR0(pVM, NULL, "g_pdmR0DrvHlp", &pNew->pHlpR0);
                         AssertReleaseRCReturn(rc, rc);
 
@@ -467,5 +467,5 @@
                     {
                         pNew->pvInstanceDataR0      = MMHyperR3ToRC(pVM, &pNew->achInstanceData[0]);
-                        rc = PDMR3LdrGetSymbolRC(pVM, NULL, "g_pdmRCDrvHlp", &pNew->pDrvHlpRC);
+                        rc = PDMR3LdrGetSymbolRC(pVM, NULL, "g_pdmRCDrvHlp", &pNew->pHlpRC);
                         AssertReleaseRCReturn(rc, rc);
                     }
Index: /trunk/src/VBox/VMM/testcase/tstVMStructRC.cpp
===================================================================
--- /trunk/src/VBox/VMM/testcase/tstVMStructRC.cpp	(revision 26167)
+++ /trunk/src/VBox/VMM/testcase/tstVMStructRC.cpp	(revision 26168)
@@ -396,9 +396,9 @@
     GEN_CHECK_OFF(PDMDRVINS, u32Version);
     GEN_CHECK_OFF(PDMDRVINS, iInstance);
-    GEN_CHECK_OFF(PDMDRVINS, pDrvHlpRC);
+    GEN_CHECK_OFF(PDMDRVINS, pHlpRC);
     GEN_CHECK_OFF(PDMDRVINS, pvInstanceDataRC);
-    GEN_CHECK_OFF(PDMDRVINS, pDrvHlpR0);
+    GEN_CHECK_OFF(PDMDRVINS, pHlpR0);
     GEN_CHECK_OFF(PDMDRVINS, pvInstanceDataR0);
-    GEN_CHECK_OFF(PDMDRVINS, pDrvHlpR3);
+    GEN_CHECK_OFF(PDMDRVINS, pHlpR3);
     GEN_CHECK_OFF(PDMDRVINS, pvInstanceDataR3);
     GEN_CHECK_OFF(PDMDRVINS, pReg);
