Index: /trunk/include/VBox/dis.h
===================================================================
--- /trunk/include/VBox/dis.h	(revision 41728)
+++ /trunk/include/VBox/dis.h	(revision 41729)
@@ -382,24 +382,24 @@
 /** @}  */
 
-/** Used by DISQueryParamVal & EMIQueryParamVal
- * @{
- */
-#define PARAM_VAL8             RT_BIT(0)
-#define PARAM_VAL16            RT_BIT(1)
-#define PARAM_VAL32            RT_BIT(2)
-#define PARAM_VAL64            RT_BIT(3)
-#define PARAM_VALFARPTR16      RT_BIT(4)
-#define PARAM_VALFARPTR32      RT_BIT(5)
-
-#define PARMTYPE_REGISTER      1
-#define PARMTYPE_ADDRESS       2
-#define PARMTYPE_IMMEDIATE     3
+/** @name Flags returned by DISQueryParamVal (DISQPVPARAMVAL::flags).
+ * @{
+ */
+#define DISQPV_FLAG_8                   UINT8_C(0x01)
+#define DISQPV_FLAG_16                  UINT8_C(0x02)
+#define DISQPV_FLAG_32                  UINT8_C(0x04)
+#define DISQPV_FLAG_64                  UINT8_C(0x08)
+#define DISQPV_FLAG_FARPTR16            UINT8_C(0x10)
+#define DISQPV_FLAG_FARPTR32            UINT8_C(0x20)
+/** @}  */
+
+/** @name Types returned by DISQueryParamVal (DISQPVPARAMVAL::flags).
+ * @{ */
+#define DISQPV_TYPE_REGISTER            UINT8_C(1)
+#define DISQPV_TYPE_ADDRESS             UINT8_C(2)
+#define DISQPV_TYPE_IMMEDIATE           UINT8_C(3)
+/** @}  */
 
 typedef struct
 {
-    uint32_t        type;
-    uint32_t        size;
-    uint64_t        flags;
-
     union
     {
@@ -416,15 +416,19 @@
     } val;
 
-} OP_PARAMVAL;
+    uint8_t         type;
+    uint8_t         size;
+    uint8_t         flags;
+} DISQPVPARAMVAL;
 /** Pointer to opcode parameter value. */
-typedef OP_PARAMVAL *POP_PARAMVAL;
-
-typedef enum
+typedef DISQPVPARAMVAL *PDISQPVPARAMVAL;
+
+/** Indicates which parameter DISQueryParamVal should operate on. */
+typedef enum DISQPVWHICH
 {
-    PARAM_DEST,
-    PARAM_SOURCE
-} PARAM_TYPE;
-
-/** @} */
+    DISQPVWHICH_DST = 1,
+    DISQPVWHICH_SRC,
+    DISQPVWHAT_32_BIT_HACK = 0x7fffffff
+} DISQPVWHICH;
+
 
 /**
@@ -649,5 +653,5 @@
 DISDECL(uint8_t)    DISQuerySegPrefixByte(PDISCPUSTATE pCpu);
 
-DISDECL(int) DISQueryParamVal(PCPUMCTXCORE pCtx, PDISCPUSTATE pCpu, PDISOPPARAM pParam, POP_PARAMVAL pParamVal, PARAM_TYPE parmtype);
+DISDECL(int) DISQueryParamVal(PCPUMCTXCORE pCtx, PDISCPUSTATE pCpu, PDISOPPARAM pParam, PDISQPVPARAMVAL pParamVal, DISQPVWHICH parmtype);
 DISDECL(int) DISQueryParamRegPtr(PCPUMCTXCORE pCtx, PDISCPUSTATE pCpu, PDISOPPARAM pParam, void **ppReg, size_t *pcbSize);
 
Index: /trunk/src/VBox/Disassembler/DisasmReg.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41728)
+++ /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41729)
@@ -500,5 +500,5 @@
  *
  */
-DISDECL(int) DISQueryParamVal(PCPUMCTXCORE pCtx, PDISCPUSTATE pCpu, PDISOPPARAM pParam, POP_PARAMVAL pParamVal, PARAM_TYPE parmtype)
+DISDECL(int) DISQueryParamVal(PCPUMCTXCORE pCtx, PDISCPUSTATE pCpu, PDISOPPARAM pParam, PDISQPVPARAMVAL pParamVal, DISQPVWHICH parmtype)
 {
     memset(pParamVal, 0, sizeof(*pParamVal));
@@ -507,5 +507,5 @@
     {
         // Effective address
-        pParamVal->type = PARMTYPE_ADDRESS;
+        pParamVal->type = DISQPV_TYPE_ADDRESS;
         pParamVal->size = pParam->cb;
 
@@ -514,5 +514,5 @@
             if (pParam->fUse & DISUSE_REG_GEN8)
             {
-                pParamVal->flags |= PARAM_VAL8;
+                pParamVal->flags |= DISQPV_FLAG_8;
                 if (RT_FAILURE(DISFetchReg8(pCtx, pParam->base.reg_gen, &pParamVal->val.val8))) return VERR_INVALID_PARAMETER;
             }
@@ -520,5 +520,5 @@
             if (pParam->fUse & DISUSE_REG_GEN16)
             {
-                pParamVal->flags |= PARAM_VAL16;
+                pParamVal->flags |= DISQPV_FLAG_16;
                 if (RT_FAILURE(DISFetchReg16(pCtx, pParam->base.reg_gen, &pParamVal->val.val16))) return VERR_INVALID_PARAMETER;
             }
@@ -526,5 +526,5 @@
             if (pParam->fUse & DISUSE_REG_GEN32)
             {
-                pParamVal->flags |= PARAM_VAL32;
+                pParamVal->flags |= DISQPV_FLAG_32;
                 if (RT_FAILURE(DISFetchReg32(pCtx, pParam->base.reg_gen, &pParamVal->val.val32))) return VERR_INVALID_PARAMETER;
             }
@@ -532,5 +532,5 @@
             if (pParam->fUse & DISUSE_REG_GEN64)
             {
-                pParamVal->flags |= PARAM_VAL64;
+                pParamVal->flags |= DISQPV_FLAG_64;
                 if (RT_FAILURE(DISFetchReg64(pCtx, pParam->base.reg_gen, &pParamVal->val.val64))) return VERR_INVALID_PARAMETER;
             }
@@ -548,5 +548,5 @@
                 uint16_t val16;
 
-                pParamVal->flags |= PARAM_VAL16;
+                pParamVal->flags |= DISQPV_FLAG_16;
                 if (RT_FAILURE(DISFetchReg16(pCtx, pParam->index.reg_gen, &val16))) return VERR_INVALID_PARAMETER;
 
@@ -560,5 +560,5 @@
                 uint32_t val32;
 
-                pParamVal->flags |= PARAM_VAL32;
+                pParamVal->flags |= DISQPV_FLAG_32;
                 if (RT_FAILURE(DISFetchReg32(pCtx, pParam->index.reg_gen, &val32))) return VERR_INVALID_PARAMETER;
 
@@ -573,5 +573,5 @@
                 uint64_t val64;
 
-                pParamVal->flags |= PARAM_VAL64;
+                pParamVal->flags |= DISQPV_FLAG_64;
                 if (RT_FAILURE(DISFetchReg64(pCtx, pParam->index.reg_gen, &val64))) return VERR_INVALID_PARAMETER;
 
@@ -632,18 +632,18 @@
     if (pParam->fUse & (DISUSE_REG_GEN8|DISUSE_REG_GEN16|DISUSE_REG_GEN32|DISUSE_REG_GEN64|DISUSE_REG_FP|DISUSE_REG_MMX|DISUSE_REG_XMM|DISUSE_REG_CR|DISUSE_REG_DBG|DISUSE_REG_SEG|DISUSE_REG_TEST))
     {
-        if (parmtype == PARAM_DEST)
+        if (parmtype == DISQPVWHICH_DST)
         {
             // Caller needs to interpret the register according to the instruction (source/target, special value etc)
-            pParamVal->type = PARMTYPE_REGISTER;
+            pParamVal->type = DISQPV_TYPE_REGISTER;
             pParamVal->size = pParam->cb;
             return VINF_SUCCESS;
         }
-        //else PARAM_SOURCE
-
-        pParamVal->type = PARMTYPE_IMMEDIATE;
+        //else DISQPVWHICH_SRC
+
+        pParamVal->type = DISQPV_TYPE_IMMEDIATE;
 
         if (pParam->fUse & DISUSE_REG_GEN8)
         {
-            pParamVal->flags |= PARAM_VAL8;
+            pParamVal->flags |= DISQPV_FLAG_8;
             pParamVal->size   = sizeof(uint8_t);
             if (RT_FAILURE(DISFetchReg8(pCtx, pParam->base.reg_gen, &pParamVal->val.val8))) return VERR_INVALID_PARAMETER;
@@ -652,5 +652,5 @@
         if (pParam->fUse & DISUSE_REG_GEN16)
         {
-            pParamVal->flags |= PARAM_VAL16;
+            pParamVal->flags |= DISQPV_FLAG_16;
             pParamVal->size   = sizeof(uint16_t);
             if (RT_FAILURE(DISFetchReg16(pCtx, pParam->base.reg_gen, &pParamVal->val.val16))) return VERR_INVALID_PARAMETER;
@@ -659,5 +659,5 @@
         if (pParam->fUse & DISUSE_REG_GEN32)
         {
-            pParamVal->flags |= PARAM_VAL32;
+            pParamVal->flags |= DISQPV_FLAG_32;
             pParamVal->size   = sizeof(uint32_t);
             if (RT_FAILURE(DISFetchReg32(pCtx, pParam->base.reg_gen, &pParamVal->val.val32))) return VERR_INVALID_PARAMETER;
@@ -666,5 +666,5 @@
         if (pParam->fUse & DISUSE_REG_GEN64)
         {
-            pParamVal->flags |= PARAM_VAL64;
+            pParamVal->flags |= DISQPV_FLAG_64;
             pParamVal->size   = sizeof(uint64_t);
             if (RT_FAILURE(DISFetchReg64(pCtx, pParam->base.reg_gen, &pParamVal->val.val64))) return VERR_INVALID_PARAMETER;
@@ -673,5 +673,5 @@
         {
             // Caller needs to interpret the register according to the instruction (source/target, special value etc)
-            pParamVal->type = PARMTYPE_REGISTER;
+            pParamVal->type = DISQPV_TYPE_REGISTER;
         }
         Assert(!(pParam->fUse & DISUSE_IMMEDIATE));
@@ -681,8 +681,8 @@
     if (pParam->fUse & DISUSE_IMMEDIATE)
     {
-        pParamVal->type = PARMTYPE_IMMEDIATE;
+        pParamVal->type = DISQPV_TYPE_IMMEDIATE;
         if (pParam->fUse & (DISUSE_IMMEDIATE8|DISUSE_IMMEDIATE8_REL))
         {
-            pParamVal->flags |= PARAM_VAL8;
+            pParamVal->flags |= DISQPV_FLAG_8;
             if (pParam->cb == 2)
             {
@@ -699,5 +699,5 @@
         if (pParam->fUse & (DISUSE_IMMEDIATE16|DISUSE_IMMEDIATE16_REL|DISUSE_IMMEDIATE_ADDR_0_16|DISUSE_IMMEDIATE16_SX8))
         {
-            pParamVal->flags |= PARAM_VAL16;
+            pParamVal->flags |= DISQPV_FLAG_16;
             pParamVal->size   = sizeof(uint16_t);
             pParamVal->val.val16 = (uint16_t)pParam->parval;
@@ -707,5 +707,5 @@
         if (pParam->fUse & (DISUSE_IMMEDIATE32|DISUSE_IMMEDIATE32_REL|DISUSE_IMMEDIATE_ADDR_0_32|DISUSE_IMMEDIATE32_SX8))
         {
-            pParamVal->flags |= PARAM_VAL32;
+            pParamVal->flags |= DISQPV_FLAG_32;
             pParamVal->size   = sizeof(uint32_t);
             pParamVal->val.val32 = (uint32_t)pParam->parval;
@@ -715,5 +715,5 @@
         if (pParam->fUse & (DISUSE_IMMEDIATE64 | DISUSE_IMMEDIATE64_REL | DISUSE_IMMEDIATE64_SX8))
         {
-            pParamVal->flags |= PARAM_VAL64;
+            pParamVal->flags |= DISQPV_FLAG_64;
             pParamVal->size   = sizeof(uint64_t);
             pParamVal->val.val64 = pParam->parval;
@@ -723,5 +723,5 @@
         if (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_16))
         {
-            pParamVal->flags |= PARAM_VALFARPTR16;
+            pParamVal->flags |= DISQPV_FLAG_FARPTR16;
             pParamVal->size   = sizeof(uint16_t)*2;
             pParamVal->val.farptr.sel    = (uint16_t)RT_LOWORD(pParam->parval >> 16);
@@ -732,5 +732,5 @@
         if (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_32))
         {
-            pParamVal->flags |= PARAM_VALFARPTR32;
+            pParamVal->flags |= DISQPV_FLAG_FARPTR32;
             pParamVal->size   = sizeof(uint16_t) + sizeof(uint32_t);
             pParamVal->val.farptr.sel    = (uint16_t)RT_LOWORD(pParam->parval >> 32);
Index: /trunk/src/VBox/VMM/VMMAll/EMAll.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/EMAll.cpp	(revision 41728)
+++ /trunk/src/VBox/VMM/VMMAll/EMAll.cpp	(revision 41729)
@@ -805,13 +805,13 @@
 static int emInterpretXchg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
 {
-    OP_PARAMVAL param1, param2;
+    DISQPVPARAMVAL param1, param2;
     NOREF(pvFault);
 
     /* Source to make DISQueryParamVal read the register value - ugly hack */
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
 
-    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
+    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -829,9 +829,9 @@
             switch(param1.type)
             {
-            case PARMTYPE_IMMEDIATE: /* register type is translated to this one too */
+            case DISQPV_TYPE_IMMEDIATE: /* register type is translated to this one too */
                 valpar1 = param1.val.val64;
                 break;
 
-            case PARMTYPE_ADDRESS:
+            case DISQPV_TYPE_ADDRESS:
                 pParam1 = (RTGCPTR)param1.val.val64;
                 pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pParam1);
@@ -852,5 +852,5 @@
             switch(param2.type)
             {
-            case PARMTYPE_ADDRESS:
+            case DISQPV_TYPE_ADDRESS:
                 pParam2 = (RTGCPTR)param2.val.val64;
                 pParam2 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param2, pParam2);
@@ -863,5 +863,5 @@
                 break;
 
-            case PARMTYPE_IMMEDIATE:
+            case DISQPV_TYPE_IMMEDIATE:
                 valpar2 = param2.val.val64;
                 break;
@@ -875,5 +875,5 @@
             if (pParam1 == 0)
             {
-                Assert(param1.type == PARMTYPE_IMMEDIATE); /* register actually */
+                Assert(param1.type == DISQPV_TYPE_IMMEDIATE); /* register actually */
                 switch(param1.size)
                 {
@@ -901,5 +901,5 @@
             if (pParam2 == 0)
             {
-                Assert(param2.type == PARMTYPE_IMMEDIATE); /* register actually */
+                Assert(param2.type == DISQPV_TYPE_IMMEDIATE); /* register actually */
                 switch(param2.size)
                 {
@@ -940,8 +940,8 @@
                              PFNEMULATEPARAM2 pfnEmulate)
 {
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     NOREF(pvFault);
 
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_DST);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -956,5 +956,5 @@
             uint64_t valpar1;
 
-            if (param1.type == PARMTYPE_ADDRESS)
+            if (param1.type == DISQPV_TYPE_ADDRESS)
             {
                 pParam1 = (RTGCPTR)param1.val.val64;
@@ -1010,8 +1010,8 @@
 {
     Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     NOREF(pvFault);
 
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_DST);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -1043,5 +1043,5 @@
             }
 
-            if (param1.type == PARMTYPE_ADDRESS)
+            if (param1.type == DISQPV_TYPE_ADDRESS)
             {
                 pParam1 = (RTGCPTR)param1.val.val64;
@@ -1092,12 +1092,12 @@
                                PFNEMULATEPARAM3 pfnEmulate)
 {
-    OP_PARAMVAL param1, param2;
+    DISQPVPARAMVAL param1, param2;
     NOREF(pvFault);
 
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_DST);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
 
-    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
+    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -1125,5 +1125,5 @@
 
             /* The destination is always a virtual address */
-            if (param1.type == PARMTYPE_ADDRESS)
+            if (param1.type == DISQPV_TYPE_ADDRESS)
             {
                 pParam1 = (RTGCPTR)param1.val.val64;
@@ -1146,5 +1146,5 @@
             switch(param2.type)
             {
-            case PARMTYPE_IMMEDIATE:    /* both immediate data and register (ugly) */
+            case DISQPV_TYPE_IMMEDIATE:    /* both immediate data and register (ugly) */
                 valpar2 = param2.val.val64;
                 break;
@@ -1189,5 +1189,5 @@
 {
     void *pvParam1;
-    OP_PARAMVAL param1, param2;
+    DISQPVPARAMVAL param1, param2;
     NOREF(pvFault);
 
@@ -1196,9 +1196,9 @@
 #endif
 
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_DST);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
 
-    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
+    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -1222,10 +1222,10 @@
 #endif
 
-    /* Register and immediate data == PARMTYPE_IMMEDIATE */
-    AssertReturn(param2.type == PARMTYPE_IMMEDIATE, VERR_EM_INTERPRETER);
+    /* Register and immediate data == DISQPV_TYPE_IMMEDIATE */
+    AssertReturn(param2.type == DISQPV_TYPE_IMMEDIATE, VERR_EM_INTERPRETER);
     RTGCUINTREG ValPar2 = param2.val.val64;
 
     /* The destination is always a virtual address */
-    AssertReturn(param1.type == PARMTYPE_ADDRESS, VERR_EM_INTERPRETER);
+    AssertReturn(param1.type == DISQPV_TYPE_ADDRESS, VERR_EM_INTERPRETER);
 
     RTGCPTR GCPtrPar1 = param1.val.val64;
@@ -1263,10 +1263,10 @@
 {
     NOREF(pvFault);
-    OP_PARAMVAL param1, param2;
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
+    DISQPVPARAMVAL param1, param2;
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_DST);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
 
-    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
+    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -1294,5 +1294,5 @@
 
             /* The destination is always a virtual address */
-            if (param1.type == PARMTYPE_ADDRESS)
+            if (param1.type == DISQPV_TYPE_ADDRESS)
             {
                 pParam1 = (RTGCPTR)param1.val.val64;
@@ -1317,5 +1317,5 @@
             switch(param2.type)
             {
-            case PARMTYPE_IMMEDIATE:    /* both immediate data and register (ugly) */
+            case DISQPV_TYPE_IMMEDIATE:    /* both immediate data and register (ugly) */
                 valpar2 = param2.val.val64;
                 break;
@@ -1367,10 +1367,10 @@
                               PFNEMULATEPARAM2UINT32 pfnEmulate)
 {
-    OP_PARAMVAL param1, param2;
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
+    DISQPVPARAMVAL param1, param2;
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_DST);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
 
-    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
+    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -1387,5 +1387,5 @@
 
             /* The destination is always a virtual address */
-            if (param1.type != PARMTYPE_ADDRESS)
+            if (param1.type != DISQPV_TYPE_ADDRESS)
                 return VERR_EM_INTERPRETER;
 
@@ -1396,5 +1396,5 @@
             switch(param2.type)
             {
-            case PARMTYPE_IMMEDIATE:    /* both immediate data and register (ugly) */
+            case DISQPV_TYPE_IMMEDIATE:    /* both immediate data and register (ugly) */
                 valpar2 = param2.val.val64;
                 break;
@@ -1449,19 +1449,19 @@
     void *pvParam1;
 
-    OP_PARAMVAL param1, param2;
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
+    DISQPVPARAMVAL param1, param2;
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_DST);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
 
-    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
+    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
 
     /* The destination is always a virtual address */
-    if (param1.type != PARMTYPE_ADDRESS)
-        return VERR_EM_INTERPRETER;
-
-    /* Register and immediate data == PARMTYPE_IMMEDIATE */
-    AssertReturn(param2.type == PARMTYPE_IMMEDIATE, VERR_EM_INTERPRETER);
+    if (param1.type != DISQPV_TYPE_ADDRESS)
+        return VERR_EM_INTERPRETER;
+
+    /* Register and immediate data == DISQPV_TYPE_IMMEDIATE */
+    AssertReturn(param2.type == DISQPV_TYPE_IMMEDIATE, VERR_EM_INTERPRETER);
     uint64_t ValPar2 = param2.val.val64;
 
@@ -1511,10 +1511,10 @@
 {
     NOREF(pvFault);
-    OP_PARAMVAL param1, param2;
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_DEST);
+    DISQPVPARAMVAL param1, param2;
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_DST);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
 
-    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
+    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -1527,5 +1527,5 @@
 #else
         /** @todo Make this the default and don't rely on TRPM information. */
-        if (param1.type == PARMTYPE_ADDRESS)
+        if (param1.type == DISQPV_TYPE_ADDRESS)
         {
 #endif
@@ -1535,10 +1535,10 @@
             switch(param1.type)
             {
-            case PARMTYPE_IMMEDIATE:
-                if(!(param1.flags  & (PARAM_VAL32|PARAM_VAL64)))
+            case DISQPV_TYPE_IMMEDIATE:
+                if(!(param1.flags  & (DISQPV_FLAG_32|DISQPV_FLAG_64)))
                     return VERR_EM_INTERPRETER;
                 /* fallthru */
 
-            case PARMTYPE_ADDRESS:
+            case DISQPV_TYPE_ADDRESS:
                 pDest = (RTGCPTR)param1.val.val64;
                 pDest = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, pDest);
@@ -1552,5 +1552,5 @@
             switch(param2.type)
             {
-            case PARMTYPE_IMMEDIATE: /* register type is translated to this one too */
+            case DISQPV_TYPE_IMMEDIATE: /* register type is translated to this one too */
                 val64 = param2.val.val64;
                 break;
@@ -1583,10 +1583,10 @@
             switch(param2.type)
             {
-            case PARMTYPE_IMMEDIATE:
-                if(!(param2.flags & (PARAM_VAL32|PARAM_VAL64)))
+            case DISQPV_TYPE_IMMEDIATE:
+                if(!(param2.flags & (DISQPV_FLAG_32|DISQPV_FLAG_64)))
                     return VERR_EM_INTERPRETER;
                 /* fallthru */
 
-            case PARMTYPE_ADDRESS:
+            case DISQPV_TYPE_ADDRESS:
                 pSrc = (RTGCPTR)param2.val.val64;
                 pSrc = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param2, pSrc);
@@ -1606,5 +1606,5 @@
             switch(param1.type)
             {
-            case PARMTYPE_REGISTER:
+            case DISQPV_TYPE_REGISTER:
                 switch(param1.size)
                 {
@@ -1799,5 +1799,5 @@
 static int emInterpretCmpXchg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
 {
-    OP_PARAMVAL param1, param2;
+    DISQPVPARAMVAL param1, param2;
     NOREF(pvFault);
 
@@ -1807,9 +1807,9 @@
 
     /* Source to make DISQueryParamVal read the register value - ugly hack */
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
 
-    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, PARAM_SOURCE);
+    rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param2, &param2, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -1818,5 +1818,5 @@
     switch(param2.type)
     {
-    case PARMTYPE_IMMEDIATE: /* register actually */
+    case DISQPV_TYPE_IMMEDIATE: /* register actually */
         valpar = param2.val.val64;
         break;
@@ -1834,5 +1834,5 @@
     switch(param1.type)
     {
-    case PARMTYPE_ADDRESS:
+    case DISQPV_TYPE_ADDRESS:
         GCPtrPar1 = param1.val.val64;
         GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
@@ -1871,9 +1871,9 @@
 {
     Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     NOREF(pvFault);
 
     /* Source to make DISQueryParamVal read the register value - ugly hack */
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -1887,5 +1887,5 @@
     switch(param1.type)
     {
-    case PARMTYPE_ADDRESS:
+    case DISQPV_TYPE_ADDRESS:
         GCPtrPar1 = param1.val.val64;
         GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
@@ -1925,5 +1925,5 @@
 {
     Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     void *pvParamReg2;
     size_t cbParamReg2;
@@ -1931,5 +1931,5 @@
 
     /* Source to make DISQueryParamVal read the register value - ugly hack */
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -1954,5 +1954,5 @@
             switch(param1.type)
             {
-            case PARMTYPE_ADDRESS:
+            case DISQPV_TYPE_ADDRESS:
                 GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, (RTRCUINTPTR)param1.val.val64);
 #ifdef IN_RC
@@ -2050,9 +2050,9 @@
 static VBOXSTRICTRC emInterpretInvlPg(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
 {
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     RTGCPTR     addr;
     NOREF(pvFault); NOREF(pVM); NOREF(pcbSize);
 
-    VBOXSTRICTRC rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
+    VBOXSTRICTRC rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -2060,7 +2060,7 @@
     switch(param1.type)
     {
-    case PARMTYPE_IMMEDIATE:
-    case PARMTYPE_ADDRESS:
-        if(!(param1.flags  & (PARAM_VAL32|PARAM_VAL64)))
+    case DISQPV_TYPE_IMMEDIATE:
+    case DISQPV_TYPE_ADDRESS:
+        if(!(param1.flags  & (DISQPV_FLAG_32|DISQPV_FLAG_64)))
             return VERR_EM_INTERPRETER;
         addr = (RTGCPTR)param1.val.val64;
@@ -2385,9 +2385,9 @@
 static int emInterpretLmsw(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
 {
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     uint32_t    val;
     NOREF(pvFault); NOREF(pcbSize);
 
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -2395,7 +2395,7 @@
     switch(param1.type)
     {
-    case PARMTYPE_IMMEDIATE:
-    case PARMTYPE_ADDRESS:
-        if(!(param1.flags  & PARAM_VAL16))
+    case DISQPV_TYPE_IMMEDIATE:
+    case DISQPV_TYPE_ADDRESS:
+        if(!(param1.flags  & DISQPV_FLAG_16))
             return VERR_EM_INTERPRETER;
         val = param1.val.val32;
@@ -2416,8 +2416,8 @@
 static int emInterpretSmsw(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
 {
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     uint64_t    cr0 = CPUMGetGuestCR0(pVCpu);
 
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -2425,5 +2425,5 @@
     switch(param1.type)
     {
-    case PARMTYPE_IMMEDIATE:
+    case DISQPV_TYPE_IMMEDIATE:
         if(param1.size != sizeof(uint16_t))
             return VERR_EM_INTERPRETER;
@@ -2432,5 +2432,5 @@
         break;
 
-    case PARMTYPE_ADDRESS:
+    case DISQPV_TYPE_ADDRESS:
     {
         RTGCPTR pParam1;
@@ -2579,9 +2579,9 @@
 static int emInterpretLLdt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
 {
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     RTSEL       sel;
     NOREF(pVM); NOREF(pvFault); NOREF(pcbSize);
 
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -2589,9 +2589,9 @@
     switch(param1.type)
     {
-    case PARMTYPE_ADDRESS:
+    case DISQPV_TYPE_ADDRESS:
         return VERR_EM_INTERPRETER; //feeling lazy right now
 
-    case PARMTYPE_IMMEDIATE:
-        if(!(param1.flags  & PARAM_VAL16))
+    case DISQPV_TYPE_IMMEDIATE:
+        if(!(param1.flags  & DISQPV_FLAG_16))
             return VERR_EM_INTERPRETER;
         sel = (RTSEL)param1.val.val16;
@@ -2627,5 +2627,5 @@
 static int emInterpretLIGdt(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
 {
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     RTGCPTR     pParam1;
     X86XDTR32   dtr32;
@@ -2637,5 +2637,5 @@
     AssertReturn(CPUMIsGuestInRealMode(pVCpu), VERR_EM_INTERPRETER);
 
-    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, PARAM_SOURCE);
+    int rc = DISQueryParamVal(pRegFrame, pDis, &pDis->param1, &param1, DISQPVWHICH_SRC);
     if(RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
@@ -2643,5 +2643,5 @@
     switch(param1.type)
     {
-    case PARMTYPE_ADDRESS:
+    case DISQPV_TYPE_ADDRESS:
         pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, param1.val.val16);
         break;
Index: /trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp	(revision 41728)
+++ /trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp	(revision 41729)
@@ -2919,17 +2919,17 @@
 static int hmR0svmInterpretInvlPg(PVMCPU pVCpu, PDISCPUSTATE pCpu, PCPUMCTXCORE pRegFrame, uint32_t uASID)
 {
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     RTGCPTR     addr;
     NOREF(uASID);
 
-    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, PARAM_SOURCE);
-    if(RT_FAILURE(rc))
+    int rc = DISQueryParamVal(pRegFrame, pCpu, &pCpu->param1, &param1, DISQPVWHICH_SRC);
+    if (RT_FAILURE(rc))
         return VERR_EM_INTERPRETER;
 
-    switch(param1.type)
-    {
-        case PARMTYPE_IMMEDIATE:
-        case PARMTYPE_ADDRESS:
-            if(!(param1.flags & (PARAM_VAL32|PARAM_VAL64)))
+    switch (param1.type)
+    {
+        case DISQPV_TYPE_IMMEDIATE:
+        case DISQPV_TYPE_ADDRESS:
+            if (!(param1.flags & (DISQPV_FLAG_32 | DISQPV_FLAG_64)))
                 return VERR_EM_INTERPRETER;
             addr = param1.val.val64;