Index: /trunk/include/VBox/dis.h
===================================================================
--- /trunk/include/VBox/dis.h	(revision 41662)
+++ /trunk/include/VBox/dis.h	(revision 41663)
@@ -383,5 +383,4 @@
         uint32_t    u8;
     } uDisp;
-    uint32_t        size;
     int32_t         param;
 
@@ -410,5 +409,7 @@
 
     /** 2, 4 or 8. */
-    uint32_t scale;
+    uint8_t         scale;
+    /** Parameter size. */
+    uint8_t         cb;
 
 #ifndef DIS_SEPARATE_FORMATTER
Index: /trunk/src/VBox/Disassembler/DisasmCore.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41662)
+++ /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41663)
@@ -394,5 +394,5 @@
     {
         size += pCpu->pfnDisasmFnTable[pOp->idxParse1](lpszCodeBlock, pOp, &pCpu->param1, pCpu);
-        if (fFiltered == false) pCpu->param1.size = DISGetParamSize(pCpu, &pCpu->param1);
+        if (fFiltered == false) pCpu->param1.cb = DISGetParamSize(pCpu, &pCpu->param1);
     }
 
@@ -400,5 +400,5 @@
     {
         size += pCpu->pfnDisasmFnTable[pOp->idxParse2](lpszCodeBlock+size, pOp, &pCpu->param2, pCpu);
-        if (fFiltered == false) pCpu->param2.size = DISGetParamSize(pCpu, &pCpu->param2);
+        if (fFiltered == false) pCpu->param2.cb = DISGetParamSize(pCpu, &pCpu->param2);
     }
 
@@ -406,5 +406,5 @@
     {
         size += pCpu->pfnDisasmFnTable[pOp->idxParse3](lpszCodeBlock+size, pOp, &pCpu->param3, pCpu);
-        if (fFiltered == false) pCpu->param3.size = DISGetParamSize(pCpu, &pCpu->param3);
+        if (fFiltered == false) pCpu->param3.cb = DISGetParamSize(pCpu, &pCpu->param3);
     }
     // else simple one byte instruction
@@ -1141,5 +1141,5 @@
     pParam->parval = DISReadByte(pCpu, lpszCodeBlock);
     pParam->flags |= USE_IMMEDIATE8;
-    pParam->size   = sizeof(uint8_t);
+    pParam->cb     = sizeof(uint8_t);
 
     disasmAddStringF1(pParam->szParam, "0%02Xh", (uint32_t)pParam->parval);
@@ -1162,5 +1162,5 @@
         pParam->parval = (uint32_t)(int8_t)DISReadByte(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE32_SX8;
-        pParam->size   = sizeof(uint32_t);
+        pParam->cb     = sizeof(uint32_t);
         disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
     }
@@ -1170,5 +1170,5 @@
         pParam->parval = (uint64_t)(int8_t)DISReadByte(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE64_SX8;
-        pParam->size   = sizeof(uint64_t);
+        pParam->cb     = sizeof(uint64_t);
         disasmAddStringF1(pParam->szParam, "0%016RX64h", pParam->parval);
     }
@@ -1177,5 +1177,5 @@
         pParam->parval = (uint16_t)(int8_t)DISReadByte(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE16_SX8;
-        pParam->size   = sizeof(uint16_t);
+        pParam->cb     = sizeof(uint16_t);
         disasmAddStringF1(pParam->szParam, "0%04Xh", (uint16_t)pParam->parval);
     }
@@ -1196,5 +1196,5 @@
     pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
     pParam->flags |= USE_IMMEDIATE16;
-    pParam->size   = sizeof(uint16_t);
+    pParam->cb     = sizeof(uint16_t);
 
     disasmAddStringF1(pParam->szParam, "0%04Xh", (uint16_t)pParam->parval);
@@ -1215,5 +1215,5 @@
     pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
     pParam->flags |= USE_IMMEDIATE32;
-    pParam->size   = sizeof(uint32_t);
+    pParam->cb     = sizeof(uint32_t);
 
     disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
@@ -1234,5 +1234,5 @@
     pParam->parval = DISReadQWord(pCpu, lpszCodeBlock);
     pParam->flags |= USE_IMMEDIATE64;
-    pParam->size   = sizeof(uint64_t);
+    pParam->cb     = sizeof(uint64_t);
 
     disasmAddStringF2(pParam->szParam, "0%08X%08Xh",
@@ -1256,5 +1256,5 @@
         pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE32;
-        pParam->size   = sizeof(uint32_t);
+        pParam->cb     = sizeof(uint32_t);
 
         disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
@@ -1266,5 +1266,5 @@
         pParam->parval = DISReadQWord(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE64;
-        pParam->size   = sizeof(uint64_t);
+        pParam->cb     = sizeof(uint64_t);
 
         disasmAddStringF1(pParam->szParam, "0%RX64h", pParam->parval);
@@ -1275,5 +1275,5 @@
         pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE16;
-        pParam->size   = sizeof(uint16_t);
+        pParam->cb     = sizeof(uint16_t);
 
         disasmAddStringF1(pParam->szParam, "0%04Xh", (uint32_t)pParam->parval);
@@ -1302,5 +1302,5 @@
         pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE16;
-        pParam->size   = sizeof(uint16_t);
+        pParam->cb     = sizeof(uint16_t);
 
         disasmAddStringF1(pParam->szParam, "0%04Xh", (uint32_t)pParam->parval);
@@ -1314,5 +1314,5 @@
             pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, lpszCodeBlock);
             pParam->flags |= USE_IMMEDIATE64;
-            pParam->size   = sizeof(uint64_t);
+            pParam->cb     = sizeof(uint64_t);
             disasmAddStringF1(pParam->szParam, "0%RX64h", pParam->parval);
         }
@@ -1321,5 +1321,5 @@
             pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
             pParam->flags |= USE_IMMEDIATE32;
-            pParam->size   = sizeof(uint32_t);
+            pParam->cb     = sizeof(uint32_t);
             disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
         }
@@ -1346,5 +1346,5 @@
     pParam->parval = DISReadByte(pCpu, lpszCodeBlock);
     pParam->flags |= USE_IMMEDIATE8_REL;
-    pParam->size   = sizeof(uint8_t);
+    pParam->cb     = sizeof(uint8_t);
 
     disasmAddStringF1(pParam->szParam, " (0%02Xh)", (uint32_t)pParam->parval);
@@ -1369,5 +1369,5 @@
         pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE32_REL;
-        pParam->size   = sizeof(int32_t);
+        pParam->cb     = sizeof(int32_t);
 
         disasmAddStringF1(pParam->szParam, " (0%08Xh)", (uint32_t)pParam->parval);
@@ -1380,5 +1380,5 @@
         pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE64_REL;
-        pParam->size   = sizeof(int64_t);
+        pParam->cb     = sizeof(int64_t);
 
         disasmAddStringF1(pParam->szParam, " (0%RX64h)", pParam->parval);
@@ -1389,5 +1389,5 @@
         pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE16_REL;
-        pParam->size   = sizeof(int16_t);
+        pParam->cb     = sizeof(int16_t);
 
         disasmAddStringF1(pParam->szParam, " (0%04Xh)", (uint32_t)pParam->parval);
@@ -1418,5 +1418,5 @@
             *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, lpszCodeBlock+sizeof(uint32_t));
             pParam->flags  |= USE_IMMEDIATE_ADDR_16_32;
-            pParam->size   = sizeof(uint16_t) + sizeof(uint32_t);
+            pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
 
             disasmAddStringF2(pParam->szParam, "0%04X:0%08Xh", (uint32_t)(pParam->parval>>32), (uint32_t)pParam->parval);
@@ -1431,5 +1431,5 @@
             pParam->uDisp.i32 = DISReadDWord(pCpu, lpszCodeBlock);
             pParam->flags |= USE_DISPLACEMENT32;
-            pParam->size   = sizeof(uint32_t);
+            pParam->cb     = sizeof(uint32_t);
 
             disasmAddStringF1(pParam->szParam, "[0%08Xh]", pParam->uDisp.i32);
@@ -1448,5 +1448,5 @@
         pParam->uDisp.i64 = DISReadQWord(pCpu, lpszCodeBlock);
         pParam->flags |= USE_DISPLACEMENT64;
-        pParam->size   = sizeof(uint64_t);
+        pParam->cb     = sizeof(uint64_t);
 
         disasmAddStringF2(pParam->szParam, "[0%08X%08Xh]", (uint32_t)(pParam->uDisp.i64 >> 32), (uint32_t)pParam->uDisp.i64);
@@ -1459,5 +1459,5 @@
             pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
             pParam->flags |= USE_IMMEDIATE_ADDR_16_16;
-            pParam->size   = 2*sizeof(uint16_t);
+            pParam->cb     = 2*sizeof(uint16_t);
 
             disasmAddStringF2(pParam->szParam, "0%04X:0%04Xh", (uint32_t)(pParam->parval>>16), (uint16_t)pParam->parval );
@@ -1472,5 +1472,5 @@
             pParam->uDisp.i16 = DISReadWord(pCpu, lpszCodeBlock);
             pParam->flags |= USE_DISPLACEMENT16;
-            pParam->size   = sizeof(uint16_t);
+            pParam->cb     = sizeof(uint16_t);
 
             disasmAddStringF1(pParam->szParam, "[0%04Xh]", (uint32_t)pParam->uDisp.i16);
@@ -1526,5 +1526,5 @@
         *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, lpszCodeBlock+sizeof(uint32_t));
         pParam->flags  |= USE_IMMEDIATE_ADDR_16_32;
-        pParam->size   = sizeof(uint16_t) + sizeof(uint32_t);
+        pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
 
         disasmAddStringF2(pParam->szParam, "0%04X:0%08Xh", (uint32_t)(pParam->parval>>32), (uint32_t)pParam->parval);
@@ -1536,5 +1536,5 @@
         pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
         pParam->flags |= USE_IMMEDIATE_ADDR_16_16;
-        pParam->size   = 2*sizeof(uint16_t);
+        pParam->cb     = 2*sizeof(uint16_t);
 
         disasmAddStringF2(pParam->szParam, "0%04X:0%04Xh", (uint32_t)(pParam->parval>>16), (uint16_t)pParam->parval );
@@ -1590,5 +1590,5 @@
             pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN32_START;
             pParam->flags |= USE_REG_GEN32;
-            pParam->size   = 4;
+            pParam->cb     = 4;
         }
         else
@@ -1604,5 +1604,5 @@
 
             pParam->flags |= USE_REG_GEN64;
-            pParam->size   = 8;
+            pParam->cb     = 8;
         }
         else
@@ -1611,5 +1611,5 @@
             pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN32_START;
             pParam->flags |= USE_REG_GEN16;
-            pParam->size   = 2;
+            pParam->cb     = 2;
             pParam->param = pParam->param - OP_PARM_REG_GEN32_START + OP_PARM_REG_GEN16_START;
         }
@@ -1621,5 +1621,5 @@
         pParam->base.reg_seg = (DIS_SELREG)(pParam->param - OP_PARM_REG_SEG_START);
         pParam->flags |= USE_REG_SEG;
-        pParam->size   = 2;
+        pParam->cb     = 2;
     }
     else
@@ -1629,5 +1629,5 @@
         pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN16_START;
         pParam->flags |= USE_REG_GEN16;
-        pParam->size   = 2;
+        pParam->cb     = 2;
     }
     else
@@ -1637,5 +1637,5 @@
         pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN8_START;
         pParam->flags |= USE_REG_GEN8;
-        pParam->size   = 1;
+        pParam->cb     = 1;
 
         if (pCpu->opmode == CPUMODE_64BIT)
@@ -1654,5 +1654,5 @@
         pParam->base.reg_fp = pParam->param - OP_PARM_REG_FP_START;
         pParam->flags |= USE_REG_FP;
-        pParam->size   = 10;
+        pParam->cb     = 10;
     }
     Assert(!(pParam->param >= OP_PARM_REG_GEN64_START && pParam->param <= OP_PARM_REG_GEN64_END));
Index: /trunk/src/VBox/Disassembler/DisasmReg.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41662)
+++ /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41663)
@@ -260,6 +260,6 @@
 
     default:
-        if (pParam->size)
-            return pParam->size;
+        if (pParam->cb)
+            return pParam->cb;
         else //@todo dangerous!!!
             return 4;
@@ -523,5 +523,5 @@
         // Effective address
         pParamVal->type = PARMTYPE_ADDRESS;
-        pParamVal->size = pParam->size;
+        pParamVal->size = pParam->cb;
 
         if (pParam->flags & USE_BASE)
@@ -651,5 +651,5 @@
             // Caller needs to interpret the register according to the instruction (source/target, special value etc)
             pParamVal->type = PARMTYPE_REGISTER;
-            pParamVal->size = pParam->size;
+            pParamVal->size = pParam->cb;
             return VINF_SUCCESS;
         }
@@ -700,5 +700,5 @@
         {
             pParamVal->flags |= PARAM_VAL8;
-            if (pParam->size == 2)
+            if (pParam->cb == 2)
             {
                 pParamVal->size   = sizeof(uint16_t);
@@ -717,5 +717,5 @@
             pParamVal->size   = sizeof(uint16_t);
             pParamVal->val.val16 = (uint16_t)pParam->parval;
-            AssertMsg(pParamVal->size == pParam->size || ((pParam->size == 1) && (pParam->flags & USE_IMMEDIATE16_SX8)), ("pParamVal->size %d vs %d EIP=%RX32\n", pParamVal->size, pParam->size, pCtx->eip) );
+            AssertMsg(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & USE_IMMEDIATE16_SX8)), ("pParamVal->size %d vs %d EIP=%RX32\n", pParamVal->size, pParam->cb, pCtx->eip) );
         }
         else
@@ -725,5 +725,5 @@
             pParamVal->size   = sizeof(uint32_t);
             pParamVal->val.val32 = (uint32_t)pParam->parval;
-            Assert(pParamVal->size == pParam->size || ((pParam->size == 1) && (pParam->flags & USE_IMMEDIATE32_SX8)) );
+            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & USE_IMMEDIATE32_SX8)) );
         }
         else
@@ -733,5 +733,5 @@
             pParamVal->size   = sizeof(uint64_t);
             pParamVal->val.val64 = pParam->parval;
-            Assert(pParamVal->size == pParam->size || ((pParam->size == 1) && (pParam->flags & USE_IMMEDIATE64_SX8)) );
+            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & USE_IMMEDIATE64_SX8)) );
         }
         else
@@ -742,5 +742,5 @@
             pParamVal->val.farptr.sel    = (uint16_t)RT_LOWORD(pParam->parval >> 16);
             pParamVal->val.farptr.offset = (uint32_t)RT_LOWORD(pParam->parval);
-            Assert(pParamVal->size == pParam->size);
+            Assert(pParamVal->size == pParam->cb);
         }
         else
@@ -751,5 +751,5 @@
             pParamVal->val.farptr.sel    = (uint16_t)RT_LOWORD(pParam->parval >> 32);
             pParamVal->val.farptr.offset = (uint32_t)(pParam->parval & 0xFFFFFFFF);
-            Assert(pParam->size == 8);
+            Assert(pParam->cb == 8);
         }
     }
Index: /trunk/src/VBox/VMM/VMMAll/EMAll.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/EMAll.cpp	(revision 41662)
+++ /trunk/src/VBox/VMM/VMMAll/EMAll.cpp	(revision 41663)
@@ -828,5 +828,5 @@
             uint64_t valpar1, valpar2;
 
-            AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
+            AssertReturn(pDis->param1.cb == pDis->param2.cb, VERR_EM_INTERPRETER);
             switch(param1.type)
             {
@@ -1114,13 +1114,13 @@
             uint64_t valpar1, valpar2;
 
-            if (pDis->param1.size != pDis->param2.size)
+            if (pDis->param1.cb != pDis->param2.cb)
             {
-                if (pDis->param1.size < pDis->param2.size)
+                if (pDis->param1.cb < pDis->param2.cb)
                 {
-                    AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size)); /* should never happen! */
+                    AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.cb, pDis->param2.cb)); /* should never happen! */
                     return VERR_EM_INTERPRETER;
                 }
                 /* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
-                pDis->param2.size = pDis->param1.size;
+                pDis->param2.cb = pDis->param1.cb;
                 param2.size     = param1.size;
             }
@@ -1195,5 +1195,5 @@
 
 #if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0)
-    Assert(pDis->param1.size <= 4);
+    Assert(pDis->param1.cb <= 4);
 #endif
 
@@ -1206,12 +1206,12 @@
         return VERR_EM_INTERPRETER;
 
-    if (pDis->param1.size != pDis->param2.size)
-    {
-        AssertMsgReturn(pDis->param1.size >= pDis->param2.size, /* should never happen! */
-                        ("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size),
+    if (pDis->param1.cb != pDis->param2.cb)
+    {
+        AssertMsgReturn(pDis->param1.cb >= pDis->param2.cb, /* should never happen! */
+                        ("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.cb, pDis->param2.cb),
                         VERR_EM_INTERPRETER);
 
         /* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
-        pDis->param2.size = pDis->param1.size;
+        pDis->param2.cb = pDis->param1.cb;
         param2.size       = param1.size;
     }
@@ -1238,12 +1238,12 @@
 
     /* Try emulate it with a one-shot #PF handler in place. (RC) */
-    Log2(("%s %RGv imm%d=%RX64\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
+    Log2(("%s %RGv imm%d=%RX64\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.cb*8, ValPar2));
 
     RTGCUINTREG32 eflags = 0;
-    rc = pfnEmulate(pvParam1, ValPar2, pDis->param2.size, &eflags);
+    rc = pfnEmulate(pvParam1, ValPar2, pDis->param2.cb, &eflags);
     PGMPhysReleasePageMappingLock(pVM, &Lock);
     if (RT_FAILURE(rc))
     {
-        Log(("%s %RGv imm%d=%RX64-> emulation failed due to page fault!\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
+        Log(("%s %RGv imm%d=%RX64-> emulation failed due to page fault!\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.cb*8, ValPar2));
         return VERR_EM_INTERPRETER;
     }
@@ -1283,13 +1283,13 @@
             uint64_t valpar1, valpar2;
 
-            if (pDis->param1.size != pDis->param2.size)
+            if (pDis->param1.cb != pDis->param2.cb)
             {
-                if (pDis->param1.size < pDis->param2.size)
+                if (pDis->param1.cb < pDis->param2.cb)
                 {
-                    AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size)); /* should never happen! */
+                    AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.cb, pDis->param2.cb)); /* should never happen! */
                     return VERR_EM_INTERPRETER;
                 }
                 /* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
-                pDis->param2.size = pDis->param1.size;
+                pDis->param2.cb = pDis->param1.cb;
                 param2.size     = param1.size;
             }
@@ -1492,5 +1492,5 @@
     {
         Log(("emInterpretLockBitTest %s: %RGv imm%d=%RX64 -> emulation failed due to page fault!\n",
-             emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
+             emGetMnemonic(pDis), GCPtrPar1, pDis->param2.cb*8, ValPar2));
         return VERR_EM_INTERPRETER;
     }
@@ -1805,5 +1805,5 @@
 
 #if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0)
-    Assert(pDis->param1.size <= 4);
+    Assert(pDis->param1.cb <= 4);
 #endif
 
@@ -1833,5 +1833,5 @@
     uint64_t eflags;
 
-    AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
+    AssertReturn(pDis->param1.cb == pDis->param2.cb, VERR_EM_INTERPRETER);
     switch(param1.type)
     {
@@ -1851,7 +1851,7 @@
 
     if (pDis->prefix & PREFIX_LOCK)
-        eflags = EMEmulateLockCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.size);
+        eflags = EMEmulateLockCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.cb);
     else
-        eflags = EMEmulateCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.size);
+        eflags = EMEmulateCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.cb);
 
     LogFlow(("%s %RGv rax=%RX64 %RX64 ZF=%d\n", emGetMnemonic(pDis), GCPtrPar1, pRegFrame->rax, valpar, !!(eflags & X86_EFL_ZF)));
@@ -1886,5 +1886,5 @@
     PGMPAGEMAPLOCK Lock;
 
-    AssertReturn(pDis->param1.size == 8, VERR_EM_INTERPRETER);
+    AssertReturn(pDis->param1.cb == 8, VERR_EM_INTERPRETER);
     switch(param1.type)
     {
@@ -1953,5 +1953,5 @@
             PGMPAGEMAPLOCK  Lock;
 
-            AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
+            AssertReturn(pDis->param1.cb == pDis->param2.cb, VERR_EM_INTERPRETER);
             switch(param1.type)
             {
@@ -3143,5 +3143,5 @@
      * Whitelisted instructions are safe.
      */
-    if (    pDis->param1.size > 4
+    if (    pDis->param1.cb > 4
         &&  CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
     {
Index: /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp	(revision 41662)
+++ /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp	(revision 41663)
@@ -887,5 +887,5 @@
                                           PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault)
 {
-    unsigned uIncrement = pDis->param1.size;
+    unsigned uIncrement = pDis->param1.cb;
     NOREF(pVM);
 
@@ -1123,5 +1123,5 @@
     if (    pPage->GCPtrLastAccessHandlerRip >= pRegFrame->rip - 0x40      /* observed loops in Windows 7 x64 */
         &&  pPage->GCPtrLastAccessHandlerRip <  pRegFrame->rip + 0x40
-        &&  pvFault == (pPage->GCPtrLastAccessHandlerFault + pDis->param1.size)
+        &&  pvFault == (pPage->GCPtrLastAccessHandlerFault + pDis->param1.cb)
         &&  pVCpu->pgm.s.cPoolAccessHandler == pPage->cLastAccessHandler + 1)
     {
Index: /trunk/src/VBox/VMM/VMMR3/PATM.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/PATM.cpp	(revision 41662)
+++ /trunk/src/VBox/VMM/VMMR3/PATM.cpp	(revision 41663)
@@ -1323,6 +1323,6 @@
            )
         {
-            Assert(pCpu->param1.size <= 4 || pCpu->param1.size == 6);
-            if (    pCpu->param1.size == 6 /* far call/jmp */
+            Assert(pCpu->param1.cb <= 4 || pCpu->param1.cb == 6);
+            if (    pCpu->param1.cb == 6 /* far call/jmp */
                 ||  (pCpu->pCurInstr->opcode == OP_CALL && !(pPatch->flags & PATMFL_SUPPORT_CALLS))
                 ||  (OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J && !(pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS))
@@ -1482,6 +1482,6 @@
            )
         {
-            Assert(pCpu->param1.size <= 4 || pCpu->param1.size == 6);
-            if (    pCpu->param1.size == 6 /* far call/jmp */
+            Assert(pCpu->param1.cb <= 4 || pCpu->param1.cb == 6);
+            if (    pCpu->param1.cb == 6 /* far call/jmp */
                 ||  (pCpu->pCurInstr->opcode == OP_CALL && !(pPatch->flags & PATMFL_SUPPORT_CALLS))
                 ||  (OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J && !(pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS))
@@ -1869,6 +1869,6 @@
          * In that case we'll jump to the original instruction and continue from there. Otherwise an int 3 is executed.
          */
-        Assert(pCpu->param1.size == 4 || pCpu->param1.size == 6);
-        if (pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS && pCpu->param1.size == 4 /* no far calls! */)
+        Assert(pCpu->param1.cb == 4 || pCpu->param1.cb == 6);
+        if (pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS && pCpu->param1.cb == 4 /* no far calls! */)
         {
             rc = patmPatchGenCall(pVM, pPatch, pCpu, pCurInstrGC, (RTRCPTR)0xDEADBEEF, true);
@@ -1886,6 +1886,6 @@
          * In that case we'll jump to the original instruction and continue from there. Otherwise an int 3 is executed.
          */
-        Assert(pCpu->param1.size == 4 || pCpu->param1.size == 6);
-        if (pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS && pCpu->param1.size == 4 /* no far jumps! */)
+        Assert(pCpu->param1.cb == 4 || pCpu->param1.cb == 6);
+        if (pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS && pCpu->param1.cb == 4 /* no far jumps! */)
         {
             rc = patmPatchGenJump(pVM, pPatch, pCpu, pCurInstrGC);
@@ -2059,5 +2059,5 @@
 
             bool disret = PATMR3DISInstr(pVM, pPatch, &cpu, pOrgJumpGC, pOrgJumpHC, &dummy, NULL);
-            if (!disret || cpu.pCurInstr->opcode != OP_CALL || cpu.param1.size != 4 /* only near calls */)
+            if (!disret || cpu.pCurInstr->opcode != OP_CALL || cpu.param1.cb != 4 /* only near calls */)
                 return VINF_SUCCESS;
         }
Index: /trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp	(revision 41662)
+++ /trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp	(revision 41663)
@@ -693,5 +693,5 @@
     {
         Log(("patmPatchGenIndirectCall\n"));
-        Assert(pCpu->param1.size == 4);
+        Assert(pCpu->param1.cb == 4);
         Assert(OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J);
 
@@ -789,5 +789,5 @@
 
     Log(("patmPatchGenIndirectJump\n"));
-    Assert(pCpu->param1.size == 4);
+    Assert(pCpu->param1.cb == 4);
     Assert(OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J);