Index: /trunk/include/VBox/pgm.h
===================================================================
--- /trunk/include/VBox/pgm.h	(revision 7730)
+++ /trunk/include/VBox/pgm.h	(revision 7731)
@@ -467,4 +467,10 @@
 #endif /* !VBOX_WITH_NEW_PHYS_CODE */
 PGMR3DECL(int)  PGMR3PhysRegisterRam(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, const char *pszDesc);
+PDMR3DECL(int)  PGMR3PhysMMIORegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb,
+                                      R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
+                                      R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
+                                      GCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
+                                      R3PTRTYPE(const char *) pszDesc);
+PDMR3DECL(int)  PGMR3PhysMMIODeregister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb);
 PDMR3DECL(int)  PGMR3PhysMMIO2Register(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion, RTGCPHYS cb, void **ppv, const char *pszDesc);
 PDMR3DECL(int)  PGMR3PhysMMIO2Deregister(PVM pVM, PPDMDEVINS pDevIns, uint32_t iRegion);
Index: /trunk/src/VBox/VMM/IOM.cpp
===================================================================
--- /trunk/src/VBox/VMM/IOM.cpp	(revision 7730)
+++ /trunk/src/VBox/VMM/IOM.cpp	(revision 7731)
@@ -53,4 +53,5 @@
 #include <VBox/stam.h>
 #include <VBox/dbgf.h>
+#include <VBox/pdm.h>
 #include "IOMInternal.h"
 #include <VBox/vm.h>
@@ -110,4 +111,6 @@
     {
         pVM->iom.s.pTreesGC = MMHyperHC2GC(pVM, pVM->iom.s.pTreesHC);
+        pVM->iom.s.pfnMMIOHandlerGC = NIL_RTGCPTR;
+        pVM->iom.s.pfnMMIOHandlerR0 = NIL_RTR0PTR;
 
         /*
@@ -1412,4 +1415,5 @@
     LogFlow(("IOMR3MMIORegisterR3: pDevIns=%p GCPhysStart=%VGp cbRange=%#x pvUser=%VHv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x pszDesc=%s\n",
              pDevIns, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback, pszDesc));
+    int rc;
 
     /*
@@ -1423,8 +1427,19 @@
 
     /*
+     * Resolve the GC/R0 handler addresses lazily because of init order.
+     */
+    if (pVM->iom.s.pfnMMIOHandlerR0 == NIL_RTR0PTR)
+    {
+        rc = PDMR3GetSymbolGCLazy(pVM, NULL, "IOMMMIOHandler", &pVM->iom.s.pfnMMIOHandlerGC);
+        AssertLogRelRCReturn(rc, rc);
+        rc = PDMR3GetSymbolR0Lazy(pVM, NULL, "IOMMMIOHandler", &pVM->iom.s.pfnMMIOHandlerR0);
+        AssertLogRelRCReturn(rc, rc);
+    }
+
+    /*
      * Allocate new range record and initialize it.
      */
     PIOMMMIORANGER3 pRange;
-    int rc = MMHyperAlloc(pVM, sizeof(*pRange), 0, MM_TAG_IOM, (void **)&pRange);
+    rc = MMHyperAlloc(pVM, sizeof(*pRange), 0, MM_TAG_IOM, (void **)&pRange);
     if (VBOX_SUCCESS(rc))
     {
@@ -1432,5 +1447,5 @@
         pRange->Core.KeyLast    = GCPhysStart + (cbRange - 1);
         pRange->GCPhys          = GCPhysStart;
-        pRange->cbSize          = cbRange;
+        pRange->cb              = cbRange;
         pRange->pvUser          = pvUser;
         pRange->pDevIns         = pDevIns;
@@ -1443,10 +1458,8 @@
          * Try register it with PGM and then insert it into the tree.
          */
-        //rc = PGMR3PhysMMIORegister(pVM, GCPhysStart, cbRange);
-        //if (RT_SUCCESS(rc))
-            rc = PGMR3HandlerPhysicalRegister(pVM, PGMPHYSHANDLERTYPE_MMIO, GCPhysStart, GCPhysStart + (cbRange - 1),
-                                              /*IOMR3MMIOHandler*/ NULL, pRange,
-                                              NULL, "IOMMMIOHandler", MMHyperR3ToR0(pVM, pRange),
-                                              NULL, "IOMMMIOHandler", MMHyperR3ToGC(pVM, pRange), pszDesc);
+        rc = PGMR3PhysMMIORegister(pVM, GCPhysStart, cbRange,
+                                   /*IOMR3MMIOHandler*/ NULL, pRange,
+                                   pVM->iom.s.pfnMMIOHandlerR0, MMHyperR3ToR0(pVM, pRange),
+                                   pVM->iom.s.pfnMMIOHandlerGC, MMHyperR3ToGC(pVM, pRange), pszDesc);
         if (RT_SUCCESS(rc))
         {
@@ -1489,113 +1502,4 @@
 {
     LogFlow(("IOMR3MMIORegisterGC: pDevIns=%p GCPhysStart=%VGp cbRange=%#x pvUser=%VGv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x pszDesc=%s\n",
-             pDevIns, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback, pszDesc));
-
-    /*
-     * Validate input.
-     */
-    if (!pfnWriteCallback && !pfnReadCallback)
-    {
-        AssertMsgFailed(("No callbacks! %VGp LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
-        return VERR_INVALID_PARAMETER;
-    }
-    RTGCPHYS GCPhysLast = GCPhysStart + (cbRange - 1);
-    if (GCPhysLast < GCPhysStart)
-    {
-        AssertMsgFailed(("Wrapped! %VGp LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
-        return VERR_IOM_INVALID_MMIO_RANGE;
-    }
-
-    /*
-     * Check that a ring-3 MMIO range exists.
-     */
-    RTGCPHYS GCPhys = GCPhysStart;
-    while (GCPhys <= GCPhysLast && GCPhys >= GCPhysStart)
-    {
-        PIOMMMIORANGER3 pRange = (PIOMMMIORANGER3)RTAvlroGCPhysRangeGet(&pVM->iom.s.CTXSUFF(pTrees)->MMIOTreeR3, GCPhys);
-        if (!pRange)
-        {
-            AssertMsgFailed(("No R3 range! GCPhys=%VGp %VGp LB%#x %s\n", GCPhys, GCPhysStart, cbRange, pszDesc));
-            return VERR_IOM_NO_HC_MMIO_RANGE;
-        }
-#ifndef IOM_NO_PDMINS_CHECKS
-        #ifndef IN_GC
-        if (pRange->pDevIns != pDevIns)
-        #else
-        if (pRange->pDevIns != MMHyperGC2HC(pVM, pDevIns))
-        #endif
-        {
-            AssertMsgFailed(("Not owner! GCPhys=%VGp %VGp LB%#x %s / %#x-%#x %s\n", GCPhys, GCPhysStart, cbRange, pszDesc,
-                             pRange->Core.Key, pRange->Core.KeyLast, MMHyper2HC(pVM, (uintptr_t)pRange->pszDesc)));
-            return VERR_IOM_NOT_MMIO_RANGE_OWNER;
-        }
-#endif /* !IOM_NO_PDMINS_CHECKS */
-        /* next */
-        Assert(GCPhys <= pRange->Core.KeyLast);
-        GCPhys = pRange->Core.KeyLast + 1;
-    }
-
-
-    /*
-     * Allocate new range record and initialize it.
-     */
-    PIOMMMIORANGEGC pRange;
-    int rc = MMHyperAlloc(pVM, sizeof(*pRange), 0, MM_TAG_IOM, (void **)&pRange);
-    if (VBOX_SUCCESS(rc))
-    {
-        pRange->Core.Key        = GCPhysStart;
-        pRange->Core.KeyLast    = GCPhysStart + (cbRange - 1);
-        pRange->GCPhys          = GCPhysStart;
-        pRange->cbSize          = cbRange;
-        pRange->pvUser          = pvUser;
-        pRange->pfnReadCallback = pfnReadCallback;
-        pRange->pfnWriteCallback= pfnWriteCallback;
-        pRange->pfnFillCallback = pfnFillCallback;
-#ifdef IN_GC
-        pRange->pDevIns         = pDevIns;
-        pRange->pszDesc         = MMHyperGC2HC(pVM, (void *)pszDesc);
-#else
-        pRange->pDevIns         = MMHyperHC2GC(pVM, pDevIns);
-        pRange->pszDesc         = pszDesc;
-#endif
-
-        /*
-         * Try insert it.
-         */
-        if (RTAvlroGCPhysInsert(&pVM->iom.s.CTXSUFF(pTrees)->MMIOTreeGC, &pRange->Core))
-            return VINF_SUCCESS;
-
-        AssertMsgFailed(("Conflict! %VGp LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
-        MMHyperFree(pVM, pRange);
-        rc = VERR_IOM_MMIO_RANGE_CONFLICT;
-    }
-
-    return rc;
-}
-
-
-/**
- * Registers a Memory Mapped I/O R0 handler range.
- *
- * This API is called by PDM on behalf of a device. Devices must first register ring-3 ranges
- * using IOMMR3MIORegisterHC() before calling this function.
- *
- *
- * @returns VBox status code.
- *
- * @param   pVM                 VM handle.
- * @param   pDevIns             PDM device instance owning the MMIO range.
- * @param   GCPhysStart         First physical address in the range.
- * @param   cbRange             The size of the range (in bytes).
- * @param   pvUser              User argument for the callbacks.
- * @param   pfnWriteCallback    Pointer to function which is gonna handle Write operations.
- * @param   pfnReadCallback     Pointer to function which is gonna handle Read operations.
- * @param   pfnFillCallback     Pointer to function which is gonna handle Fill/memset operations.
- * @param   pszDesc             Pointer to description string. This must not be freed.
- */
-IOMR3DECL(int)  IOMR3MMIORegisterR0(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
-                                    R0PTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, R0PTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
-                                    R0PTRTYPE(PFNIOMMMIOFILL) pfnFillCallback, const char *pszDesc)
-{
-    LogFlow(("IOMR3MMIORegisterR0: pDevIns=%p GCPhysStart=%VGp cbRange=%#x pvUser=%VHv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x pszDesc=%s\n",
              pDevIns, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback, pszDesc));
 
@@ -1648,4 +1552,113 @@
      * Allocate new range record and initialize it.
      */
+    PIOMMMIORANGEGC pRange;
+    int rc = MMHyperAlloc(pVM, sizeof(*pRange), 0, MM_TAG_IOM, (void **)&pRange);
+    if (VBOX_SUCCESS(rc))
+    {
+        pRange->Core.Key        = GCPhysStart;
+        pRange->Core.KeyLast    = GCPhysStart + (cbRange - 1);
+        pRange->GCPhys          = GCPhysStart;
+        pRange->cb              = cbRange;
+        pRange->pvUser          = pvUser;
+        pRange->pfnReadCallback = pfnReadCallback;
+        pRange->pfnWriteCallback= pfnWriteCallback;
+        pRange->pfnFillCallback = pfnFillCallback;
+#ifdef IN_GC
+        pRange->pDevIns         = pDevIns;
+        pRange->pszDesc         = MMHyperGC2HC(pVM, (void *)pszDesc);
+#else
+        pRange->pDevIns         = MMHyperHC2GC(pVM, pDevIns);
+        pRange->pszDesc         = pszDesc;
+#endif
+
+        /*
+         * Try insert it.
+         */
+        if (RTAvlroGCPhysInsert(&pVM->iom.s.CTXSUFF(pTrees)->MMIOTreeGC, &pRange->Core))
+            return VINF_SUCCESS;
+
+        AssertMsgFailed(("Conflict! %VGp LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
+        MMHyperFree(pVM, pRange);
+        rc = VERR_IOM_MMIO_RANGE_CONFLICT;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Registers a Memory Mapped I/O R0 handler range.
+ *
+ * This API is called by PDM on behalf of a device. Devices must first register ring-3 ranges
+ * using IOMMR3MIORegisterHC() before calling this function.
+ *
+ *
+ * @returns VBox status code.
+ *
+ * @param   pVM                 VM handle.
+ * @param   pDevIns             PDM device instance owning the MMIO range.
+ * @param   GCPhysStart         First physical address in the range.
+ * @param   cbRange             The size of the range (in bytes).
+ * @param   pvUser              User argument for the callbacks.
+ * @param   pfnWriteCallback    Pointer to function which is gonna handle Write operations.
+ * @param   pfnReadCallback     Pointer to function which is gonna handle Read operations.
+ * @param   pfnFillCallback     Pointer to function which is gonna handle Fill/memset operations.
+ * @param   pszDesc             Pointer to description string. This must not be freed.
+ */
+IOMR3DECL(int)  IOMR3MMIORegisterR0(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhysStart, RTUINT cbRange, RTR0PTR pvUser,
+                                    R0PTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallback, R0PTRTYPE(PFNIOMMMIOREAD) pfnReadCallback,
+                                    R0PTRTYPE(PFNIOMMMIOFILL) pfnFillCallback, const char *pszDesc)
+{
+    LogFlow(("IOMR3MMIORegisterR0: pDevIns=%p GCPhysStart=%VGp cbRange=%#x pvUser=%VHv pfnWriteCallback=%#x pfnReadCallback=%#x pfnFillCallback=%#x pszDesc=%s\n",
+             pDevIns, GCPhysStart, cbRange, pvUser, pfnWriteCallback, pfnReadCallback, pfnFillCallback, pszDesc));
+
+    /*
+     * Validate input.
+     */
+    if (!pfnWriteCallback && !pfnReadCallback)
+    {
+        AssertMsgFailed(("No callbacks! %VGp LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
+        return VERR_INVALID_PARAMETER;
+    }
+    RTGCPHYS GCPhysLast = GCPhysStart + (cbRange - 1);
+    if (GCPhysLast < GCPhysStart)
+    {
+        AssertMsgFailed(("Wrapped! %VGp LB%#x %s\n", GCPhysStart, cbRange, pszDesc));
+        return VERR_IOM_INVALID_MMIO_RANGE;
+    }
+
+    /*
+     * Check that a ring-3 MMIO range exists.
+     */
+    RTGCPHYS GCPhys = GCPhysStart;
+    while (GCPhys <= GCPhysLast && GCPhys >= GCPhysStart)
+    {
+        PIOMMMIORANGER3 pRange = (PIOMMMIORANGER3)RTAvlroGCPhysRangeGet(&pVM->iom.s.CTXSUFF(pTrees)->MMIOTreeR3, GCPhys);
+        if (!pRange)
+        {
+            AssertMsgFailed(("No R3 range! GCPhys=%VGp %VGp LB%#x %s\n", GCPhys, GCPhysStart, cbRange, pszDesc));
+            return VERR_IOM_NO_HC_MMIO_RANGE;
+        }
+#ifndef IOM_NO_PDMINS_CHECKS
+# ifndef IN_GC
+        if (pRange->pDevIns != pDevIns)
+# else
+        if (pRange->pDevIns != MMHyperGC2HC(pVM, pDevIns))
+# endif
+        {
+            AssertMsgFailed(("Not owner! GCPhys=%VGp %VGp LB%#x %s / %#x-%#x %s\n", GCPhys, GCPhysStart, cbRange, pszDesc,
+                             pRange->Core.Key, pRange->Core.KeyLast, MMHyper2HC(pVM, (uintptr_t)pRange->pszDesc)));
+            return VERR_IOM_NOT_MMIO_RANGE_OWNER;
+        }
+#endif /* !IOM_NO_PDMINS_CHECKS */
+        /* next */
+        Assert(GCPhys <= pRange->Core.KeyLast);
+        GCPhys = pRange->Core.KeyLast + 1;
+    }
+
+
+    /*
+     * Allocate new range record and initialize it.
+     */
     PIOMMMIORANGER0 pRange;
     int rc = MMHyperAlloc(pVM, sizeof(*pRange), 0, MM_TAG_IOM, (void **)&pRange);
@@ -1655,5 +1668,5 @@
         pRange->Core.KeyLast    = GCPhysStart + (cbRange - 1);
         pRange->GCPhys          = GCPhysStart;
-        pRange->cbSize          = cbRange;
+        pRange->cb              = cbRange;
         pRange->pvUser          = pvUser;
         pRange->pfnReadCallback = pfnReadCallback;
@@ -1790,5 +1803,5 @@
 
         /* remove it from PGM */
-        int rc = PGMHandlerPhysicalDeregister(pVM, GCPhys);
+        int rc = PGMR3PhysMMIODeregister(pVM, GCPhys, pRange->cb);
         AssertRC(rc);
 
Index: /trunk/src/VBox/VMM/IOMInternal.h
===================================================================
--- /trunk/src/VBox/VMM/IOMInternal.h	(revision 7730)
+++ /trunk/src/VBox/VMM/IOMInternal.h	(revision 7731)
@@ -23,4 +23,5 @@
 #include <VBox/iom.h>
 #include <VBox/stam.h>
+#include <VBox/pgm.h>
 #include <iprt/avl.h>
 
@@ -49,5 +50,5 @@
     RTGCPHYS                    GCPhys;
     /** Size of the range. */
-    RTUINT                      cbSize;
+    RTUINT                      cb;
     /** Pointer to user argument. */
     RTR3PTR                     pvUser;
@@ -79,5 +80,5 @@
 #endif
     /** Size of the range. */
-    RTUINT                      cbSize;
+    RTUINT                      cb;
     /** Pointer to user argument. */
     RTR0PTR                     pvUser;
@@ -106,5 +107,5 @@
     RTGCPHYS                    GCPhys;
     /** Size of the range. */
-    RTUINT                      cbSize;
+    RTUINT                      cb;
 #if HC_ARCH_BITS == 64
     uint32_t                    u32Alignment;
@@ -122,5 +123,5 @@
 #if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32
     RTGCPTR                     GCPtrAlignment; /**< pszDesc is 8 byte aligned. */
-#endif 
+#endif
     /** Description / Name. For easing debugging. */
     R3PTRTYPE(const char *)     pszDesc;
@@ -266,5 +267,5 @@
 #if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32
     RTGCPTR                     GCPtrAlignment; /**< pszDesc is 8 byte aligned. */
-#endif 
+#endif
     /** Description / Name. For easing debugging. */
     R3PTRTYPE(const char *)     pszDesc;
@@ -375,4 +376,9 @@
     R3R0PTRTYPE(PIOMTREES)          pTreesHC;
 
+    /** The ring-0 address of IOMMMIOHandler. */
+    R0PTRTYPE(PFNPGMR0PHYSHANDLER)  pfnMMIOHandlerR0;
+    /** The GC address of IOMMMIOHandler. */
+    GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnMMIOHandlerGC;
+    RTGCPTR                         Alignment;
 
     /** @name Caching of I/O Port ranges and statistics.
Index: /trunk/src/VBox/VMM/PGMPhys.cpp
===================================================================
--- /trunk/src/VBox/VMM/PGMPhys.cpp	(revision 7730)
+++ /trunk/src/VBox/VMM/PGMPhys.cpp	(revision 7731)
@@ -278,7 +278,16 @@
  *
  */
-PDMR3DECL(int) PGMR3PhysMMIORegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb)
-{
-    return -1;
+PDMR3DECL(int) PGMR3PhysMMIORegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb,
+                                     R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, RTR3PTR pvUserR3,
+                                     R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, RTR0PTR pvUserR0,
+                                     GCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnHandlerGC, RTGCPTR pvUserGC,
+                                     R3PTRTYPE(const char *) pszDesc)
+{
+
+    int rc = PGMHandlerPhysicalRegisterEx(pVM, PGMPHYSHANDLERTYPE_MMIO, GCPhys, GCPhys + (cb - 1),
+                                          pfnHandlerR3, pvUserR3,
+                                          pfnHandlerR0, pvUserR0,
+                                          pfnHandlerGC, pvUserGC, pszDesc);
+    return rc;
 }
 
@@ -293,5 +302,7 @@
 PDMR3DECL(int) PGMR3PhysMMIODeregister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb)
 {
-    return -1;
+    int rc = PGMHandlerPhysicalDeregister(pVM, GCPhys);
+
+    return rc;
 }
 
Index: /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp	(revision 7730)
+++ /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp	(revision 7731)
@@ -159,8 +159,8 @@
  * @warning VBOX_SUCCESS(rc=VINF_IOM_HC_MMIO_WRITE) is TRUE!
  */
-DECLINLINE(int) iomMMIODoWrite(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cbSize)
+DECLINLINE(int) iomMMIODoWrite(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cb)
 {
 #ifdef VBOX_WITH_STATISTICS
-    if (pRange->cbSize <= PAGE_SIZE)
+    if (pRange->cb <= PAGE_SIZE)
     {
         PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhysFault);
@@ -168,5 +168,5 @@
             return VINF_IOM_HC_MMIO_WRITE;
 
-        int rc = pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, (void *)pvData, cbSize); /* @todo fix const!! */
+        int rc = pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, (void *)pvData, cb); /* @todo fix const!! */
         if (rc != VINF_IOM_HC_MMIO_WRITE)
             STAM_COUNTER_INC(&pStats->WriteGC);
@@ -174,5 +174,5 @@
     }
 #endif
-    return pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, (void *)pvData, cbSize);
+    return pRange->pfnWriteCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, (void *)pvData, cb);
 }
 
@@ -180,8 +180,8 @@
  * Wrapper which does the read and updates range statistics when such are enabled.
  */
-DECLINLINE(int) iomMMIODoRead(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, void *pvData, unsigned cbSize)
+DECLINLINE(int) iomMMIODoRead(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, void *pvData, unsigned cb)
 {
 #ifdef VBOX_WITH_STATISTICS
-    if (pRange->cbSize <= PAGE_SIZE)
+    if (pRange->cb <= PAGE_SIZE)
     {
         PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhysFault);
@@ -189,5 +189,5 @@
             return VINF_IOM_HC_MMIO_READ;
 
-        int rc = pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, pvData, cbSize);
+        int rc = pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, pvData, cb);
         if (rc != VINF_IOM_HC_MMIO_READ)
             STAM_COUNTER_INC(&pStats->ReadGC);
@@ -195,5 +195,5 @@
     }
 #endif
-    return pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, pvData, cbSize);
+    return pRange->pfnReadCallback(pRange->pDevIns, pRange->pvUser, GCPhysFault, pvData, cb);
 }
 
@@ -373,9 +373,9 @@
      * and call the handler function to get the data.
      */
-    unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param2);
-    AssertMsg(cbSize > 0 && cbSize <= sizeof(uint32_t), ("cbSize=%d\n", cbSize));
+    unsigned cb = DISGetParamSize(pCpu, &pCpu->param2);
+    AssertMsg(cb > 0 && cb <= sizeof(uint32_t), ("cb=%d\n", cb));
 
     uint32_t u32Data = 0;
-    int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &u32Data, cbSize);
+    int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &u32Data, cb);
     if (rc == VINF_SUCCESS)
     {
@@ -386,5 +386,5 @@
         if (pCpu->pCurInstr->opcode == OP_MOVSX)
         {
-            if (cbSize == 1)
+            if (cb == 1)
             {
                 /* DWORD <- BYTE */
@@ -408,5 +408,5 @@
 
     if (rc == VINF_SUCCESS)
-        iomMMIOStatLength(pVM, cbSize);
+        iomMMIOStatLength(pVM, cb);
     return rc;
 }
@@ -436,12 +436,12 @@
      * and call the callback to write it.
      */
-    unsigned cbSize = 0;
+    unsigned cb = 0;
     uint32_t u32Data  = 0;
-    bool fRc = iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cbSize);
+    bool fRc = iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cb);
     AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
 
-    int rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &u32Data, cbSize);
+    int rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &u32Data, cb);
     if (rc == VINF_SUCCESS)
-        iomMMIOStatLength(pVM, cbSize);
+        iomMMIOStatLength(pVM, cb);
     return rc;
 }
@@ -523,11 +523,11 @@
      * Get data size.
      */
-    unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param1);
-    Assert(cbSize);
-    int      offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
+    unsigned cb = DISGetParamSize(pCpu, &pCpu->param1);
+    Assert(cb);
+    int      offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cb : (signed)cb;
 
 #ifdef VBOX_WITH_STATISTICS
-    if (pVM->iom.s.cMovsMaxBytes < (cTransfers << SIZE_2_SHIFT(cbSize)))
-        pVM->iom.s.cMovsMaxBytes = cTransfers << SIZE_2_SHIFT(cbSize);
+    if (pVM->iom.s.cMovsMaxBytes < (cTransfers << SIZE_2_SHIFT(cb)))
+        pVM->iom.s.cMovsMaxBytes = cTransfers << SIZE_2_SHIFT(cb);
 #endif
 
@@ -558,5 +558,5 @@
 
             /* Access verification first; we currently can't recover properly from traps inside this instruction */
-            rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cbSize, (cpl == 3) ? X86_PTE_US : 0);
+            rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cb, (cpl == 3) ? X86_PTE_US : 0);
             if (rc != VINF_SUCCESS)
             {
@@ -574,8 +574,8 @@
             {
                 uint32_t u32Data = 0;
-                rc = iomRamRead(pVM, &u32Data, (RTGCPTR)pu8Virt, cbSize);
+                rc = iomRamRead(pVM, &u32Data, (RTGCPTR)pu8Virt, cb);
                 if (rc != VINF_SUCCESS)
                     break;
-                rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cbSize);
+                rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cb);
                 if (rc != VINF_SUCCESS)
                     break;
@@ -642,8 +642,8 @@
             {
                 uint32_t u32Data;
-                rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cbSize);
+                rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cb);
                 if (rc != VINF_SUCCESS)
                     break;
-                rc = iomMMIODoWrite(pVM, pMMIODst, PhysDst, &u32Data, cbSize);
+                rc = iomMMIODoWrite(pVM, pMMIODst, PhysDst, &u32Data, cb);
                 if (rc != VINF_SUCCESS)
                     break;
@@ -666,5 +666,5 @@
 
             /* Access verification first; we currently can't recover properly from traps inside this instruction */
-            rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cbSize, X86_PTE_RW | ((cpl == 3) ? X86_PTE_US : 0));
+            rc = PGMVerifyAccess(pVM, pu8Virt, cTransfers * cb, X86_PTE_RW | ((cpl == 3) ? X86_PTE_US : 0));
             if (rc != VINF_SUCCESS)
             {
@@ -681,11 +681,11 @@
             {
                 uint32_t u32Data;
-                rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cbSize);
+                rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cb);
                 if (rc != VINF_SUCCESS)
                     break;
-                rc = iomRamWrite(pVM, (RTGCPTR)pu8Virt, &u32Data, cbSize);
+                rc = iomRamWrite(pVM, (RTGCPTR)pu8Virt, &u32Data, cb);
                 if (rc != VINF_SUCCESS)
                 {
-                    Log(("iomRamWrite %08X size=%d failed with %d\n", pu8Virt, cbSize, rc));
+                    Log(("iomRamWrite %08X size=%d failed with %d\n", pu8Virt, cb, rc));
                     break;
                 }
@@ -712,5 +712,5 @@
     {
         STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovs, a);
-        iomMMIOStatLength(pVM, cbSize);
+        iomMMIOStatLength(pVM, cb);
     }
     return rc;
@@ -763,11 +763,11 @@
      * Get data size.
      */
-    unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param1);
-    Assert(cbSize);
-    int      offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
+    unsigned cb = DISGetParamSize(pCpu, &pCpu->param1);
+    Assert(cb);
+    int      offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cb : (signed)cb;
 
 #ifdef VBOX_WITH_STATISTICS
-    if (pVM->iom.s.cStosMaxBytes < (cTransfers << SIZE_2_SHIFT(cbSize)))
-        pVM->iom.s.cStosMaxBytes = cTransfers << SIZE_2_SHIFT(cbSize);
+    if (pVM->iom.s.cStosMaxBytes < (cTransfers << SIZE_2_SHIFT(cb)))
+        pVM->iom.s.cStosMaxBytes = cTransfers << SIZE_2_SHIFT(cb);
 #endif
 
@@ -785,9 +785,9 @@
         {
             /* addr++ variant. */
-            rc = pRange->pfnFillCallback(pRange->pDevIns, pRange->pvUser, Phys, u32Data, cbSize, cTransfers);
+            rc = pRange->pfnFillCallback(pRange->pDevIns, pRange->pvUser, Phys, u32Data, cb, cTransfers);
             if (rc == VINF_SUCCESS)
             {
                 /* Update registers. */
-                pRegFrame->edi += cTransfers << SIZE_2_SHIFT(cbSize);
+                pRegFrame->edi += cTransfers << SIZE_2_SHIFT(cb);
                 if (pCpu->prefix & PREFIX_REP)
                     pRegFrame->ecx = 0;
@@ -797,9 +797,9 @@
         {
             /* addr-- variant. */
-            rc = pRange->pfnFillCallback(pRange->pDevIns, pRange->pvUser, (Phys - (cTransfers - 1)) << SIZE_2_SHIFT(cbSize), u32Data, cbSize, cTransfers);
+            rc = pRange->pfnFillCallback(pRange->pDevIns, pRange->pvUser, (Phys - (cTransfers - 1)) << SIZE_2_SHIFT(cb), u32Data, cb, cTransfers);
             if (rc == VINF_SUCCESS)
             {
                 /* Update registers. */
-                pRegFrame->edi -= cTransfers << SIZE_2_SHIFT(cbSize);
+                pRegFrame->edi -= cTransfers << SIZE_2_SHIFT(cb);
                 if (pCpu->prefix & PREFIX_REP)
                     pRegFrame->ecx = 0;
@@ -819,5 +819,5 @@
         do
         {
-            rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cbSize);
+            rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cb);
             if (rc != VINF_SUCCESS)
                 break;
@@ -839,5 +839,5 @@
     {
         STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstStos, a);
-        iomMMIOStatLength(pVM, cbSize);
+        iomMMIOStatLength(pVM, cb);
     }
     return rc;
@@ -878,12 +878,12 @@
      * Get data size.
      */
-    unsigned cbSize = DISGetParamSize(pCpu, &pCpu->param2);
-    Assert(cbSize);
-    int     offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
+    unsigned cb = DISGetParamSize(pCpu, &pCpu->param2);
+    Assert(cb);
+    int     offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cb : (signed)cb;
 
     /*
      * Perform read.
      */
-    int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &pRegFrame->eax, cbSize);
+    int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &pRegFrame->eax, cb);
     if (rc == VINF_SUCCESS)
         pRegFrame->esi += offIncrement;
@@ -895,5 +895,5 @@
     {
         STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstLods, a1);
-        iomMMIOStatLength(pVM, cbSize);
+        iomMMIOStatLength(pVM, cb);
     }
     return rc;
@@ -927,14 +927,14 @@
      * Get the operands.
      */
-    unsigned cbSize = 0;
+    unsigned cb = 0;
     uint32_t uData1;
     uint32_t uData2;
     int rc;
-    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
+    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cb))
         /* cmp reg, [MMIO]. */
-        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
-    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
+        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
+    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cb))
         /* cmp [MMIO], reg|imm. */
-        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
+        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
     else
     {
@@ -946,10 +946,10 @@
     {
         /* Emulate CMP and update guest flags. */
-        uint32_t eflags = EMEmulateCmp(uData1, uData2, cbSize);
+        uint32_t eflags = EMEmulateCmp(uData1, uData2, cb);
         pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
                               | (eflags                &  (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
 
         STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstCmp, a1);
-        iomMMIOStatLength(pVM, cbSize);
+        iomMMIOStatLength(pVM, cb);
     }
 
@@ -979,24 +979,24 @@
     /* Check read callback. */
 
-    unsigned    cbSize = 0;
+    unsigned    cb = 0;
     uint32_t    uData1;
     uint32_t    uData2;
     bool        fAndWrite;
     int         rc;
-    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
+    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cb))
     {
         /* and reg, [MMIO]. */
         fAndWrite = false;
         if (pRange->pfnReadCallback)
-            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
+            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
         else
             rc = VINF_IOM_HC_MMIO_READ;
     }
-    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
+    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cb))
     {
         /* and [MMIO], reg|imm. */
         fAndWrite = true;
         if (pRange->pfnReadCallback && pRange->pfnWriteCallback)
-            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
+            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
         else
             rc = VINF_IOM_HC_MMIO_READ_WRITE;
@@ -1011,8 +1011,8 @@
     {
         /* Emulate AND and update guest flags. */
-        uint32_t eflags = EMEmulateAnd(&uData1, uData2, cbSize);
+        uint32_t eflags = EMEmulateAnd(&uData1, uData2, cb);
         if (fAndWrite)
             /* Store result to MMIO. */
-            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cbSize);
+            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cb);
         else
         {
@@ -1027,5 +1027,5 @@
                                   | (eflags                &  (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
             STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstAnd, a1);
-            iomMMIOStatLength(pVM, cbSize);
+            iomMMIOStatLength(pVM, cb);
         }
     }
@@ -1057,22 +1057,22 @@
     /* Check read callback. */
 
-    unsigned    cbSize = 0;
+    unsigned    cb = 0;
     uint32_t    uData1;
     uint32_t    uData2;
     int         rc;
 
-    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
+    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cb))
     {
         /* and test, [MMIO]. */
         if (pRange->pfnReadCallback)
-            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
+            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
         else
             rc = VINF_IOM_HC_MMIO_READ;
     }
-    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
+    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cb))
     {
         /* test [MMIO], reg|imm. */
         if (pRange->pfnReadCallback)
-            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
+            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
         else
             rc = VINF_IOM_HC_MMIO_READ;
@@ -1087,9 +1087,9 @@
     {
         /* Emulate TEST (=AND without write back) and update guest EFLAGS. */
-        uint32_t eflags = EMEmulateAnd(&uData1, uData2, cbSize);
+        uint32_t eflags = EMEmulateAnd(&uData1, uData2, cb);
         pRegFrame->eflags.u32 = (pRegFrame->eflags.u32 & ~(X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF))
                               | (eflags                &  (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
         STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstTest, a1);
-        iomMMIOStatLength(pVM, cbSize);
+        iomMMIOStatLength(pVM, cb);
     }
 
@@ -1117,5 +1117,5 @@
 
     /* Check read callback. */
-    unsigned    cbSize = 0;
+    unsigned    cb = 0;
     uint32_t    uData1;
     uint32_t    uData2;
@@ -1128,12 +1128,12 @@
     }
 
-    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
+    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cb))
     {
         /* xchg reg, [MMIO]. */
-        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
+        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cb);
         if (rc == VINF_SUCCESS)
         {
             /* Store result to MMIO. */
-            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cbSize);
+            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cb);
 
             if (rc == VINF_SUCCESS)
@@ -1150,12 +1150,12 @@
     }
     else
-    if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
+    if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cb))
     {
         /* xchg [MMIO], reg. */
-        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
+        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cb);
         if (rc == VINF_SUCCESS)
         {
             /* Store result to MMIO. */
-            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData2, cbSize);
+            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData2, cb);
 
             if (rc == VINF_SUCCESS)
@@ -1412,5 +1412,5 @@
 #ifdef VBOX_WITH_STATISTICS
     PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhys);
-    if (!pStats && (!pRange || pRange->cbSize <= PAGE_SIZE))
+    if (!pStats && (!pRange || pRange->cb <= PAGE_SIZE))
 # ifdef IN_RING3
         pStats = iomR3MMIOStatsCreate(pVM, GCPhys, pRange ? pRange->pszDesc : NULL);
@@ -1513,5 +1513,5 @@
 #ifdef VBOX_WITH_STATISTICS
     PIOMMMIOSTATS pStats = iomMMIOGetStats(&pVM->iom.s, GCPhys);
-    if (!pStats && (!pRange || pRange->cbSize <= PAGE_SIZE))
+    if (!pStats && (!pRange || pRange->cb <= PAGE_SIZE))
 # ifdef IN_RING3
         pStats = iomR3MMIOStatsCreate(pVM, GCPhys, pRange ? pRange->pszDesc : NULL);
@@ -1707,12 +1707,12 @@
      * disassembler). And get the I/O register size from the opcode / prefix.
      */
-    uint32_t    uPort = pRegFrame->edx & 0xffff;
-    unsigned    cbSize = 0;
+    RTIOPORT    Port = pRegFrame->edx & 0xffff;
+    unsigned    cb = 0;
     if (pCpu->pCurInstr->opcode == OP_INSB)
-        cbSize = 1;
+        cb = 1;
     else
-        cbSize = pCpu->opmode == CPUMODE_32BIT ? 4 : 2;
-
-    int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, uPort, cbSize);
+        cb = pCpu->opmode == CPUMODE_32BIT ? 4 : 2;
+
+    int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, Port, cb);
     if (RT_UNLIKELY(rc != VINF_SUCCESS))
     {
@@ -1721,5 +1721,5 @@
     }
 
-    return IOMInterpretINSEx(pVM, pRegFrame, uPort, pCpu->prefix, cbSize);
+    return IOMInterpretINSEx(pVM, pRegFrame, Port, pCpu->prefix, cb);
 }
 
@@ -1865,14 +1865,14 @@
      * And get the I/O register size from the opcode / prefix.
      */
-    uint32_t    uPort = 0;
-    unsigned    cbSize = 0;
-    bool fRc = iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uPort, &cbSize);
+    uint32_t    Port = 0;
+    unsigned    cb = 0;
+    bool fRc = iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &Port, &cb);
     AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
     if (pCpu->pCurInstr->opcode == OP_OUTSB)
-        cbSize = 1;
+        cb = 1;
     else
-        cbSize = (pCpu->opmode == CPUMODE_32BIT) ? 4 : 2;
-
-    int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, uPort, cbSize);
+        cb = (pCpu->opmode == CPUMODE_32BIT) ? 4 : 2;
+
+    int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, Port, cb);
     if (RT_UNLIKELY(rc != VINF_SUCCESS))
     {
@@ -1881,5 +1881,5 @@
     }
 
-    return IOMInterpretOUTSEx(pVM, pRegFrame, uPort, pCpu->prefix, cbSize);
-}
-
+    return IOMInterpretOUTSEx(pVM, pRegFrame, Port, pCpu->prefix, cb);
+}
+
Index: /trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp
===================================================================
--- /trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp	(revision 7730)
+++ /trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp	(revision 7731)
@@ -125,5 +125,5 @@
     GEN_CHECK_SIZE(IOMMMIORANGER0);
     GEN_CHECK_OFF(IOMMMIORANGER0, GCPhys);
-    GEN_CHECK_OFF(IOMMMIORANGER0, cbSize);
+    GEN_CHECK_OFF(IOMMMIORANGER0, cb);
     GEN_CHECK_OFF(IOMMMIORANGER0, pvUser);
     GEN_CHECK_OFF(IOMMMIORANGER0, pDevIns);
@@ -133,5 +133,5 @@
     GEN_CHECK_SIZE(IOMMMIORANGEGC);
     GEN_CHECK_OFF(IOMMMIORANGEGC, GCPhys);
-    GEN_CHECK_OFF(IOMMMIORANGEGC, cbSize);
+    GEN_CHECK_OFF(IOMMMIORANGEGC, cb);
     GEN_CHECK_OFF(IOMMMIORANGEGC, pvUser);
     GEN_CHECK_OFF(IOMMMIORANGEGC, pDevIns);
