Changeset 41678 in vbox for trunk/src/VBox/Disassembler

Timestamp:

Jun 13, 2012 9:37:47 AM (12 years ago)

Author:

vboxsync

Message:

OP_PARAMETER::flags -> fUse.

Location:

trunk/src/VBox/Disassembler

Files:

• DisasmCore.cpp (modified) (60 diffs)
• DisasmFormatYasm.cpp (modified) (22 diffs)
• DisasmReg.cpp (modified) (28 diffs)

trunk/src/VBox/Disassembler/DisasmCore.cpp

@@ -616 +616 @@
     if (ppszSIBIndexReg[index])
     {
-         pParam->flags |= DISUSE_INDEX | regtype;
+         pParam->fUse |= DISUSE_INDEX | regtype;
          pParam->index.reg_gen = index;
 
          if (scale != 0)
          {
-             pParam->flags |= DISUSE_SCALE;
+             pParam->fUse |= DISUSE_SCALE;
              pParam->scale  = (1<<scale);
          }
@@ -631 +631 @@
         if (pCpu->addrmode == DISCPUMODE_32BIT)
         {
-            pParam->flags |= DISUSE_DISPLACEMENT32;
+            pParam->fUse |= DISUSE_DISPLACEMENT32;
             pParam->uDisp.i32 = pCpu->i32SibDisp;
         }
         else
         {   /* sign-extend to 64 bits */
-            pParam->flags |= DISUSE_DISPLACEMENT64;
+            pParam->fUse |= DISUSE_DISPLACEMENT64;
             pParam->uDisp.i64 = pCpu->i32SibDisp;
         }
@@ -642 +642 @@
     else
     {
-        pParam->flags |= DISUSE_BASE | regtype;
+        pParam->fUse |= DISUSE_BASE | regtype;
         pParam->base.reg_gen = base;
     }
@@ -735 +735 @@
             {
             case OP_PARM_C: //control register
-                pParam->flags |= DISUSE_REG_CR;
+                pParam->fUse |= DISUSE_REG_CR;
 
                 if (    pCpu->pCurInstr->opcode == OP_MOV_CR
@@ -749 +749 @@
 
             case OP_PARM_D: //debug register
-                pParam->flags |= DISUSE_REG_DBG;
+                pParam->fUse |= DISUSE_REG_DBG;
                 pParam->base.reg_dbg = reg;
                 return 0;
@@ -755 +755 @@
             case OP_PARM_P: //MMX register
                 reg &= 7;   /* REX.R has no effect here */
-                pParam->flags |= DISUSE_REG_MMX;
+                pParam->fUse |= DISUSE_REG_MMX;
                 pParam->base.reg_mmx = reg;
                 return 0;
@@ -762 +762 @@
                 reg &= 7;   /* REX.R has no effect here */
                 disasmModRMSReg(pCpu, pOp, reg, pParam);
-                pParam->flags |= DISUSE_REG_SEG;
+                pParam->fUse |= DISUSE_REG_SEG;
                 return 0;
 
             case OP_PARM_T: //test register
                 reg &= 7;   /* REX.R has no effect here */
-                pParam->flags |= DISUSE_REG_TEST;
+                pParam->fUse |= DISUSE_REG_TEST;
                 pParam->base.reg_test = reg;
                 return 0;
@@ -778 +778 @@
 
             case OP_PARM_V: //XMM register
-                pParam->flags |= DISUSE_REG_XMM;
+                pParam->fUse |= DISUSE_REG_XMM;
                 pParam->base.reg_xmm = reg;
                 return 0;
@@ -807 +807 @@
                 if (pCpu->mode != DISCPUMODE_64BIT)
                 {
-                    pParam->flags |= DISUSE_DISPLACEMENT32;
+                    pParam->fUse |= DISUSE_DISPLACEMENT32;
                     pParam->uDisp.i32 = pCpu->i32SibDisp;
                 }
                 else
                 {
-                    pParam->flags |= DISUSE_RIPDISPLACEMENT32;
+                    pParam->fUse |= DISUSE_RIPDISPLACEMENT32;
                     pParam->uDisp.i32 = pCpu->i32SibDisp;
                 }
@@ -818 +818 @@
             else
             {   //register address
-                pParam->flags |= DISUSE_BASE;
+                pParam->fUse |= DISUSE_BASE;
                 disasmModRMReg(pCpu, pOp, rm, pParam, 1);
             }
@@ -829 +829 @@
             else
             {
-                pParam->flags |= DISUSE_BASE;
+                pParam->fUse |= DISUSE_BASE;
                 disasmModRMReg(pCpu, pOp, rm, pParam, 1);
             }
             pParam->uDisp.i8 = pCpu->i32SibDisp;
-            pParam->flags |= DISUSE_DISPLACEMENT8;
+            pParam->fUse |= DISUSE_DISPLACEMENT8;
             break;
 
@@ -842 +842 @@
             else
             {
-                pParam->flags |= DISUSE_BASE;
+                pParam->fUse |= DISUSE_BASE;
                 disasmModRMReg(pCpu, pOp, rm, pParam, 1);
             }
             pParam->uDisp.i32 = pCpu->i32SibDisp;
-            pParam->flags |= DISUSE_DISPLACEMENT32;
+            pParam->fUse |= DISUSE_DISPLACEMENT32;
             break;
 
@@ -862 +862 @@
             {//16 bits displacement
                 pParam->uDisp.i16 = pCpu->i32SibDisp;
-                pParam->flags |= DISUSE_DISPLACEMENT16;
+                pParam->fUse |= DISUSE_DISPLACEMENT16;
             }
             else
             {
-                pParam->flags |= DISUSE_BASE;
+                pParam->fUse |= DISUSE_BASE;
                 disasmModRMReg16(pCpu, pOp, rm, pParam);
             }
@@ -874 +874 @@
             disasmModRMReg16(pCpu, pOp, rm, pParam);
             pParam->uDisp.i8 = pCpu->i32SibDisp;
-            pParam->flags |= DISUSE_BASE | DISUSE_DISPLACEMENT8;
+            pParam->fUse |= DISUSE_BASE | DISUSE_DISPLACEMENT8;
             break;
 
@@ -880 +880 @@
             disasmModRMReg16(pCpu, pOp, rm, pParam);
             pParam->uDisp.i16 = pCpu->i32SibDisp;
-            pParam->flags |= DISUSE_BASE | DISUSE_DISPLACEMENT16;
+            pParam->fUse |= DISUSE_BASE | DISUSE_DISPLACEMENT16;
             break;
 
@@ -1165 +1165 @@
     NOREF(pOp);
     pParam->parval = DISReadByte(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_IMMEDIATE8;
+    pParam->fUse  |= DISUSE_IMMEDIATE8;
     pParam->cb     = sizeof(uint8_t);
     return sizeof(uint8_t);
@@ -1184 +1184 @@
     {
         pParam->parval = (uint32_t)(int8_t)DISReadByte(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE32_SX8;
+        pParam->fUse  |= DISUSE_IMMEDIATE32_SX8;
         pParam->cb     = sizeof(uint32_t);
     }
@@ -1191 +1191 @@
     {
         pParam->parval = (uint64_t)(int8_t)DISReadByte(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE64_SX8;
+        pParam->fUse  |= DISUSE_IMMEDIATE64_SX8;
         pParam->cb     = sizeof(uint64_t);
     }
@@ -1197 +1197 @@
     {
         pParam->parval = (uint16_t)(int8_t)DISReadByte(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE16_SX8;
+        pParam->fUse  |= DISUSE_IMMEDIATE16_SX8;
         pParam->cb     = sizeof(uint16_t);
     }
@@ -1215 +1215 @@
     NOREF(pOp);
     pParam->parval = DISReadWord(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_IMMEDIATE16;
+    pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
     return sizeof(uint16_t);
@@ -1232 +1232 @@
     NOREF(pOp);
     pParam->parval = DISReadDWord(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_IMMEDIATE32;
+    pParam->fUse  |= DISUSE_IMMEDIATE32;
     pParam->cb     = sizeof(uint32_t);
     return sizeof(uint32_t);
@@ -1249 +1249 @@
     NOREF(pOp);
     pParam->parval = DISReadQWord(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_IMMEDIATE64;
+    pParam->fUse  |= DISUSE_IMMEDIATE64;
     pParam->cb     = sizeof(uint64_t);
     return sizeof(uint64_t);
@@ -1268 +1268 @@
     {
         pParam->parval = DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE32;
+        pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
         return sizeof(uint32_t);
@@ -1276 +1276 @@
     {
         pParam->parval = DISReadQWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE64;
+        pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
         return sizeof(uint64_t);
@@ -1282 +1282 @@
 
     pParam->parval = DISReadWord(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_IMMEDIATE16;
+    pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
     return sizeof(uint16_t);
@@ -1306 +1306 @@
     {
         pParam->parval = DISReadWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE16;
+        pParam->fUse  |= DISUSE_IMMEDIATE16;
         pParam->cb     = sizeof(uint16_t);
         return sizeof(uint16_t);
@@ -1315 +1315 @@
     {
         pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE64;
+        pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
     }
@@ -1321 +1321 @@
     {
         pParam->parval = DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE32;
+        pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
     }
@@ -1344 +1344 @@
     NOREF(pOp);
     pParam->parval = DISReadByte(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_IMMEDIATE8_REL;
+    pParam->fUse  |= DISUSE_IMMEDIATE8_REL;
     pParam->cb     = sizeof(uint8_t);
     return sizeof(char);
@@ -1365 +1365 @@
     {
         pParam->parval = DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE32_REL;
+        pParam->fUse  |= DISUSE_IMMEDIATE32_REL;
         pParam->cb     = sizeof(int32_t);
         return sizeof(int32_t);
@@ -1374 +1374 @@
         /* 32 bits relative immediate sign extended to 64 bits. */
         pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE64_REL;
+        pParam->fUse  |= DISUSE_IMMEDIATE64_REL;
         pParam->cb     = sizeof(int64_t);
         return sizeof(int32_t);
@@ -1380 +1380 @@
 
     pParam->parval = DISReadWord(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_IMMEDIATE16_REL;
+    pParam->fUse  |= DISUSE_IMMEDIATE16_REL;
     pParam->cb     = sizeof(int16_t);
     return sizeof(int16_t);
@@ -1406 +1406 @@
             pParam->parval = DISReadDWord(pCpu, uCodePtr);
             *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, uCodePtr+sizeof(uint32_t));
-            pParam->flags  |= DISUSE_IMMEDIATE_ADDR_16_32;
+            pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
             pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
             return sizeof(uint32_t) + sizeof(uint16_t);
@@ -1418 +1418 @@
          */
         pParam->uDisp.i32 = DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_DISPLACEMENT32;
+        pParam->fUse  |= DISUSE_DISPLACEMENT32;
         pParam->cb     = sizeof(uint32_t);
         return sizeof(uint32_t);
@@ -1433 +1433 @@
          */
         pParam->uDisp.i64 = DISReadQWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_DISPLACEMENT64;
+        pParam->fUse  |= DISUSE_DISPLACEMENT64;
         pParam->cb     = sizeof(uint64_t);
         return sizeof(uint64_t);
@@ -1441 +1441 @@
         /* far 16:16 pointer */
         pParam->parval = DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE_ADDR_16_16;
+        pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
         pParam->cb     = 2*sizeof(uint16_t);
         return sizeof(uint32_t);
@@ -1453 +1453 @@
      */
     pParam->uDisp.i16 = DISReadWord(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_DISPLACEMENT16;
+    pParam->fUse  |= DISUSE_DISPLACEMENT16;
     pParam->cb     = sizeof(uint16_t);
     return sizeof(uint16_t);
@@ -1502 +1502 @@
         pParam->parval = DISReadDWord(pCpu, uCodePtr);
         *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, uCodePtr+sizeof(uint32_t));
-        pParam->flags  |= DISUSE_IMMEDIATE_ADDR_16_32;
+        pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
         pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
         return sizeof(uint32_t) + sizeof(uint16_t);
@@ -1509 +1509 @@
     // far 16:16 pointer
     pParam->parval = DISReadDWord(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_IMMEDIATE_ADDR_16_16;
+    pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
     pParam->cb     = 2*sizeof(uint16_t);
     return sizeof(uint32_t);
@@ -1560 +1560 @@
             /* Use 32-bit registers. */
             pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN32_START;
-            pParam->flags |= DISUSE_REG_GEN32;
+            pParam->fUse  |= DISUSE_REG_GEN32;
             pParam->cb     = 4;
         }
@@ -1574 +1574 @@
                 pParam->base.reg_gen += 8;
 
-            pParam->flags |= DISUSE_REG_GEN64;
+            pParam->fUse  |= DISUSE_REG_GEN64;
             pParam->cb     = 8;
         }
@@ -1581 +1581 @@
             /* Use 16-bit registers. */
             pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN32_START;
-            pParam->flags |= DISUSE_REG_GEN16;
+            pParam->fUse  |= DISUSE_REG_GEN16;
             pParam->cb     = 2;
             pParam->param = pParam->param - OP_PARM_REG_GEN32_START + OP_PARM_REG_GEN16_START;
@@ -1591 +1591 @@
         /* Segment ES..GS registers. */
         pParam->base.reg_seg = (DIS_SELREG)(pParam->param - OP_PARM_REG_SEG_START);
-        pParam->flags |= DISUSE_REG_SEG;
+        pParam->fUse  |= DISUSE_REG_SEG;
         pParam->cb     = 2;
     }
@@ -1599 +1599 @@
         /* 16-bit AX..DI registers. */
         pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN16_START;
-        pParam->flags |= DISUSE_REG_GEN16;
+        pParam->fUse  |= DISUSE_REG_GEN16;
         pParam->cb     = 2;
     }
@@ -1607 +1607 @@
         /* 8-bit AL..DL, AH..DH registers. */
         pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN8_START;
-        pParam->flags |= DISUSE_REG_GEN8;
+        pParam->fUse  |= DISUSE_REG_GEN8;
         pParam->cb     = 1;
 
@@ -1624 +1624 @@
         /* FPU registers. */
         pParam->base.reg_fp = pParam->param - OP_PARM_REG_FP_START;
-        pParam->flags |= DISUSE_REG_FP;
+        pParam->fUse  |= DISUSE_REG_FP;
         pParam->cb     = 10;
     }
@@ -1639 +1639 @@
     NOREF(uCodePtr);
 
-    pParam->flags |= DISUSE_POINTER_DS_BASED;
+    pParam->fUse |= DISUSE_POINTER_DS_BASED;
     if (pCpu->addrmode == DISCPUMODE_32BIT)
     {
         pParam->base.reg_gen = USE_REG_ESI;
-        pParam->flags |= DISUSE_REG_GEN32;
+        pParam->fUse |= DISUSE_REG_GEN32;
     }
     else
@@ -1649 +1649 @@
     {
         pParam->base.reg_gen = USE_REG_RSI;
-        pParam->flags |= DISUSE_REG_GEN64;
+        pParam->fUse |= DISUSE_REG_GEN64;
     }
     else
     {
         pParam->base.reg_gen = USE_REG_SI;
-        pParam->flags |= DISUSE_REG_GEN16;
+        pParam->fUse |= DISUSE_REG_GEN16;
     }
     return 0;   //no additional opcode bytes
@@ -1664 +1664 @@
     NOREF(uCodePtr); NOREF(pOp);
 
-    pParam->flags |= DISUSE_POINTER_DS_BASED;
+    pParam->fUse |= DISUSE_POINTER_DS_BASED;
     if (pCpu->addrmode == DISCPUMODE_32BIT)
     {
         pParam->base.reg_gen = USE_REG_ESI;
-        pParam->flags |= DISUSE_REG_GEN32;
+        pParam->fUse |= DISUSE_REG_GEN32;
     }
     else
@@ -1674 +1674 @@
     {
         pParam->base.reg_gen = USE_REG_RSI;
-        pParam->flags |= DISUSE_REG_GEN64;
+        pParam->fUse |= DISUSE_REG_GEN64;
     }
     else
     {
         pParam->base.reg_gen = USE_REG_SI;
-        pParam->flags |= DISUSE_REG_GEN16;
+        pParam->fUse |= DISUSE_REG_GEN16;
     }
     return 0;   //no additional opcode bytes
@@ -1689 +1689 @@
     NOREF(uCodePtr);
 
-    pParam->flags |= DISUSE_POINTER_ES_BASED;
+    pParam->fUse |= DISUSE_POINTER_ES_BASED;
     if (pCpu->addrmode == DISCPUMODE_32BIT)
     {
         pParam->base.reg_gen = USE_REG_EDI;
-        pParam->flags |= DISUSE_REG_GEN32;
+        pParam->fUse |= DISUSE_REG_GEN32;
     }
     else
@@ -1699 +1699 @@
     {
         pParam->base.reg_gen = USE_REG_RDI;
-        pParam->flags |= DISUSE_REG_GEN64;
+        pParam->fUse |= DISUSE_REG_GEN64;
     }
     else
     {
         pParam->base.reg_gen = USE_REG_DI;
-        pParam->flags |= DISUSE_REG_GEN16;
+        pParam->fUse |= DISUSE_REG_GEN16;
     }
     return 0;   //no additional opcode bytes
@@ -1714 +1714 @@
     NOREF(uCodePtr); NOREF(pOp);
 
-    pParam->flags |= DISUSE_POINTER_ES_BASED;
+    pParam->fUse |= DISUSE_POINTER_ES_BASED;
     if (pCpu->addrmode == DISCPUMODE_32BIT)
     {
         pParam->base.reg_gen = USE_REG_EDI;
-        pParam->flags |= DISUSE_REG_GEN32;
+        pParam->fUse |= DISUSE_REG_GEN32;
     }
     else
@@ -1724 +1724 @@
     {
         pParam->base.reg_gen = USE_REG_RDI;
-        pParam->flags |= DISUSE_REG_GEN64;
+        pParam->fUse |= DISUSE_REG_GEN64;
     }
     else
     {
         pParam->base.reg_gen = USE_REG_DI;
-        pParam->flags |= DISUSE_REG_GEN16;
+        pParam->fUse |= DISUSE_REG_GEN16;
     }
     return 0;   //no additional opcode bytes
@@ -2341 +2341 @@
         }
 
-        pParam->flags |= DISUSE_REG_GEN8;
+        pParam->fUse |= DISUSE_REG_GEN8;
         pParam->base.reg_gen = idx;
         break;
@@ -2348 +2348 @@
         Assert(idx < (pCpu->prefix & DISPREFIX_REX) ? 16 : 8);
 
-        pParam->flags |= DISUSE_REG_GEN16;
+        pParam->fUse |= DISUSE_REG_GEN16;
         pParam->base.reg_gen = idx;
         break;
@@ -2355 +2355 @@
         Assert(idx < (pCpu->prefix & DISPREFIX_REX) ? 16 : 8);
 
-        pParam->flags |= DISUSE_REG_GEN32;
+        pParam->fUse |= DISUSE_REG_GEN32;
         pParam->base.reg_gen = idx;
         break;
 
     case OP_PARM_q:
-        pParam->flags |= DISUSE_REG_GEN64;
+        pParam->fUse |= DISUSE_REG_GEN64;
         pParam->base.reg_gen = idx;
         break;
@@ -2375 +2375 @@
 {
     NOREF(pCpu); NOREF(pOp);
-    pParam->flags |= DISUSE_REG_GEN16;
+    pParam->fUse |= DISUSE_REG_GEN16;
     pParam->base.reg_gen = BaseModRMReg16[idx];
     if (idx < 4)
     {
-        pParam->flags |= DISUSE_INDEX;
+        pParam->fUse |= DISUSE_INDEX;
         pParam->index.reg_gen = IndexModRMReg16[idx];
     }
@@ -2395 +2395 @@
     }
 
-    pParam->flags |= DISUSE_REG_SEG;
+    pParam->fUse |= DISUSE_REG_SEG;
     pParam->base.reg_seg = (DIS_SELREG)idx;
 }
@@ -2655 +2655 @@
         case OP_XCHG:
         case OP_XOR:
-            if (pCpu->param1.flags & (DISUSE_BASE | DISUSE_INDEX | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT8 | DISUSE_RIPDISPLACEMENT32))
+            if (pCpu->param1.fUse & (DISUSE_BASE | DISUSE_INDEX | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32
+                                     | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT8 | DISUSE_RIPDISPLACEMENT32))
                 return;
             break;

trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp

@@ -93 +93 @@
 static const char *disasmFormatYasmBaseReg(PCDISCPUSTATE pCpu, PCOP_PARAMETER pParam, size_t *pcchReg)
 {
-    switch (pParam->flags & (  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))
+    switch (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))
 
     {
@@ -187 +187 @@
 
         default:
-            AssertMsgFailed(("%#x\n", pParam->flags));
+            AssertMsgFailed(("%#x\n", pParam->fUse));
             *pcchReg = 3;
             return "r??";
@@ -231 +231 @@
 
         default:
-            AssertMsgFailed(("%#x %#x\n", pParam->flags, pCpu->addrmode));
+            AssertMsgFailed(("%#x %#x\n", pParam->fUse, pCpu->addrmode));
             *pcchReg = 3;
             return "r??";
@@ -591 +591 @@
                         break; \
                     case OP_PARM_p: break; /* see PUT_FAR */ \
-                    case OP_PARM_s: if (pParam->flags & DISUSE_REG_FP) PUT_SZ("tword "); break; /* ?? */ \
+                    case OP_PARM_s: if (pParam->fUse & DISUSE_REG_FP) PUT_SZ("tword "); break; /* ?? */ \
                     case OP_PARM_z: break; \
                     case OP_PARM_NONE: \
                         if (    OP_PARM_VTYPE(pParam->param) == OP_PARM_M \
-                            &&  ((pParam->flags & DISUSE_REG_FP) || pOp->opcode == OP_FLD)) \
+                            &&  ((pParam->fUse & DISUSE_REG_FP) || pOp->opcode == OP_FLD)) \
                             PUT_SZ("tword "); \
                         break; \
@@ -613 +613 @@
          */
         if (    (pCpu->prefix & DISPREFIX_SEG)
-            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.flags)
-            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.flags)
-            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param3.flags))
+            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.fUse)
+            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.fUse)
+            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param3.fUse))
         {
             PUT_STR(s_szSegPrefix[pCpu->enmPrefixSeg], 2);
@@ -647 +647 @@
                     {
                         pszFmt += RT_C_IS_ALPHA(pszFmt[0]) ? RT_C_IS_ALPHA(pszFmt[1]) ? 2 : 1 : 0;
-                        Assert(!(pParam->flags & (DISUSE_INDEX | DISUSE_SCALE) /* No SIB here... */));
-                        Assert(!(pParam->flags & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32)));
+                        Assert(!(pParam->fUse & (DISUSE_INDEX | DISUSE_SCALE) /* No SIB here... */));
+                        Assert(!(pParam->fUse & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32)));
 
                         size_t cchReg;
@@ -668 +668 @@
 
                         PUT_FAR();
-                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->flags))
+                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse))
                         {
                             /* Work around mov seg,[mem16]  and mov [mem16],seg as these always make a 16-bit mem
@@ -680 +680 @@
                         }
                         if (    (fFlags & DIS_FMT_FLAGS_STRICT)
-                            &&  (pParam->flags & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32)))
+                            &&  (pParam->fUse & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32)))
                         {
-                            if (   (pParam->flags & DISUSE_DISPLACEMENT8)
+                            if (   (pParam->fUse & DISUSE_DISPLACEMENT8)
                                 && !pParam->uDisp.i8)
                                 PUT_SZ("byte ");
-                            else if (   (pParam->flags & DISUSE_DISPLACEMENT16)
+                            else if (   (pParam->fUse & DISUSE_DISPLACEMENT16)
                                      && (int8_t)pParam->uDisp.i16 == (int16_t)pParam->uDisp.i16)
                                 PUT_SZ("word ");
-                            else if (   (pParam->flags & DISUSE_DISPLACEMENT32)
+                            else if (   (pParam->fUse & DISUSE_DISPLACEMENT32)
                                      && (int16_t)pParam->uDisp.i32 == (int32_t)pParam->uDisp.i32) //??
                                 PUT_SZ("dword ");
-                            else if (   (pParam->flags & DISUSE_DISPLACEMENT64)
+                            else if (   (pParam->fUse & DISUSE_DISPLACEMENT64)
                                      && (pCpu->SIB.Bits.Base != 5 || pCpu->ModRM.Bits.Mod != 0)
                                      && (int32_t)pParam->uDisp.i64 == (int64_t)pParam->uDisp.i64) //??
                                 PUT_SZ("qword ");
                         }
-                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->flags))
+                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse))
                             PUT_SEGMENT_OVERRIDE();
 
-                        bool fBase =  (pParam->flags & DISUSE_BASE) /* When exactly is DISUSE_BASE supposed to be set? disasmModRMReg doesn't set it. */
-                                   || (   (pParam->flags & (DISUSE_REG_GEN8 | DISUSE_REG_GEN16 | DISUSE_REG_GEN32 | DISUSE_REG_GEN64))
-                                       && !DISUSE_IS_EFFECTIVE_ADDR(pParam->flags));
+                        bool fBase =  (pParam->fUse & DISUSE_BASE) /* When exactly is DISUSE_BASE supposed to be set? disasmModRMReg doesn't set it. */
+                                   || (   (pParam->fUse & (DISUSE_REG_GEN8 | DISUSE_REG_GEN16 | DISUSE_REG_GEN32 | DISUSE_REG_GEN64))
+                                       && !DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse));
                         if (fBase)
                         {
@@ -709 +709 @@
                         }
 
-                        if (pParam->flags & DISUSE_INDEX)
+                        if (pParam->fUse & DISUSE_INDEX)
                         {
                             if (fBase)
@@ -718 +718 @@
                             PUT_STR(pszReg, cchReg);
 
-                            if (pParam->flags & DISUSE_SCALE)
+                            if (pParam->fUse & DISUSE_SCALE)
                             {
                                 PUT_C('*');
@@ -725 +725 @@
                         }
                         else
-                            Assert(!(pParam->flags & DISUSE_SCALE));
-
-                        if (pParam->flags & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32))
+                            Assert(!(pParam->fUse & DISUSE_SCALE));
+
+                        if (pParam->fUse & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32))
                         {
                             int64_t off2;
-                            if (pParam->flags & DISUSE_DISPLACEMENT8)
+                            if (pParam->fUse & DISUSE_DISPLACEMENT8)
                                 off2 = pParam->uDisp.i8;
-                            else if (pParam->flags & DISUSE_DISPLACEMENT16)
+                            else if (pParam->fUse & DISUSE_DISPLACEMENT16)
                                 off2 = pParam->uDisp.i16;
-                            else if (pParam->flags & (DISUSE_DISPLACEMENT32 | DISUSE_RIPDISPLACEMENT32))
+                            else if (pParam->fUse & (DISUSE_DISPLACEMENT32 | DISUSE_RIPDISPLACEMENT32))
                                 off2 = pParam->uDisp.i32;
-                            else if (pParam->flags & DISUSE_DISPLACEMENT64)
+                            else if (pParam->fUse & DISUSE_DISPLACEMENT64)
                                 off2 = pParam->uDisp.i64;
                             else
@@ -744 +744 @@
                             }
 
-                            if (fBase || (pParam->flags & DISUSE_INDEX))
+                            if (fBase || (pParam->fUse & DISUSE_INDEX))
                             {
                                 PUT_C(off2 >= 0 ? '+' : '-');
@@ -750 +750 @@
                                     off2 = -off2;
                             }
-                            if (pParam->flags & DISUSE_DISPLACEMENT8)
+                            if (pParam->fUse & DISUSE_DISPLACEMENT8)
                                 PUT_NUM_8( off2);
-                            else if (pParam->flags & DISUSE_DISPLACEMENT16)
+                            else if (pParam->fUse & DISUSE_DISPLACEMENT16)
                                 PUT_NUM_16(off2);
-                            else if (pParam->flags & DISUSE_DISPLACEMENT32)
+                            else if (pParam->fUse & DISUSE_DISPLACEMENT32)
                                 PUT_NUM_32(off2);
-                            else if (pParam->flags & DISUSE_DISPLACEMENT64)
+                            else if (pParam->fUse & DISUSE_DISPLACEMENT64)
                                 PUT_NUM_64(off2);
                             else
@@ -765 +765 @@
                         }
 
-                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->flags))
+                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse))
                             PUT_C(']');
                         break;
@@ -776 +776 @@
                     case 'I': /* Immediate data (ParseImmByte, ParseImmByteSX, ParseImmV, ParseImmUshort, ParseImmZ). */
                         Assert(*pszFmt == 'b' || *pszFmt == 'v' || *pszFmt == 'w' || *pszFmt == 'z'); pszFmt++;
-                        switch (pParam->flags & (  DISUSE_IMMEDIATE8 | DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE64
-                                                 | DISUSE_IMMEDIATE16_SX8 | DISUSE_IMMEDIATE32_SX8 | DISUSE_IMMEDIATE64_SX8))
+                        switch (pParam->fUse & (  DISUSE_IMMEDIATE8 | DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE64
+                                                | DISUSE_IMMEDIATE16_SX8 | DISUSE_IMMEDIATE32_SX8 | DISUSE_IMMEDIATE64_SX8))
                         {
                             case DISUSE_IMMEDIATE8:
@@ -862 +862 @@
                             fFlags &= ~DIS_FMT_FLAGS_RELATIVE_BRANCH;
 
-                        if (pParam->flags & DISUSE_IMMEDIATE8_REL)
+                        if (pParam->fUse & DISUSE_IMMEDIATE8_REL)
                         {
                             if (fPrefix)
@@ -872 +872 @@
                                 PUT_NUM_S8(offDisplacement);
                         }
-                        else if (pParam->flags & DISUSE_IMMEDIATE16_REL)
+                        else if (pParam->fUse & DISUSE_IMMEDIATE16_REL)
                         {
                             if (fPrefix)
@@ -887 +887 @@
                                 PUT_SZ("near ");
                             offDisplacement = (int32_t)pParam->parval;
-                            Assert(pParam->flags & (DISUSE_IMMEDIATE32_REL|DISUSE_IMMEDIATE64_REL));
+                            Assert(pParam->fUse & (DISUSE_IMMEDIATE32_REL|DISUSE_IMMEDIATE64_REL));
                             Assert(*pszFmt == 'v'); pszFmt++;
 
@@ -938 +938 @@
                         PUT_SEGMENT_OVERRIDE();
                         int rc = VERR_SYMBOL_NOT_FOUND;
-                        switch (pParam->flags & (DISUSE_IMMEDIATE_ADDR_16_16 | DISUSE_IMMEDIATE_ADDR_16_32 | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT16))
+                        switch (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_16 | DISUSE_IMMEDIATE_ADDR_16_32 | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT16))
                         {
                             case DISUSE_IMMEDIATE_ADDR_16_16:
@@ -1002 +1002 @@
                         PUT_SEGMENT_OVERRIDE();
                         int rc = VERR_SYMBOL_NOT_FOUND;
-                        switch (pParam->flags & (DISUSE_IMMEDIATE_ADDR_16_16 | DISUSE_IMMEDIATE_ADDR_16_32 | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT16))
+                        switch (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_16 | DISUSE_IMMEDIATE_ADDR_16_32 | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT16))
                         {
                             case DISUSE_IMMEDIATE_ADDR_16_16:
@@ -1066 +1066 @@
                         PUT_SIZE_OVERRIDE();
                         PUT_C('[');
-                        if (pParam->flags & DISUSE_POINTER_DS_BASED)
+                        if (pParam->fUse & DISUSE_POINTER_DS_BASED)
                             PUT_SZ("ds:");
                         else
@@ -1281 +1281 @@
         /* no effective address which it may apply to. */
         Assert((pCpu->prefix & DISPREFIX_SEG) || pCpu->mode == DISCPUMODE_64BIT);
-        if (    !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.flags)
-            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.flags)
-            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param3.flags))
+        if (    !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.fUse)
+            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.fUse)
+            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param3.fUse))
             return true;
     }

trunk/src/VBox/Disassembler/DisasmReg.cpp

@@ -268 +268 @@
     {
         /* Guess segment register by parameter type. */
-        if (pParam->flags & (DISUSE_REG_GEN32|DISUSE_REG_GEN64|DISUSE_REG_GEN16))
+        if (pParam->fUse & (DISUSE_REG_GEN32|DISUSE_REG_GEN64|DISUSE_REG_GEN16))
         {
             AssertCompile(USE_REG_ESP == USE_REG_RSP);
@@ -509 +509 @@
     memset(pParamVal, 0, sizeof(*pParamVal));
 
-    if (DISUSE_IS_EFFECTIVE_ADDR(pParam->flags))
+    if (DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse))
     {
         // Effective address
@@ -515 +515 @@
         pParamVal->size = pParam->cb;
 
-        if (pParam->flags & DISUSE_BASE)
-        {
-            if (pParam->flags & DISUSE_REG_GEN8)
+        if (pParam->fUse & DISUSE_BASE)
+        {
+            if (pParam->fUse & DISUSE_REG_GEN8)
             {
                 pParamVal->flags |= PARAM_VAL8;
@@ -523 +523 @@
             }
             else
-            if (pParam->flags & DISUSE_REG_GEN16)
+            if (pParam->fUse & DISUSE_REG_GEN16)
             {
                 pParamVal->flags |= PARAM_VAL16;
@@ -529 +529 @@
             }
             else
-            if (pParam->flags & DISUSE_REG_GEN32)
+            if (pParam->fUse & DISUSE_REG_GEN32)
             {
                 pParamVal->flags |= PARAM_VAL32;
@@ -535 +535 @@
             }
             else
-            if (pParam->flags & DISUSE_REG_GEN64)
+            if (pParam->fUse & DISUSE_REG_GEN64)
             {
                 pParamVal->flags |= PARAM_VAL64;
@@ -547 +547 @@
         }
         // Note that scale implies index (SIB byte)
-        if (pParam->flags & DISUSE_INDEX)
-        {
-            if (pParam->flags & DISUSE_REG_GEN16)
+        if (pParam->fUse & DISUSE_INDEX)
+        {
+            if (pParam->fUse & DISUSE_REG_GEN16)
             {
                 uint16_t val16;
@@ -556 +556 @@
                 if (RT_FAILURE(DISFetchReg16(pCtx, pParam->index.reg_gen, &val16))) return VERR_INVALID_PARAMETER;
 
-                Assert(!(pParam->flags & DISUSE_SCALE));   /* shouldn't be possible in 16 bits mode */
+                Assert(!(pParam->fUse & DISUSE_SCALE));   /* shouldn't be possible in 16 bits mode */
 
                 pParamVal->val.val16 += val16;
             }
             else
-            if (pParam->flags & DISUSE_REG_GEN32)
+            if (pParam->fUse & DISUSE_REG_GEN32)
             {
                 uint32_t val32;
@@ -568 +568 @@
                 if (RT_FAILURE(DISFetchReg32(pCtx, pParam->index.reg_gen, &val32))) return VERR_INVALID_PARAMETER;
 
-                if (pParam->flags & DISUSE_SCALE)
+                if (pParam->fUse & DISUSE_SCALE)
                     val32 *= pParam->scale;
 
@@ -574 +574 @@
             }
             else
-            if (pParam->flags & DISUSE_REG_GEN64)
+            if (pParam->fUse & DISUSE_REG_GEN64)
             {
                 uint64_t val64;
@@ -581 +581 @@
                 if (RT_FAILURE(DISFetchReg64(pCtx, pParam->index.reg_gen, &val64))) return VERR_INVALID_PARAMETER;
 
-                if (pParam->flags & DISUSE_SCALE)
+                if (pParam->fUse & DISUSE_SCALE)
                     val64 *= pParam->scale;
 
@@ -590 +590 @@
         }
 
-        if (pParam->flags & DISUSE_DISPLACEMENT8)
+        if (pParam->fUse & DISUSE_DISPLACEMENT8)
         {
             if (pCpu->mode == DISCPUMODE_32BIT)
@@ -601 +601 @@
         }
         else
-        if (pParam->flags & DISUSE_DISPLACEMENT16)
+        if (pParam->fUse & DISUSE_DISPLACEMENT16)
         {
             if (pCpu->mode == DISCPUMODE_32BIT)
@@ -612 +612 @@
         }
         else
-        if (pParam->flags & DISUSE_DISPLACEMENT32)
+        if (pParam->fUse & DISUSE_DISPLACEMENT32)
         {
             if (pCpu->mode == DISCPUMODE_32BIT)
@@ -620 +620 @@
         }
         else
-        if (pParam->flags & DISUSE_DISPLACEMENT64)
+        if (pParam->fUse & DISUSE_DISPLACEMENT64)
         {
             Assert(pCpu->mode == DISCPUMODE_64BIT);
@@ -626 +626 @@
         }
         else
-        if (pParam->flags & DISUSE_RIPDISPLACEMENT32)
+        if (pParam->fUse & DISUSE_RIPDISPLACEMENT32)
         {
             Assert(pCpu->mode == DISCPUMODE_64BIT);
@@ -635 +635 @@
     }
 
-    if (pParam->flags & (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 (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)
@@ -648 +648 @@
         pParamVal->type = PARMTYPE_IMMEDIATE;
 
-        if (pParam->flags & DISUSE_REG_GEN8)
+        if (pParam->fUse & DISUSE_REG_GEN8)
         {
             pParamVal->flags |= PARAM_VAL8;
@@ -655 +655 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN16)
+        if (pParam->fUse & DISUSE_REG_GEN16)
         {
             pParamVal->flags |= PARAM_VAL16;
@@ -662 +662 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN32)
+        if (pParam->fUse & DISUSE_REG_GEN32)
         {
             pParamVal->flags |= PARAM_VAL32;
@@ -669 +669 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN64)
+        if (pParam->fUse & DISUSE_REG_GEN64)
         {
             pParamVal->flags |= PARAM_VAL64;
@@ -680 +680 @@
             pParamVal->type = PARMTYPE_REGISTER;
         }
-        Assert(!(pParam->flags & DISUSE_IMMEDIATE));
+        Assert(!(pParam->fUse & DISUSE_IMMEDIATE));
         return VINF_SUCCESS;
     }
 
-    if (pParam->flags & DISUSE_IMMEDIATE)
+    if (pParam->fUse & DISUSE_IMMEDIATE)
     {
         pParamVal->type = PARMTYPE_IMMEDIATE;
-        if (pParam->flags & (DISUSE_IMMEDIATE8|DISUSE_IMMEDIATE8_REL))
+        if (pParam->fUse & (DISUSE_IMMEDIATE8|DISUSE_IMMEDIATE8_REL))
         {
             pParamVal->flags |= PARAM_VAL8;
@@ -702 +702 @@
         }
         else
-        if (pParam->flags & (DISUSE_IMMEDIATE16|DISUSE_IMMEDIATE16_REL|DISUSE_IMMEDIATE_ADDR_0_16|DISUSE_IMMEDIATE16_SX8))
+        if (pParam->fUse & (DISUSE_IMMEDIATE16|DISUSE_IMMEDIATE16_REL|DISUSE_IMMEDIATE_ADDR_0_16|DISUSE_IMMEDIATE16_SX8))
         {
             pParamVal->flags |= PARAM_VAL16;
             pParamVal->size   = sizeof(uint16_t);
             pParamVal->val.val16 = (uint16_t)pParam->parval;
-            AssertMsg(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & DISUSE_IMMEDIATE16_SX8)), ("pParamVal->size %d vs %d EIP=%RX32\n", pParamVal->size, pParam->cb, pCtx->eip) );
-        }
-        else
-        if (pParam->flags & (DISUSE_IMMEDIATE32|DISUSE_IMMEDIATE32_REL|DISUSE_IMMEDIATE_ADDR_0_32|DISUSE_IMMEDIATE32_SX8))
+            AssertMsg(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->fUse & DISUSE_IMMEDIATE16_SX8)), ("pParamVal->size %d vs %d EIP=%RX32\n", pParamVal->size, pParam->cb, pCtx->eip) );
+        }
+        else
+        if (pParam->fUse & (DISUSE_IMMEDIATE32|DISUSE_IMMEDIATE32_REL|DISUSE_IMMEDIATE_ADDR_0_32|DISUSE_IMMEDIATE32_SX8))
         {
             pParamVal->flags |= PARAM_VAL32;
             pParamVal->size   = sizeof(uint32_t);
             pParamVal->val.val32 = (uint32_t)pParam->parval;
-            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & DISUSE_IMMEDIATE32_SX8)) );
-        }
-        else
-        if (pParam->flags & (DISUSE_IMMEDIATE64 | DISUSE_IMMEDIATE64_REL | DISUSE_IMMEDIATE64_SX8))
+            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->fUse & DISUSE_IMMEDIATE32_SX8)) );
+        }
+        else
+        if (pParam->fUse & (DISUSE_IMMEDIATE64 | DISUSE_IMMEDIATE64_REL | DISUSE_IMMEDIATE64_SX8))
         {
             pParamVal->flags |= PARAM_VAL64;
             pParamVal->size   = sizeof(uint64_t);
             pParamVal->val.val64 = pParam->parval;
-            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & DISUSE_IMMEDIATE64_SX8)) );
-        }
-        else
-        if (pParam->flags & (DISUSE_IMMEDIATE_ADDR_16_16))
+            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->fUse & DISUSE_IMMEDIATE64_SX8)) );
+        }
+        else
+        if (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_16))
         {
             pParamVal->flags |= PARAM_VALFARPTR16;
@@ -735 +735 @@
         }
         else
-        if (pParam->flags & (DISUSE_IMMEDIATE_ADDR_16_32))
+        if (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_32))
         {
             pParamVal->flags |= PARAM_VALFARPTR32;
@@ -767 +767 @@
 {
     NOREF(pCpu);
-    if (pParam->flags & (DISUSE_REG_GEN8|DISUSE_REG_GEN16|DISUSE_REG_GEN32|DISUSE_REG_FP|DISUSE_REG_MMX|DISUSE_REG_XMM|DISUSE_REG_CR|DISUSE_REG_DBG|DISUSE_REG_SEG|DISUSE_REG_TEST))
+    if (pParam->fUse & (DISUSE_REG_GEN8|DISUSE_REG_GEN16|DISUSE_REG_GEN32|DISUSE_REG_FP|DISUSE_REG_MMX|DISUSE_REG_XMM|DISUSE_REG_CR|DISUSE_REG_DBG|DISUSE_REG_SEG|DISUSE_REG_TEST))
     {
-        if (pParam->flags & DISUSE_REG_GEN8)
+        if (pParam->fUse & DISUSE_REG_GEN8)
         {
             uint8_t *pu8Reg;
@@ -780 +780 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN16)
+        if (pParam->fUse & DISUSE_REG_GEN16)
         {
             uint16_t *pu16Reg;
@@ -791 +791 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN32)
+        if (pParam->fUse & DISUSE_REG_GEN32)
         {
             uint32_t *pu32Reg;
@@ -802 +802 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN64)
+        if (pParam->fUse & DISUSE_REG_GEN64)
         {
             uint64_t *pu64Reg;