Changeset 41729 in vbox

Timestamp:

Jun 14, 2012 11:24:17 PM (13 years ago)

Author:

vboxsync

Message:

DISQueryParamVal: renamed related types and constants and reduced the param structure by 8-12 bytes.

Location:

trunk

Files:

• include/VBox/dis.h (modified) (3 diffs)
• src/VBox/Disassembler/DisasmReg.cpp (modified) (20 diffs)
• src/VBox/VMM/VMMAll/EMAll.cpp (modified) (50 diffs)
• src/VBox/VMM/VMMR0/HWSVMR0.cpp (modified) (1 diff)

trunk/include/VBox/dis.h

@@ -382 +382 @@
 /** @}  */
 
-/** 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 +416 @@
     } 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 +653 @@
 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);
 

trunk/src/VBox/Disassembler/DisasmReg.cpp

@@ -500 +500 @@
  *
  */
-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 +507 @@
     {
         // Effective address
-        pParamVal->type = PARMTYPE_ADDRESS;
+        pParamVal->type = DISQPV_TYPE_ADDRESS;
         pParamVal->size = pParam->cb;
 
@@ -514 +514 @@
             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 +520 @@
             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 +526 @@
             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 +532 @@
             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 +548 @@
                 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 +560 @@
                 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 +573 @@
                 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 +632 @@
     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 +652 @@
         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 +659 @@
         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 +666 @@
         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 +673 @@
         {
             // 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 +681 @@
     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 +699 @@
         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 +707 @@
         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 +715 @@
         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 +723 @@
         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 +732 @@
         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);

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

@@ -805 +805 @@
 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 +829 @@
             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 +852 @@
             switch(param2.type)
             {
-            case PARMTYPE_ADDRESS:
+            case DISQPV_TYPE_ADDRESS:
                 pParam2 = (RTGCPTR)param2.val.val64;
                 pParam2 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param2, pParam2);
@@ -863 +863 @@
                 break;
 
-            case PARMTYPE_IMMEDIATE:
+            case DISQPV_TYPE_IMMEDIATE:
                 valpar2 = param2.val.val64;
                 break;
@@ -875 +875 @@
             if (pParam1 == 0)
             {
-                Assert(param1.type == PARMTYPE_IMMEDIATE); /* register actually */
+                Assert(param1.type == DISQPV_TYPE_IMMEDIATE); /* register actually */
                 switch(param1.size)
                 {
@@ -901 +901 @@
             if (pParam2 == 0)
             {
-                Assert(param2.type == PARMTYPE_IMMEDIATE); /* register actually */
+                Assert(param2.type == DISQPV_TYPE_IMMEDIATE); /* register actually */
                 switch(param2.size)
                 {
@@ -940 +940 @@
                              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 +956 @@
             uint64_t valpar1;
 
-            if (param1.type == PARMTYPE_ADDRESS)
+            if (param1.type == DISQPV_TYPE_ADDRESS)
             {
                 pParam1 = (RTGCPTR)param1.val.val64;
@@ -1010 +1010 @@
 {
     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 +1043 @@
             }
 
-            if (param1.type == PARMTYPE_ADDRESS)
+            if (param1.type == DISQPV_TYPE_ADDRESS)
             {
                 pParam1 = (RTGCPTR)param1.val.val64;
@@ -1092 +1092 @@
                                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 +1125 @@
 
             /* The destination is always a virtual address */
-            if (param1.type == PARMTYPE_ADDRESS)
+            if (param1.type == DISQPV_TYPE_ADDRESS)
             {
                 pParam1 = (RTGCPTR)param1.val.val64;
@@ -1146 +1146 @@
             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 +1189 @@
 {
     void *pvParam1;
-    OP_PARAMVAL param1, param2;
+    DISQPVPARAMVAL param1, param2;
     NOREF(pvFault);
 
@@ -1196 +1196 @@
 #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 +1222 @@
 #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 +1263 @@
 {
     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 +1294 @@
 
             /* The destination is always a virtual address */
-            if (param1.type == PARMTYPE_ADDRESS)
+            if (param1.type == DISQPV_TYPE_ADDRESS)
             {
                 pParam1 = (RTGCPTR)param1.val.val64;
@@ -1317 +1317 @@
             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 +1367 @@
                               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 +1387 @@
 
             /* The destination is always a virtual address */
-            if (param1.type != PARMTYPE_ADDRESS)
+            if (param1.type != DISQPV_TYPE_ADDRESS)
                 return VERR_EM_INTERPRETER;
 
@@ -1396 +1396 @@
             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 +1449 @@
     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 +1511 @@
 {
     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 +1527 @@
 #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 +1535 @@
             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 +1552 @@
             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 +1583 @@
             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 +1606 @@
             switch(param1.type)
             {
-            case PARMTYPE_REGISTER:
+            case DISQPV_TYPE_REGISTER:
                 switch(param1.size)
                 {
@@ -1799 +1799 @@
 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 +1807 @@
 
     /* 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 +1818 @@
     switch(param2.type)
     {
-    case PARMTYPE_IMMEDIATE: /* register actually */
+    case DISQPV_TYPE_IMMEDIATE: /* register actually */
         valpar = param2.val.val64;
         break;
@@ -1834 +1834 @@
     switch(param1.type)
     {
-    case PARMTYPE_ADDRESS:
+    case DISQPV_TYPE_ADDRESS:
         GCPtrPar1 = param1.val.val64;
         GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
@@ -1871 +1871 @@
 {
     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 +1887 @@
     switch(param1.type)
     {
-    case PARMTYPE_ADDRESS:
+    case DISQPV_TYPE_ADDRESS:
         GCPtrPar1 = param1.val.val64;
         GCPtrPar1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, GCPtrPar1);
@@ -1925 +1925 @@
 {
     Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
-    OP_PARAMVAL param1;
+    DISQPVPARAMVAL param1;
     void *pvParamReg2;
     size_t cbParamReg2;
@@ -1931 +1931 @@
 
     /* 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 +1954 @@
             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 +2050 @@
 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 +2060 @@
     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 +2385 @@
 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 +2395 @@
     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 +2416 @@
 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 +2425 @@
     switch(param1.type)
     {
-    case PARMTYPE_IMMEDIATE:
+    case DISQPV_TYPE_IMMEDIATE:
         if(param1.size != sizeof(uint16_t))
             return VERR_EM_INTERPRETER;
@@ -2432 +2432 @@
         break;
 
-    case PARMTYPE_ADDRESS:
+    case DISQPV_TYPE_ADDRESS:
     {
         RTGCPTR pParam1;
@@ -2579 +2579 @@
 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 +2589 @@
     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 +2627 @@
 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 +2637 @@
     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 +2643 @@
     switch(param1.type)
     {
-    case PARMTYPE_ADDRESS:
+    case DISQPV_TYPE_ADDRESS:
         pParam1 = emConvertToFlatAddr(pVM, pRegFrame, pDis, &pDis->param1, param1.val.val16);
         break;

trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp

@@ -2919 +2919 @@
 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;