Changeset 11219 in vbox for trunk/src/VBox/VMM

Timestamp:

Aug 7, 2008 6:05:58 PM (16 years ago)

Author:

vboxsync

Message:

#1865: DevAPIC.

Location:

trunk/src/VBox/VMM

Files:

• PDM.cpp (modified) (2 diffs)
• PDMDevice.cpp (modified) (17 diffs)
• PDMInternal.h (modified) (3 diffs)
• VMMAll/PDMAll.cpp (modified) (8 diffs)
• VMMGC/PDMGCDevice.cpp (modified) (13 diffs)
• testcase/tstVMStructGC.cpp (modified) (2 diffs)

trunk/src/VBox/VMM/PDM.cpp

@@ -275 +275 @@
      * The registered APIC.
      */
-    if (pVM->pdm.s.Apic.pDevInsGC)
-    {
-        pVM->pdm.s.Apic.pDevInsGC           += offDelta;
-        pVM->pdm.s.Apic.pfnGetInterruptGC   += offDelta;
-        pVM->pdm.s.Apic.pfnSetBaseGC        += offDelta;
-        pVM->pdm.s.Apic.pfnGetBaseGC        += offDelta;
-        pVM->pdm.s.Apic.pfnSetTPRGC         += offDelta;
-        pVM->pdm.s.Apic.pfnGetTPRGC         += offDelta;
-        pVM->pdm.s.Apic.pfnBusDeliverGC     += offDelta;
+    if (pVM->pdm.s.Apic.pDevInsRC)
+    {
+        pVM->pdm.s.Apic.pDevInsRC           += offDelta;
+        pVM->pdm.s.Apic.pfnGetInterruptRC   += offDelta;
+        pVM->pdm.s.Apic.pfnSetBaseRC        += offDelta;
+        pVM->pdm.s.Apic.pfnGetBaseRC        += offDelta;
+        pVM->pdm.s.Apic.pfnSetTPRRC         += offDelta;
+        pVM->pdm.s.Apic.pfnGetTPRRC         += offDelta;
+        pVM->pdm.s.Apic.pfnBusDeliverRC     += offDelta;
     }
 
@@ -289 +289 @@
      * The registered I/O APIC.
      */
-    if (pVM->pdm.s.IoApic.pDevInsGC)
-    {
-        pVM->pdm.s.IoApic.pDevInsGC         += offDelta;
-        pVM->pdm.s.IoApic.pfnSetIrqGC       += offDelta;
+    if (pVM->pdm.s.IoApic.pDevInsRC)
+    {
+        pVM->pdm.s.IoApic.pDevInsRC         += offDelta;
+        pVM->pdm.s.IoApic.pfnSetIrqRC       += offDelta;
     }
 

trunk/src/VBox/VMM/PDMDevice.cpp

@@ -235 +235 @@
 static DECLCALLBACK(int) pdmR3ApicHlp_Lock(PPDMDEVINS pDevIns, int rc);
 static DECLCALLBACK(void) pdmR3ApicHlp_Unlock(PPDMDEVINS pDevIns);
-static DECLCALLBACK(PCPDMAPICHLPGC) pdmR3ApicHlp_GetGCHelpers(PPDMDEVINS pDevIns);
+static DECLCALLBACK(PCPDMAPICHLPRC) pdmR3ApicHlp_GetRCHelpers(PPDMDEVINS pDevIns);
 static DECLCALLBACK(PCPDMAPICHLPR0) pdmR3ApicHlp_GetR0Helpers(PPDMDEVINS pDevIns);
 /** @} */
@@ -247 +247 @@
 static DECLCALLBACK(int) pdmR3IoApicHlp_Lock(PPDMDEVINS pDevIns, int rc);
 static DECLCALLBACK(void) pdmR3IoApicHlp_Unlock(PPDMDEVINS pDevIns);
-static DECLCALLBACK(PCPDMIOAPICHLPGC) pdmR3IoApicHlp_GetGCHelpers(PPDMDEVINS pDevIns);
+static DECLCALLBACK(PCPDMIOAPICHLPRC) pdmR3IoApicHlp_GetRCHelpers(PPDMDEVINS pDevIns);
 static DECLCALLBACK(PCPDMIOAPICHLPR0) pdmR3IoApicHlp_GetR0Helpers(PPDMDEVINS pDevIns);
 /** @} */
@@ -505 +505 @@
     pdmR3ApicHlp_Lock,
     pdmR3ApicHlp_Unlock,
-    pdmR3ApicHlp_GetGCHelpers,
+    pdmR3ApicHlp_GetRCHelpers,
     pdmR3ApicHlp_GetR0Helpers,
     PDM_APICHLPR3_VERSION /* the end */
@@ -520 +520 @@
     pdmR3IoApicHlp_Lock,
     pdmR3IoApicHlp_Unlock,
-    pdmR3IoApicHlp_GetGCHelpers,
+    pdmR3IoApicHlp_GetRCHelpers,
     pdmR3IoApicHlp_GetR0Helpers,
     PDM_IOAPICHLPR3_VERSION /* the end */
@@ -2626 +2626 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
-    LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: pApicReg=%p:{.u32Version=%#x, .pfnGetInterruptHC=%p, .pfnSetBaseHC=%p, .pfnGetBaseHC=%p, "
-             ".pfnSetTPRHC=%p, .pfnGetTPRHC=%p, .pfnBusDeliverHC=%p, pszGetInterruptGC=%p:{%s}, pszSetBaseGC=%p:{%s}, pszGetBaseGC=%p:{%s}, "
-             ".pszSetTPRGC=%p:{%s}, .pszGetTPRGC=%p:{%s}, .pszBusDeliverGC=%p:{%s}} ppApicHlpR3=%p\n",
-             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pApicReg, pApicReg->u32Version, pApicReg->pfnGetInterruptHC, pApicReg->pfnSetBaseHC,
-             pApicReg->pfnGetBaseHC, pApicReg->pfnSetTPRHC, pApicReg->pfnGetTPRHC, pApicReg->pfnBusDeliverHC, pApicReg->pszGetInterruptGC,
-             pApicReg->pszGetInterruptGC, pApicReg->pszSetBaseGC, pApicReg->pszSetBaseGC, pApicReg->pszGetBaseGC, pApicReg->pszGetBaseGC,
-             pApicReg->pszSetTPRGC, pApicReg->pszSetTPRGC, pApicReg->pszGetTPRGC, pApicReg->pszGetTPRGC, pApicReg->pszBusDeliverGC,
-             pApicReg->pszBusDeliverGC, ppApicHlpR3));
+    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}, "
+             ".pszSetTPRRC=%p:{%s}, .pszGetTPRRC=%p:{%s}, .pszBusDeliverRC=%p:{%s}} ppApicHlpR3=%p\n",
+             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pApicReg, pApicReg->u32Version, pApicReg->pfnGetInterruptR3, pApicReg->pfnSetBaseR3,
+             pApicReg->pfnGetBaseR3, pApicReg->pfnSetTPRR3, pApicReg->pfnGetTPRR3, pApicReg->pfnBusDeliverR3, pApicReg->pszGetInterruptRC,
+             pApicReg->pszGetInterruptRC, pApicReg->pszSetBaseRC, pApicReg->pszSetBaseRC, pApicReg->pszGetBaseRC, pApicReg->pszGetBaseRC,
+             pApicReg->pszSetTPRRC, pApicReg->pszSetTPRRC, pApicReg->pszGetTPRRC, pApicReg->pszGetTPRRC, pApicReg->pszBusDeliverRC,
+             pApicReg->pszBusDeliverRC, ppApicHlpR3));
 
     /*
@@ -2644 +2644 @@
         return VERR_INVALID_PARAMETER;
     }
-    if (    !pApicReg->pfnGetInterruptHC
-        ||  !pApicReg->pfnHasPendingIrqHC
-        ||  !pApicReg->pfnSetBaseHC
-        ||  !pApicReg->pfnGetBaseHC
-        ||  !pApicReg->pfnSetTPRHC
-        ||  !pApicReg->pfnGetTPRHC
-        ||  !pApicReg->pfnBusDeliverHC)
-    {
-        Assert(pApicReg->pfnGetInterruptHC);
-        Assert(pApicReg->pfnHasPendingIrqHC);
-        Assert(pApicReg->pfnSetBaseHC);
-        Assert(pApicReg->pfnGetBaseHC);
-        Assert(pApicReg->pfnSetTPRHC);
-        Assert(pApicReg->pfnGetTPRHC);
-        Assert(pApicReg->pfnBusDeliverHC);
-        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Vrc (HC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+    if (    !pApicReg->pfnGetInterruptR3
+        ||  !pApicReg->pfnHasPendingIrqR3
+        ||  !pApicReg->pfnSetBaseR3
+        ||  !pApicReg->pfnGetBaseR3
+        ||  !pApicReg->pfnSetTPRR3
+        ||  !pApicReg->pfnGetTPRR3
+        ||  !pApicReg->pfnBusDeliverR3)
+    {
+        Assert(pApicReg->pfnGetInterruptR3);
+        Assert(pApicReg->pfnHasPendingIrqR3);
+        Assert(pApicReg->pfnSetBaseR3);
+        Assert(pApicReg->pfnGetBaseR3);
+        Assert(pApicReg->pfnSetTPRR3);
+        Assert(pApicReg->pfnGetTPRR3);
+        Assert(pApicReg->pfnBusDeliverR3);
+        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Vrc (R3 callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
         return VERR_INVALID_PARAMETER;
     }
-    if (   (    pApicReg->pszGetInterruptGC
-            ||  pApicReg->pszHasPendingIrqGC
-            ||  pApicReg->pszSetBaseGC
-            ||  pApicReg->pszGetBaseGC
-            ||  pApicReg->pszSetTPRGC
-            ||  pApicReg->pszGetTPRGC
-            ||  pApicReg->pszBusDeliverGC)
-        &&  (   !VALID_PTR(pApicReg->pszGetInterruptGC)
-            ||  !VALID_PTR(pApicReg->pszHasPendingIrqGC)
-            ||  !VALID_PTR(pApicReg->pszSetBaseGC)
-            ||  !VALID_PTR(pApicReg->pszGetBaseGC)
-            ||  !VALID_PTR(pApicReg->pszSetTPRGC)
-            ||  !VALID_PTR(pApicReg->pszGetTPRGC)
-            ||  !VALID_PTR(pApicReg->pszBusDeliverGC))
+    if (   (    pApicReg->pszGetInterruptRC
+            ||  pApicReg->pszHasPendingIrqRC
+            ||  pApicReg->pszSetBaseRC
+            ||  pApicReg->pszGetBaseRC
+            ||  pApicReg->pszSetTPRRC
+            ||  pApicReg->pszGetTPRRC
+            ||  pApicReg->pszBusDeliverRC)
+        &&  (   !VALID_PTR(pApicReg->pszGetInterruptRC)
+            ||  !VALID_PTR(pApicReg->pszHasPendingIrqRC)
+            ||  !VALID_PTR(pApicReg->pszSetBaseRC)
+            ||  !VALID_PTR(pApicReg->pszGetBaseRC)
+            ||  !VALID_PTR(pApicReg->pszSetTPRRC)
+            ||  !VALID_PTR(pApicReg->pszGetTPRRC)
+            ||  !VALID_PTR(pApicReg->pszBusDeliverRC))
        )
     {
-        Assert(VALID_PTR(pApicReg->pszGetInterruptGC));
-        Assert(VALID_PTR(pApicReg->pszHasPendingIrqGC));
-        Assert(VALID_PTR(pApicReg->pszSetBaseGC));
-        Assert(VALID_PTR(pApicReg->pszGetBaseGC));
-        Assert(VALID_PTR(pApicReg->pszSetTPRGC));
-        Assert(VALID_PTR(pApicReg->pszGetTPRGC));
-        Assert(VALID_PTR(pApicReg->pszBusDeliverGC));
-        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Vrc (GC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+        Assert(VALID_PTR(pApicReg->pszGetInterruptRC));
+        Assert(VALID_PTR(pApicReg->pszHasPendingIrqRC));
+        Assert(VALID_PTR(pApicReg->pszSetBaseRC));
+        Assert(VALID_PTR(pApicReg->pszGetBaseRC));
+        Assert(VALID_PTR(pApicReg->pszSetTPRRC));
+        Assert(VALID_PTR(pApicReg->pszGetTPRRC));
+        Assert(VALID_PTR(pApicReg->pszBusDeliverRC));
+        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Vrc (RC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
         return VERR_INVALID_PARAMETER;
     }
@@ -2733 +2733 @@
 
     /*
-     * Resolve & initialize the GC bits.
-     */
-    if (pApicReg->pszGetInterruptGC)
-    {
-        int rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszGetInterruptGC, &pVM->pdm.s.Apic.pfnGetInterruptGC);
-        AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszGetInterruptGC, rc));
+     * Resolve & initialize the RC bits.
+     */
+    if (pApicReg->pszGetInterruptRC)
+    {
+        int rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszGetInterruptRC, &pVM->pdm.s.Apic.pfnGetInterruptRC);
+        AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszGetInterruptRC, rc));
         if (RT_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszHasPendingIrqGC, &pVM->pdm.s.Apic.pfnHasPendingIrqGC);
-            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszHasPendingIrqGC, rc));
+            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszHasPendingIrqRC, &pVM->pdm.s.Apic.pfnHasPendingIrqRC);
+            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszHasPendingIrqRC, rc));
         }
         if (RT_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszSetBaseGC, &pVM->pdm.s.Apic.pfnSetBaseGC);
-            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszSetBaseGC, rc));
+            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszSetBaseRC, &pVM->pdm.s.Apic.pfnSetBaseRC);
+            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszSetBaseRC, rc));
         }
         if (RT_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszGetBaseGC, &pVM->pdm.s.Apic.pfnGetBaseGC);
-            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszGetBaseGC, rc));
+            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszGetBaseRC, &pVM->pdm.s.Apic.pfnGetBaseRC);
+            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszGetBaseRC, rc));
         }
         if (RT_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszSetTPRGC, &pVM->pdm.s.Apic.pfnSetTPRGC);
-            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszSetTPRGC, rc));
+            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszSetTPRRC, &pVM->pdm.s.Apic.pfnSetTPRRC);
+            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszSetTPRRC, rc));
         }
         if (RT_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszGetTPRGC, &pVM->pdm.s.Apic.pfnGetTPRGC);
-            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszGetTPRGC, rc));
+            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszGetTPRRC, &pVM->pdm.s.Apic.pfnGetTPRRC);
+            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszGetTPRRC, rc));
         }
         if (RT_SUCCESS(rc))
         {
-            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszBusDeliverGC, &pVM->pdm.s.Apic.pfnBusDeliverGC);
-            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszBusDeliverGC, rc));
+            rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pApicReg->pszBusDeliverRC, &pVM->pdm.s.Apic.pfnBusDeliverRC);
+            AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pApicReg->pszBusDeliverRC, rc));
         }
         if (VBOX_FAILURE(rc))
@@ -2774 +2774 @@
             return rc;
         }
-        pVM->pdm.s.Apic.pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
+        pVM->pdm.s.Apic.pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
     }
     else
     {
-        pVM->pdm.s.Apic.pDevInsGC           = 0;
-        pVM->pdm.s.Apic.pfnGetInterruptGC   = 0;
-        pVM->pdm.s.Apic.pfnHasPendingIrqGC  = 0;
-        pVM->pdm.s.Apic.pfnSetBaseGC        = 0;
-        pVM->pdm.s.Apic.pfnGetBaseGC        = 0;
-        pVM->pdm.s.Apic.pfnSetTPRGC         = 0;
-        pVM->pdm.s.Apic.pfnGetTPRGC         = 0;
-        pVM->pdm.s.Apic.pfnBusDeliverGC     = 0;
+        pVM->pdm.s.Apic.pDevInsRC           = 0;
+        pVM->pdm.s.Apic.pfnGetInterruptRC   = 0;
+        pVM->pdm.s.Apic.pfnHasPendingIrqRC  = 0;
+        pVM->pdm.s.Apic.pfnSetBaseRC        = 0;
+        pVM->pdm.s.Apic.pfnGetBaseRC        = 0;
+        pVM->pdm.s.Apic.pfnSetTPRRC         = 0;
+        pVM->pdm.s.Apic.pfnGetTPRRC         = 0;
+        pVM->pdm.s.Apic.pfnBusDeliverRC     = 0;
     }
 
@@ -2849 +2849 @@
      */
     pVM->pdm.s.Apic.pDevInsR3           = pDevIns;
-    pVM->pdm.s.Apic.pfnGetInterruptR3   = pApicReg->pfnGetInterruptHC;
-    pVM->pdm.s.Apic.pfnHasPendingIrqR3  = pApicReg->pfnHasPendingIrqHC;
-    pVM->pdm.s.Apic.pfnSetBaseR3        = pApicReg->pfnSetBaseHC;
-    pVM->pdm.s.Apic.pfnGetBaseR3        = pApicReg->pfnGetBaseHC;
-    pVM->pdm.s.Apic.pfnSetTPRR3         = pApicReg->pfnSetTPRHC;
-    pVM->pdm.s.Apic.pfnGetTPRR3         = pApicReg->pfnGetTPRHC;
-    pVM->pdm.s.Apic.pfnBusDeliverR3     = pApicReg->pfnBusDeliverHC;
+    pVM->pdm.s.Apic.pfnGetInterruptR3   = pApicReg->pfnGetInterruptR3;
+    pVM->pdm.s.Apic.pfnHasPendingIrqR3  = pApicReg->pfnHasPendingIrqR3;
+    pVM->pdm.s.Apic.pfnSetBaseR3        = pApicReg->pfnSetBaseR3;
+    pVM->pdm.s.Apic.pfnGetBaseR3        = pApicReg->pfnGetBaseR3;
+    pVM->pdm.s.Apic.pfnSetTPRR3         = pApicReg->pfnSetTPRR3;
+    pVM->pdm.s.Apic.pfnGetTPRR3         = pApicReg->pfnGetTPRR3;
+    pVM->pdm.s.Apic.pfnBusDeliverR3     = pApicReg->pfnBusDeliverR3;
     Log(("PDM: Registered APIC device '%s'/%d pDevIns=%p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns));
 
@@ -2870 +2870 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
-    LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrqHC=%p, .pszSetIrqGC=%p:{%s}} ppIoApicHlpR3=%p\n",
-             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrqHC, pIoApicReg->pszSetIrqGC,
-             pIoApicReg->pszSetIrqGC, ppIoApicHlpR3));
+    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,
+             pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqR0, pIoApicReg->pszSetIrqR0, ppIoApicHlpR3));
 
     /*
@@ -2883 +2883 @@
         return VERR_INVALID_PARAMETER;
     }
-    if (!pIoApicReg->pfnSetIrqHC)
-    {
-        Assert(pIoApicReg->pfnSetIrqHC);
-        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Vrc (HC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
+    if (!pIoApicReg->pfnSetIrqR3)
+    {
+        Assert(pIoApicReg->pfnSetIrqR3);
+        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Vrc (R3 callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
         return VERR_INVALID_PARAMETER;
     }
-    if (    pIoApicReg->pszSetIrqGC
-        &&  !VALID_PTR(pIoApicReg->pszSetIrqGC))
-    {
-        Assert(VALID_PTR(pIoApicReg->pszSetIrqGC));
+    if (    pIoApicReg->pszSetIrqRC
+        &&  !VALID_PTR(pIoApicReg->pszSetIrqRC))
+    {
+        Assert(VALID_PTR(pIoApicReg->pszSetIrqRC));
         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Vrc (GC callbacks)\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
         return VERR_INVALID_PARAMETER;
@@ -2921 +2921 @@
         return VERR_INVALID_PARAMETER;
     }
-    if (    pIoApicReg->pszSetIrqGC
-        &&  !pVM->pdm.s.Apic.pDevInsGC)
+    if (    pIoApicReg->pszSetIrqRC
+        &&  !pVM->pdm.s.Apic.pDevInsRC)
     {
         AssertMsgFailed(("Configuration error! APIC doesn't do GC, I/O APIC does!\n"));
@@ -2942 +2942 @@
      * Resolve & initialize the GC bits.
      */
-    if (pIoApicReg->pszSetIrqGC)
-    {
-        int rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pIoApicReg->pszSetIrqGC, &pVM->pdm.s.IoApic.pfnSetIrqGC);
-        AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pIoApicReg->pszSetIrqGC, rc));
+    if (pIoApicReg->pszSetIrqRC)
+    {
+        int rc = PDMR3GetSymbolGCLazy(pVM, pDevIns->pDevReg->szGCMod, pIoApicReg->pszSetIrqRC, &pVM->pdm.s.IoApic.pfnSetIrqRC);
+        AssertMsgRC(rc, ("%s::%s rc=%Vrc\n", pDevIns->pDevReg->szGCMod, pIoApicReg->pszSetIrqRC, rc));
         if (VBOX_FAILURE(rc))
         {
@@ -2951 +2951 @@
             return rc;
         }
-        pVM->pdm.s.IoApic.pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
+        pVM->pdm.s.IoApic.pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
     }
     else
     {
-        pVM->pdm.s.IoApic.pDevInsGC   = 0;
-        pVM->pdm.s.IoApic.pfnSetIrqGC = 0;
+        pVM->pdm.s.IoApic.pDevInsRC   = 0;
+        pVM->pdm.s.IoApic.pfnSetIrqRC = 0;
     }
 
@@ -2981 +2981 @@
 
     /*
-     * Initialize the HC bits.
+     * Initialize the R3 bits.
      */
     pVM->pdm.s.IoApic.pDevInsR3   = pDevIns;
-    pVM->pdm.s.IoApic.pfnSetIrqR3 = pIoApicReg->pfnSetIrqHC;
+    pVM->pdm.s.IoApic.pfnSetIrqR3 = pIoApicReg->pfnSetIrqR3;
     Log(("PDM: Registered I/O APIC device '%s'/%d pDevIns=%p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pDevIns));
 
@@ -4120 +4120 @@
 
 
-/** @copydoc PDMAPICHLPR3::pfnGetGCHelpers */
-static DECLCALLBACK(PCPDMAPICHLPGC) pdmR3ApicHlp_GetGCHelpers(PPDMDEVINS pDevIns)
+/** @copydoc PDMAPICHLPR3::pfnGetRCHelpers */
+static DECLCALLBACK(PCPDMAPICHLPRC) pdmR3ApicHlp_GetRCHelpers(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
     VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
-    RTGCPTR32 pGCHelpers = 0;
-    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMHC, NULL, "g_pdmGCApicHlp", &pGCHelpers);
+    RTRCPTR pRCHelpers = 0;
+    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMHC, NULL, "g_pdmRCApicHlp", &pRCHelpers);
     AssertReleaseRC(rc);
-    AssertRelease(pGCHelpers);
-    LogFlow(("pdmR3ApicHlp_GetGCHelpers: caller='%s'/%d: returns %VGv\n",
-             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pGCHelpers));
-    return pGCHelpers;
+    AssertRelease(pRCHelpers);
+    LogFlow(("pdmR3ApicHlp_GetRCHelpers: caller='%s'/%d: returns %VGv\n",
+             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
+    return pRCHelpers;
 }
 
@@ -4179 +4179 @@
 
 
-/** @copydoc PDMIOAPICHLPR3::pfnGetGCHelpers */
-static DECLCALLBACK(PCPDMIOAPICHLPGC) pdmR3IoApicHlp_GetGCHelpers(PPDMDEVINS pDevIns)
+/** @copydoc PDMIOAPICHLPR3::pfnGetRCHelpers */
+static DECLCALLBACK(PCPDMIOAPICHLPRC) pdmR3IoApicHlp_GetRCHelpers(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
     VM_ASSERT_EMT(pDevIns->Internal.s.pVMHC);
-    RTGCPTR32 pGCHelpers = 0;
-    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMHC, NULL, "g_pdmGCIoApicHlp", &pGCHelpers);
+    RTRCPTR pRCHelpers = 0;
+    int rc = PDMR3GetSymbolGC(pDevIns->Internal.s.pVMHC, NULL, "g_pdmRCIoApicHlp", &pRCHelpers);
     AssertReleaseRC(rc);
-    AssertRelease(pGCHelpers);
-    LogFlow(("pdmR3IoApicHlp_GetGCHelpers: caller='%s'/%d: returns %VGv\n",
-             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pGCHelpers));
-    return pGCHelpers;
+    AssertRelease(pRCHelpers);
+    LogFlow(("pdmR3IoApicHlp_GetRCHelpers: caller='%s'/%d: returns %VGv\n",
+             pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
+    return pRCHelpers;
 }
 

trunk/src/VBox/VMM/PDMInternal.h

@@ -384 +384 @@
 typedef struct PDMAPIC
 {
-    /** Pointer to the APIC device instance - HC Ptr. */
+    /** Pointer to the APIC device instance - R3 Ptr. */
     PPDMDEVINSR3                    pDevInsR3;
-    /** @copydoc PDMAPICREG::pfnGetInterruptHC */
+    /** @copydoc PDMAPICREG::pfnGetInterruptR3 */
     DECLR3CALLBACKMEMBER(int,       pfnGetInterruptR3,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnHasPendingIrqHC */
+    /** @copydoc PDMAPICREG::pfnHasPendingIrqR3 */
     DECLR3CALLBACKMEMBER(bool,      pfnHasPendingIrqR3,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnSetBaseHC */
+    /** @copydoc PDMAPICREG::pfnSetBaseR3 */
     DECLR3CALLBACKMEMBER(void,      pfnSetBaseR3,(PPDMDEVINS pDevIns, uint64_t u64Base));
-    /** @copydoc PDMAPICREG::pfnGetBaseHC */
+    /** @copydoc PDMAPICREG::pfnGetBaseR3 */
     DECLR3CALLBACKMEMBER(uint64_t,  pfnGetBaseR3,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnSetTPRHC */
+    /** @copydoc PDMAPICREG::pfnSetTPRR3 */
     DECLR3CALLBACKMEMBER(void,      pfnSetTPRR3,(PPDMDEVINS pDevIns, uint8_t u8TPR));
-    /** @copydoc PDMAPICREG::pfnGetTPRHC */
+    /** @copydoc PDMAPICREG::pfnGetTPRR3 */
     DECLR3CALLBACKMEMBER(uint8_t,   pfnGetTPRR3,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnBusDeliverHC */
+    /** @copydoc PDMAPICREG::pfnBusDeliverR3 */
     DECLR3CALLBACKMEMBER(void,      pfnBusDeliverR3,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
                                                      uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode));
@@ -404 +404 @@
     /** Pointer to the APIC device instance - R0. */
     R0PTRTYPE(PPDMDEVINS)           pDevInsR0;
-    /** @copydoc PDMAPICREG::pfnGetInterruptHC */
+    /** @copydoc PDMAPICREG::pfnGetInterruptR3 */
     DECLR0CALLBACKMEMBER(int,       pfnGetInterruptR0,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnHasPendingIrqHC */
+    /** @copydoc PDMAPICREG::pfnHasPendingIrqR3 */
     DECLR0CALLBACKMEMBER(bool,      pfnHasPendingIrqR0,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnSetBaseHC */
+    /** @copydoc PDMAPICREG::pfnSetBaseR3 */
     DECLR0CALLBACKMEMBER(void,      pfnSetBaseR0,(PPDMDEVINS pDevIns, uint64_t u64Base));
-    /** @copydoc PDMAPICREG::pfnGetBaseHC */
+    /** @copydoc PDMAPICREG::pfnGetBaseR3 */
     DECLR0CALLBACKMEMBER(uint64_t,  pfnGetBaseR0,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnSetTPRHC */
+    /** @copydoc PDMAPICREG::pfnSetTPRR3 */
     DECLR0CALLBACKMEMBER(void,      pfnSetTPRR0,(PPDMDEVINS pDevIns, uint8_t u8TPR));
-    /** @copydoc PDMAPICREG::pfnGetTPRHC */
+    /** @copydoc PDMAPICREG::pfnGetTPRR3 */
     DECLR0CALLBACKMEMBER(uint8_t,   pfnGetTPRR0,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnBusDeliverHC */
+    /** @copydoc PDMAPICREG::pfnBusDeliverR3 */
     DECLR0CALLBACKMEMBER(void,      pfnBusDeliverR0,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
                                                      uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode));
 
-    /** Pointer to the APIC device instance - GC Ptr. */
-    PPDMDEVINSGC                    pDevInsGC;
-    /** @copydoc PDMAPICREG::pfnGetInterruptHC */
-    DECLGCCALLBACKMEMBER(int,       pfnGetInterruptGC,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnHasPendingIrqHC */
-    DECLGCCALLBACKMEMBER(bool,      pfnHasPendingIrqGC,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnSetBaseHC */
-    DECLGCCALLBACKMEMBER(void,      pfnSetBaseGC,(PPDMDEVINS pDevIns, uint64_t u64Base));
-    /** @copydoc PDMAPICREG::pfnGetBaseHC */
-    DECLGCCALLBACKMEMBER(uint64_t,  pfnGetBaseGC,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnSetTPRHC */
-    DECLGCCALLBACKMEMBER(void,      pfnSetTPRGC,(PPDMDEVINS pDevIns, uint8_t u8TPR));
-    /** @copydoc PDMAPICREG::pfnGetTPRHC */
-    DECLGCCALLBACKMEMBER(uint8_t,   pfnGetTPRGC,(PPDMDEVINS pDevIns));
-    /** @copydoc PDMAPICREG::pfnBusDeliverHC */
-    DECLGCCALLBACKMEMBER(void,      pfnBusDeliverGC,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
+    /** Pointer to the APIC device instance - RC Ptr. */
+    PPDMDEVINSRC                    pDevInsRC;
+    /** @copydoc PDMAPICREG::pfnGetInterruptR3 */
+    DECLRCCALLBACKMEMBER(int,       pfnGetInterruptRC,(PPDMDEVINS pDevIns));
+    /** @copydoc PDMAPICREG::pfnHasPendingIrqR3 */
+    DECLRCCALLBACKMEMBER(bool,      pfnHasPendingIrqRC,(PPDMDEVINS pDevIns));
+    /** @copydoc PDMAPICREG::pfnSetBaseR3 */
+    DECLRCCALLBACKMEMBER(void,      pfnSetBaseRC,(PPDMDEVINS pDevIns, uint64_t u64Base));
+    /** @copydoc PDMAPICREG::pfnGetBaseR3 */
+    DECLRCCALLBACKMEMBER(uint64_t,  pfnGetBaseRC,(PPDMDEVINS pDevIns));
+    /** @copydoc PDMAPICREG::pfnSetTPRR3 */
+    DECLRCCALLBACKMEMBER(void,      pfnSetTPRRC,(PPDMDEVINS pDevIns, uint8_t u8TPR));
+    /** @copydoc PDMAPICREG::pfnGetTPRR3 */
+    DECLRCCALLBACKMEMBER(uint8_t,   pfnGetTPRRC,(PPDMDEVINS pDevIns));
+    /** @copydoc PDMAPICREG::pfnBusDeliverR3 */
+    DECLRCCALLBACKMEMBER(void,      pfnBusDeliverRC,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
                                                      uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode));
 } PDMAPIC;
@@ -445 +445 @@
 typedef struct PDMIOAPIC
 {
-    /** Pointer to the APIC device instance - HC Ptr. */
+    /** Pointer to the APIC device instance - R3 Ptr. */
     PPDMDEVINSR3                    pDevInsR3;
-    /** @copydoc PDMIOAPICREG::pfnSetIrqHC */
+    /** @copydoc PDMIOAPICREG::pfnSetIrqR3 */
     DECLR3CALLBACKMEMBER(void,      pfnSetIrqR3,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
 
     /** Pointer to the PIC device instance - R0. */
     R0PTRTYPE(PPDMDEVINS)   pDevInsR0;
-    /** @copydoc PDMIOAPICREG::pfnSetIrqHC */
+    /** @copydoc PDMIOAPICREG::pfnSetIrqR3 */
     DECLR0CALLBACKMEMBER(void,      pfnSetIrqR0,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
 
     /** Pointer to the APIC device instance - GC Ptr. */
-    PPDMDEVINSGC                    pDevInsGC;
-    /** @copydoc PDMIOAPICREG::pfnSetIrqHC */
-    DECLGCCALLBACKMEMBER(void,      pfnSetIrqGC,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
+    PPDMDEVINSGC                    pDevInsRC;
+    /** @copydoc PDMIOAPICREG::pfnSetIrqR3 */
+    DECLGCCALLBACKMEMBER(void,      pfnSetIrqRC,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
 } PDMIOAPIC;
 

trunk/src/VBox/VMM/VMMAll/PDMAll.cpp

@@ -53 +53 @@
     {
         VM_FF_CLEAR(pVM, VM_FF_INTERRUPT_APIC);
-        Assert(pVM->pdm.s.Apic.CTXALLSUFF(pDevIns));
-        Assert(pVM->pdm.s.Apic.CTXALLSUFF(pfnGetInterrupt));
-        int i = pVM->pdm.s.Apic.CTXALLSUFF(pfnGetInterrupt)(pVM->pdm.s.Apic.CTXALLSUFF(pDevIns));
+        Assert(pVM->pdm.s.Apic.CTX_SUFF(pDevIns));
+        Assert(pVM->pdm.s.Apic.CTX_SUFF(pfnGetInterrupt));
+        int i = pVM->pdm.s.Apic.CTX_SUFF(pfnGetInterrupt)(pVM->pdm.s.Apic.CTX_SUFF(pDevIns));
         AssertMsg(i <= 255 && i >= 0, ("i=%d\n", i));
         if (i >= 0)
@@ -110 +110 @@
     }
 
-    if (pVM->pdm.s.IoApic.CTXALLSUFF(pDevIns))
-    {
-        Assert(pVM->pdm.s.IoApic.CTXALLSUFF(pfnSetIrq));
-        pVM->pdm.s.IoApic.CTXALLSUFF(pfnSetIrq)(pVM->pdm.s.IoApic.CTXALLSUFF(pDevIns), u8Irq, u8Level);
+    if (pVM->pdm.s.IoApic.CTX_SUFF(pDevIns))
+    {
+        Assert(pVM->pdm.s.IoApic.CTX_SUFF(pfnSetIrq));
+        pVM->pdm.s.IoApic.CTX_SUFF(pfnSetIrq)(pVM->pdm.s.IoApic.CTX_SUFF(pDevIns), u8Irq, u8Level);
         rc = VINF_SUCCESS;
     }
@@ -132 +132 @@
 PDMDECL(int) PDMIoApicSetIrq(PVM pVM, uint8_t u8Irq, uint8_t u8Level)
 {
-    if (pVM->pdm.s.IoApic.CTXALLSUFF(pDevIns))
-    {
-        Assert(pVM->pdm.s.IoApic.CTXALLSUFF(pfnSetIrq));
-        pdmLock(pVM);
-        pVM->pdm.s.IoApic.CTXALLSUFF(pfnSetIrq)(pVM->pdm.s.IoApic.CTXALLSUFF(pDevIns), u8Irq, u8Level);
+    if (pVM->pdm.s.IoApic.CTX_SUFF(pDevIns))
+    {
+        Assert(pVM->pdm.s.IoApic.CTX_SUFF(pfnSetIrq));
+        pdmLock(pVM);
+        pVM->pdm.s.IoApic.CTX_SUFF(pfnSetIrq)(pVM->pdm.s.IoApic.CTX_SUFF(pDevIns), u8Irq, u8Level);
         pdmUnlock(pVM);
         return VINF_SUCCESS;
@@ -153 +153 @@
 PDMDECL(int) PDMApicSetBase(PVM pVM, uint64_t u64Base)
 {
-    if (pVM->pdm.s.Apic.CTXALLSUFF(pDevIns))
-    {
-        Assert(pVM->pdm.s.Apic.CTXALLSUFF(pfnSetBase));
-        pdmLock(pVM);
-        pVM->pdm.s.Apic.CTXALLSUFF(pfnSetBase)(pVM->pdm.s.Apic.CTXALLSUFF(pDevIns), u64Base);
+    if (pVM->pdm.s.Apic.CTX_SUFF(pDevIns))
+    {
+        Assert(pVM->pdm.s.Apic.CTX_SUFF(pfnSetBase));
+        pdmLock(pVM);
+        pVM->pdm.s.Apic.CTX_SUFF(pfnSetBase)(pVM->pdm.s.Apic.CTX_SUFF(pDevIns), u64Base);
         pdmUnlock(pVM);
         return VINF_SUCCESS;
@@ -174 +174 @@
 PDMDECL(int) PDMApicGetBase(PVM pVM, uint64_t *pu64Base)
 {
-    if (pVM->pdm.s.Apic.CTXALLSUFF(pDevIns))
-    {
-        Assert(pVM->pdm.s.Apic.CTXALLSUFF(pfnGetBase));
-        pdmLock(pVM);
-        *pu64Base = pVM->pdm.s.Apic.CTXALLSUFF(pfnGetBase)(pVM->pdm.s.Apic.CTXALLSUFF(pDevIns));
+    if (pVM->pdm.s.Apic.CTX_SUFF(pDevIns))
+    {
+        Assert(pVM->pdm.s.Apic.CTX_SUFF(pfnGetBase));
+        pdmLock(pVM);
+        *pu64Base = pVM->pdm.s.Apic.CTX_SUFF(pfnGetBase)(pVM->pdm.s.Apic.CTX_SUFF(pDevIns));
         pdmUnlock(pVM);
         return VINF_SUCCESS;
@@ -196 +196 @@
 PDMDECL(int) PDMApicHasPendingIrq(PVM pVM, bool *pfPending)
 {
-    if (pVM->pdm.s.Apic.CTXALLSUFF(pDevIns))
-    {
-        Assert(pVM->pdm.s.Apic.CTXALLSUFF(pfnSetTPR));
-        pdmLock(pVM);
-        *pfPending = pVM->pdm.s.Apic.CTXALLSUFF(pfnHasPendingIrq)(pVM->pdm.s.Apic.CTXALLSUFF(pDevIns));
+    if (pVM->pdm.s.Apic.CTX_SUFF(pDevIns))
+    {
+        Assert(pVM->pdm.s.Apic.CTX_SUFF(pfnSetTPR));
+        pdmLock(pVM);
+        *pfPending = pVM->pdm.s.Apic.CTX_SUFF(pfnHasPendingIrq)(pVM->pdm.s.Apic.CTX_SUFF(pDevIns));
         pdmUnlock(pVM);
         return VINF_SUCCESS;
@@ -217 +217 @@
 PDMDECL(int) PDMApicSetTPR(PVM pVM, uint8_t u8TPR)
 {
-    if (pVM->pdm.s.Apic.CTXALLSUFF(pDevIns))
-    {
-        Assert(pVM->pdm.s.Apic.CTXALLSUFF(pfnSetTPR));
-        pdmLock(pVM);
-        pVM->pdm.s.Apic.CTXALLSUFF(pfnSetTPR)(pVM->pdm.s.Apic.CTXALLSUFF(pDevIns), u8TPR);
+    if (pVM->pdm.s.Apic.CTX_SUFF(pDevIns))
+    {
+        Assert(pVM->pdm.s.Apic.CTX_SUFF(pfnSetTPR));
+        pdmLock(pVM);
+        pVM->pdm.s.Apic.CTX_SUFF(pfnSetTPR)(pVM->pdm.s.Apic.CTX_SUFF(pDevIns), u8TPR);
         pdmUnlock(pVM);
         return VINF_SUCCESS;
@@ -239 +239 @@
 PDMDECL(int) PDMApicGetTPR(PVM pVM, uint8_t *pu8TPR, bool *pfPending)
 {
-    if (pVM->pdm.s.Apic.CTXALLSUFF(pDevIns))
-    {
-        Assert(pVM->pdm.s.Apic.CTXALLSUFF(pfnGetTPR));
-        pdmLock(pVM);
-        *pu8TPR = pVM->pdm.s.Apic.CTXALLSUFF(pfnGetTPR)(pVM->pdm.s.Apic.CTXALLSUFF(pDevIns));
+    if (pVM->pdm.s.Apic.CTX_SUFF(pDevIns))
+    {
+        Assert(pVM->pdm.s.Apic.CTX_SUFF(pfnGetTPR));
+        pdmLock(pVM);
+        *pu8TPR = pVM->pdm.s.Apic.CTX_SUFF(pfnGetTPR)(pVM->pdm.s.Apic.CTX_SUFF(pDevIns));
         if (pfPending)
-            *pfPending = pVM->pdm.s.Apic.CTXALLSUFF(pfnHasPendingIrq)(pVM->pdm.s.Apic.CTXALLSUFF(pDevIns));
+            *pfPending = pVM->pdm.s.Apic.CTX_SUFF(pfnHasPendingIrq)(pVM->pdm.s.Apic.CTX_SUFF(pDevIns));
         pdmUnlock(pVM);
         return VINF_SUCCESS;

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

@@ -61 +61 @@
 extern DECLEXPORT(const PDMDEVHLPGC)    g_pdmGCDevHlp;
 extern DECLEXPORT(const PDMPICHLPGC)    g_pdmGCPicHlp;
-extern DECLEXPORT(const PDMAPICHLPGC)   g_pdmGCApicHlp;
-extern DECLEXPORT(const PDMIOAPICHLPGC) g_pdmGCIoApicHlp;
+extern DECLEXPORT(const PDMAPICHLPRC)   g_pdmRCApicHlp;
+extern DECLEXPORT(const PDMIOAPICHLPRC) g_pdmRCIoApicHlp;
 extern DECLEXPORT(const PDMPCIHLPRC)    g_pdmRCPciHlp;
 __END_DECLS
@@ -96 +96 @@
 
 
-/** @name APIC GC Helpers
+/** @name APIC RC Helpers
  * @{
  */
-static DECLCALLBACK(void) pdmGCApicHlp_SetInterruptFF(PPDMDEVINS pDevIns);
-static DECLCALLBACK(void) pdmGCApicHlp_ClearInterruptFF(PPDMDEVINS pDevIns);
-static DECLCALLBACK(void) pdmGCApicHlp_ChangeFeature(PPDMDEVINS pDevIns, bool fEnabled);
-static DECLCALLBACK(int) pdmGCApicHlp_Lock(PPDMDEVINS pDevIns, int rc);
-static DECLCALLBACK(void) pdmGCApicHlp_Unlock(PPDMDEVINS pDevIns);
+static DECLCALLBACK(void) pdmRCApicHlp_SetInterruptFF(PPDMDEVINS pDevIns);
+static DECLCALLBACK(void) pdmRCApicHlp_ClearInterruptFF(PPDMDEVINS pDevIns);
+static DECLCALLBACK(void) pdmRCApicHlp_ChangeFeature(PPDMDEVINS pDevIns, bool fEnabled);
+static DECLCALLBACK(int) pdmRCApicHlp_Lock(PPDMDEVINS pDevIns, int rc);
+static DECLCALLBACK(void) pdmRCApicHlp_Unlock(PPDMDEVINS pDevIns);
 /** @} */
 
 
-/** @name I/O APIC GC Helpers
+/** @name I/O APIC RC Helpers
  * @{
  */
-static DECLCALLBACK(void) pdmGCIoApicHlp_ApicBusDeliver(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
+static DECLCALLBACK(void) pdmRCIoApicHlp_ApicBusDeliver(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
                                                         uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode);
-static DECLCALLBACK(int) pdmGCIoApicHlp_Lock(PPDMDEVINS pDevIns, int rc);
-static DECLCALLBACK(void) pdmGCIoApicHlp_Unlock(PPDMDEVINS pDevIns);
+static DECLCALLBACK(int) pdmRCIoApicHlp_Lock(PPDMDEVINS pDevIns, int rc);
+static DECLCALLBACK(void) pdmRCIoApicHlp_Unlock(PPDMDEVINS pDevIns);
 /** @} */
 
@@ -166 +166 @@
 
 /**
- * The Guest Context APIC Helper Callbacks.
- */
-extern DECLEXPORT(const PDMAPICHLPGC) g_pdmGCApicHlp =
-{
-    PDM_APICHLPGC_VERSION,
-    pdmGCApicHlp_SetInterruptFF,
-    pdmGCApicHlp_ClearInterruptFF,
-    pdmGCApicHlp_ChangeFeature,
-    pdmGCApicHlp_Lock,
-    pdmGCApicHlp_Unlock,
-    PDM_APICHLPGC_VERSION
+ * The Raw-Mode Context APIC Helper Callbacks.
+ */
+extern DECLEXPORT(const PDMAPICHLPRC) g_pdmRCApicHlp =
+{
+    PDM_APICHLPRC_VERSION,
+    pdmRCApicHlp_SetInterruptFF,
+    pdmRCApicHlp_ClearInterruptFF,
+    pdmRCApicHlp_ChangeFeature,
+    pdmRCApicHlp_Lock,
+    pdmRCApicHlp_Unlock,
+    PDM_APICHLPRC_VERSION
 };
 
 
 /**
- * The Guest Context I/O APIC Helper Callbacks.
- */
-extern DECLEXPORT(const PDMIOAPICHLPGC) g_pdmGCIoApicHlp =
-{
-    PDM_IOAPICHLPGC_VERSION,
-    pdmGCIoApicHlp_ApicBusDeliver,
-    pdmGCIoApicHlp_Lock,
-    pdmGCIoApicHlp_Unlock,
-    PDM_IOAPICHLPGC_VERSION
+ * The Raw-Mode Context I/O APIC Helper Callbacks.
+ */
+extern DECLEXPORT(const PDMIOAPICHLPRC) g_pdmRCIoApicHlp =
+{
+    PDM_IOAPICHLPRC_VERSION,
+    pdmRCIoApicHlp_ApicBusDeliver,
+    pdmRCIoApicHlp_Lock,
+    pdmRCIoApicHlp_Unlock,
+    PDM_IOAPICHLPRC_VERSION
 };
 
@@ -391 +391 @@
 
 /** @copydoc PDMAPICHLPGC::pfnSetInterruptFF */
-static DECLCALLBACK(void) pdmGCApicHlp_SetInterruptFF(PPDMDEVINS pDevIns)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmGCApicHlp_SetInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 1\n",
+static DECLCALLBACK(void) pdmRCApicHlp_SetInterruptFF(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmRCApicHlp_SetInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 1\n",
              pDevIns, pDevIns->iInstance, VM_FF_ISSET(pDevIns->Internal.s.pVMGC, VM_FF_INTERRUPT_APIC)));
     VM_FF_SET(pDevIns->Internal.s.pVMGC, VM_FF_INTERRUPT_APIC);
@@ -401 +401 @@
 
 /** @copydoc PDMAPICHLPGC::pfnClearInterruptFF */
-static DECLCALLBACK(void) pdmGCApicHlp_ClearInterruptFF(PPDMDEVINS pDevIns)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmGCApicHlp_ClearInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 0\n",
+static DECLCALLBACK(void) pdmRCApicHlp_ClearInterruptFF(PPDMDEVINS pDevIns)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmRCApicHlp_ClearInterruptFF: caller=%p/%d: VM_FF_INTERRUPT %d -> 0\n",
              pDevIns, pDevIns->iInstance, VM_FF_ISSET(pDevIns->Internal.s.pVMGC, VM_FF_INTERRUPT_APIC)));
     VM_FF_CLEAR(pDevIns->Internal.s.pVMGC, VM_FF_INTERRUPT_APIC);
@@ -411 +411 @@
 
 /** @copydoc PDMAPICHLPGC::pfnChangeFeature */
-static DECLCALLBACK(void) pdmGCApicHlp_ChangeFeature(PPDMDEVINS pDevIns, bool fEnabled)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    LogFlow(("pdmGCApicHlp_ChangeFeature: caller=%p/%d: fEnabled=%RTbool\n", pDevIns, pDevIns->iInstance, fEnabled));
+static DECLCALLBACK(void) pdmRCApicHlp_ChangeFeature(PPDMDEVINS pDevIns, bool fEnabled)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmRCApicHlp_ChangeFeature: caller=%p/%d: fEnabled=%RTbool\n", pDevIns, pDevIns->iInstance, fEnabled));
     if (fEnabled)
         CPUMSetGuestCpuIdFeature(pDevIns->Internal.s.pVMGC, CPUMCPUIDFEATURE_APIC);
@@ -423 +423 @@
 
 /** @copydoc PDMAPICHLPGC::pfnLock */
-static DECLCALLBACK(int) pdmGCApicHlp_Lock(PPDMDEVINS pDevIns, int rc)
+static DECLCALLBACK(int) pdmRCApicHlp_Lock(PPDMDEVINS pDevIns, int rc)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
@@ -431 +431 @@
 
 /** @copydoc PDMAPICHLPGC::pfnUnlock */
-static DECLCALLBACK(void) pdmGCApicHlp_Unlock(PPDMDEVINS pDevIns)
+static DECLCALLBACK(void) pdmRCApicHlp_Unlock(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
@@ -441 +441 @@
 
 /** @copydoc PDMIOAPICHLPGC::pfnApicBusDeliver */
-static DECLCALLBACK(void) pdmGCIoApicHlp_ApicBusDeliver(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
+static DECLCALLBACK(void) pdmRCIoApicHlp_ApicBusDeliver(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
                                                         uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
     PVM pVM = pDevIns->Internal.s.pVMGC;
-    LogFlow(("pdmGCIoApicHlp_ApicBusDeliver: caller=%p/%d: u8Dest=%RX8 u8DestMode=%RX8 u8DeliveryMode=%RX8 iVector=%RX8 u8Polarity=%RX8 u8TriggerMode=%RX8\n",
+    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));
-    if (pVM->pdm.s.Apic.pfnBusDeliverGC)
-        pVM->pdm.s.Apic.pfnBusDeliverGC(pVM->pdm.s.Apic.pDevInsGC, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode);
+    if (pVM->pdm.s.Apic.pfnBusDeliverRC)
+        pVM->pdm.s.Apic.pfnBusDeliverRC(pVM->pdm.s.Apic.pDevInsRC, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode);
 }
 
 
 /** @copydoc PDMIOAPICHLPGC::pfnLock */
-static DECLCALLBACK(int) pdmGCIoApicHlp_Lock(PPDMDEVINS pDevIns, int rc)
+static DECLCALLBACK(int) pdmRCIoApicHlp_Lock(PPDMDEVINS pDevIns, int rc)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
@@ -462 +462 @@
 
 /** @copydoc PDMIOAPICHLPGC::pfnUnlock */
-static DECLCALLBACK(void) pdmGCIoApicHlp_Unlock(PPDMDEVINS pDevIns)
+static DECLCALLBACK(void) pdmRCIoApicHlp_Unlock(PPDMDEVINS pDevIns)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
@@ -516 +516 @@
 static void pdmGCIsaSetIrq(PVM pVM, int iIrq, int iLevel)
 {
-    if (    (   pVM->pdm.s.IoApic.pDevInsGC
+    if (    (   pVM->pdm.s.IoApic.pDevInsRC
              || !pVM->pdm.s.IoApic.pDevInsR3)
         &&  (   pVM->pdm.s.Pic.pDevInsGC
@@ -524 +524 @@
         if (pVM->pdm.s.Pic.pDevInsGC)
             pVM->pdm.s.Pic.pfnSetIrqGC(pVM->pdm.s.Pic.pDevInsGC, iIrq, iLevel);
-        if (pVM->pdm.s.IoApic.pDevInsGC)
-            pVM->pdm.s.IoApic.pfnSetIrqGC(pVM->pdm.s.IoApic.pDevInsGC, iIrq, iLevel);
+        if (pVM->pdm.s.IoApic.pDevInsRC)
+            pVM->pdm.s.IoApic.pfnSetIrqRC(pVM->pdm.s.IoApic.pDevInsRC, iIrq, iLevel);
         pdmUnlock(pVM);
     }
@@ -556 +556 @@
 static void pdmGCIoApicSetIrq(PVM pVM, int iIrq, int iLevel)
 {
-    if (pVM->pdm.s.IoApic.pDevInsGC)
+    if (pVM->pdm.s.IoApic.pDevInsRC)
     {
         pdmLock(pVM);
-        pVM->pdm.s.IoApic.pfnSetIrqGC(pVM->pdm.s.IoApic.pDevInsGC, iIrq, iLevel);
+        pVM->pdm.s.IoApic.pfnSetIrqRC(pVM->pdm.s.IoApic.pDevInsRC, iIrq, iLevel);
         pdmUnlock(pVM);
     }

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

@@ -275 +275 @@
     GEN_CHECK_OFF(PDM, Apic.pfnGetTPRR0);
     GEN_CHECK_OFF(PDM, Apic.pfnBusDeliverR0);
-    GEN_CHECK_OFF(PDM, Apic.pDevInsGC);
-    GEN_CHECK_OFF(PDM, Apic.pfnGetInterruptGC);
-    GEN_CHECK_OFF(PDM, Apic.pfnSetBaseGC);
-    GEN_CHECK_OFF(PDM, Apic.pfnGetBaseGC);
-    GEN_CHECK_OFF(PDM, Apic.pfnSetTPRGC);
-    GEN_CHECK_OFF(PDM, Apic.pfnGetTPRGC);
-    GEN_CHECK_OFF(PDM, Apic.pfnBusDeliverGC);
+    GEN_CHECK_OFF(PDM, Apic.pDevInsRC);
+    GEN_CHECK_OFF(PDM, Apic.pfnGetInterruptRC);
+    GEN_CHECK_OFF(PDM, Apic.pfnSetBaseRC);
+    GEN_CHECK_OFF(PDM, Apic.pfnGetBaseRC);
+    GEN_CHECK_OFF(PDM, Apic.pfnSetTPRRC);
+    GEN_CHECK_OFF(PDM, Apic.pfnGetTPRRC);
+    GEN_CHECK_OFF(PDM, Apic.pfnBusDeliverRC);
     GEN_CHECK_OFF(PDM, IoApic);
     GEN_CHECK_OFF(PDM, IoApic.pDevInsR3);
@@ -287 +287 @@
     GEN_CHECK_OFF(PDM, IoApic.pDevInsR0);
     GEN_CHECK_OFF(PDM, IoApic.pfnSetIrqR0);
-    GEN_CHECK_OFF(PDM, IoApic.pDevInsGC);
-    GEN_CHECK_OFF(PDM, IoApic.pfnSetIrqGC);
+    GEN_CHECK_OFF(PDM, IoApic.pDevInsRC);
+    GEN_CHECK_OFF(PDM, IoApic.pfnSetIrqRC);
     GEN_CHECK_OFF(PDM, pDmac);
     GEN_CHECK_OFF(PDM, pRtc);