Index: /trunk/include/VBox/dis.h
===================================================================
--- /trunk/include/VBox/dis.h	(revision 41677)
+++ /trunk/include/VBox/dis.h	(revision 41678)
@@ -393,5 +393,6 @@
 {
     uint64_t        parval;
-    uint64_t        flags;
+    /** A combination of DISUSE_XXX. */
+    uint64_t        fUse;
     union
     {
Index: /trunk/src/VBox/Disassembler/DisasmCore.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41677)
+++ /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41678)
@@ -616,10 +616,10 @@
     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,10 +631,10 @@
         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,5 +642,5 @@
     else
     {
-        pParam->flags |= DISUSE_BASE | regtype;
+        pParam->fUse |= DISUSE_BASE | regtype;
         pParam->base.reg_gen = base;
     }
@@ -735,5 +735,5 @@
             {
             case OP_PARM_C: //control register
-                pParam->flags |= DISUSE_REG_CR;
+                pParam->fUse |= DISUSE_REG_CR;
 
                 if (    pCpu->pCurInstr->opcode == OP_MOV_CR
@@ -749,5 +749,5 @@
 
             case OP_PARM_D: //debug register
-                pParam->flags |= DISUSE_REG_DBG;
+                pParam->fUse |= DISUSE_REG_DBG;
                 pParam->base.reg_dbg = reg;
                 return 0;
@@ -755,5 +755,5 @@
             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,10 +762,10 @@
                 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,5 +778,5 @@
 
             case OP_PARM_V: //XMM register
-                pParam->flags |= DISUSE_REG_XMM;
+                pParam->fUse |= DISUSE_REG_XMM;
                 pParam->base.reg_xmm = reg;
                 return 0;
@@ -807,10 +807,10 @@
                 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,5 +818,5 @@
             else
             {   //register address
-                pParam->flags |= DISUSE_BASE;
+                pParam->fUse |= DISUSE_BASE;
                 disasmModRMReg(pCpu, pOp, rm, pParam, 1);
             }
@@ -829,9 +829,9 @@
             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,9 +842,9 @@
             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,9 +862,9 @@
             {//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,5 +874,5 @@
             disasmModRMReg16(pCpu, pOp, rm, pParam);
             pParam->uDisp.i8 = pCpu->i32SibDisp;
-            pParam->flags |= DISUSE_BASE | DISUSE_DISPLACEMENT8;
+            pParam->fUse |= DISUSE_BASE | DISUSE_DISPLACEMENT8;
             break;
 
@@ -880,5 +880,5 @@
             disasmModRMReg16(pCpu, pOp, rm, pParam);
             pParam->uDisp.i16 = pCpu->i32SibDisp;
-            pParam->flags |= DISUSE_BASE | DISUSE_DISPLACEMENT16;
+            pParam->fUse |= DISUSE_BASE | DISUSE_DISPLACEMENT16;
             break;
 
@@ -1165,5 +1165,5 @@
     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,5 +1184,5 @@
     {
         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,5 +1191,5 @@
     {
         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,5 +1197,5 @@
     {
         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,5 +1215,5 @@
     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,5 +1232,5 @@
     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,5 +1249,5 @@
     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,5 +1268,5 @@
     {
         pParam->parval = DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE32;
+        pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
         return sizeof(uint32_t);
@@ -1276,5 +1276,5 @@
     {
         pParam->parval = DISReadQWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE64;
+        pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
         return sizeof(uint64_t);
@@ -1282,5 +1282,5 @@
 
     pParam->parval = DISReadWord(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_IMMEDIATE16;
+    pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
     return sizeof(uint16_t);
@@ -1306,5 +1306,5 @@
     {
         pParam->parval = DISReadWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE16;
+        pParam->fUse  |= DISUSE_IMMEDIATE16;
         pParam->cb     = sizeof(uint16_t);
         return sizeof(uint16_t);
@@ -1315,5 +1315,5 @@
     {
         pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE64;
+        pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
     }
@@ -1321,5 +1321,5 @@
     {
         pParam->parval = DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_IMMEDIATE32;
+        pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
     }
@@ -1344,5 +1344,5 @@
     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,5 +1365,5 @@
     {
         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,5 +1374,5 @@
         /* 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,5 +1380,5 @@
 
     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,5 +1406,5 @@
             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,5 +1418,5 @@
          */
         pParam->uDisp.i32 = DISReadDWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_DISPLACEMENT32;
+        pParam->fUse  |= DISUSE_DISPLACEMENT32;
         pParam->cb     = sizeof(uint32_t);
         return sizeof(uint32_t);
@@ -1433,5 +1433,5 @@
          */
         pParam->uDisp.i64 = DISReadQWord(pCpu, uCodePtr);
-        pParam->flags |= DISUSE_DISPLACEMENT64;
+        pParam->fUse  |= DISUSE_DISPLACEMENT64;
         pParam->cb     = sizeof(uint64_t);
         return sizeof(uint64_t);
@@ -1441,5 +1441,5 @@
         /* 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,5 +1453,5 @@
      */
     pParam->uDisp.i16 = DISReadWord(pCpu, uCodePtr);
-    pParam->flags |= DISUSE_DISPLACEMENT16;
+    pParam->fUse  |= DISUSE_DISPLACEMENT16;
     pParam->cb     = sizeof(uint16_t);
     return sizeof(uint16_t);
@@ -1502,5 +1502,5 @@
         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,5 +1509,5 @@
     // 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,5 +1560,5 @@
             /* 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,5 +1574,5 @@
                 pParam->base.reg_gen += 8;
 
-            pParam->flags |= DISUSE_REG_GEN64;
+            pParam->fUse  |= DISUSE_REG_GEN64;
             pParam->cb     = 8;
         }
@@ -1581,5 +1581,5 @@
             /* 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,5 +1591,5 @@
         /* 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,5 +1599,5 @@
         /* 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,5 +1607,5 @@
         /* 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,5 +1624,5 @@
         /* 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,9 +1639,9 @@
     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,10 +1649,10 @@
     {
         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,9 +1664,9 @@
     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,10 +1674,10 @@
     {
         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,9 +1689,9 @@
     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,10 +1699,10 @@
     {
         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,9 +1714,9 @@
     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,10 +1724,10 @@
     {
         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,5 +2341,5 @@
         }
 
-        pParam->flags |= DISUSE_REG_GEN8;
+        pParam->fUse |= DISUSE_REG_GEN8;
         pParam->base.reg_gen = idx;
         break;
@@ -2348,5 +2348,5 @@
         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,10 +2355,10 @@
         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,9 +2375,9 @@
 {
     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,5 +2395,5 @@
     }
 
-    pParam->flags |= DISUSE_REG_SEG;
+    pParam->fUse |= DISUSE_REG_SEG;
     pParam->base.reg_seg = (DIS_SELREG)idx;
 }
@@ -2655,5 +2655,6 @@
         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;
Index: /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp	(revision 41677)
+++ /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp	(revision 41678)
@@ -93,7 +93,7 @@
 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,5 +187,5 @@
 
         default:
-            AssertMsgFailed(("%#x\n", pParam->flags));
+            AssertMsgFailed(("%#x\n", pParam->fUse));
             *pcchReg = 3;
             return "r??";
@@ -231,5 +231,5 @@
 
         default:
-            AssertMsgFailed(("%#x %#x\n", pParam->flags, pCpu->addrmode));
+            AssertMsgFailed(("%#x %#x\n", pParam->fUse, pCpu->addrmode));
             *pcchReg = 3;
             return "r??";
@@ -591,9 +591,9 @@
                         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,7 +613,7 @@
          */
         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,6 +647,6 @@
                     {
                         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,5 +668,5 @@
 
                         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,26 +680,26 @@
                         }
                         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,5 +709,5 @@
                         }
 
-                        if (pParam->flags & DISUSE_INDEX)
+                        if (pParam->fUse & DISUSE_INDEX)
                         {
                             if (fBase)
@@ -718,5 +718,5 @@
                             PUT_STR(pszReg, cchReg);
 
-                            if (pParam->flags & DISUSE_SCALE)
+                            if (pParam->fUse & DISUSE_SCALE)
                             {
                                 PUT_C('*');
@@ -725,16 +725,16 @@
                         }
                         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,5 +744,5 @@
                             }
 
-                            if (fBase || (pParam->flags & DISUSE_INDEX))
+                            if (fBase || (pParam->fUse & DISUSE_INDEX))
                             {
                                 PUT_C(off2 >= 0 ? '+' : '-');
@@ -750,11 +750,11 @@
                                     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,5 +765,5 @@
                         }
 
-                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->flags))
+                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse))
                             PUT_C(']');
                         break;
@@ -776,6 +776,6 @@
                     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,5 +862,5 @@
                             fFlags &= ~DIS_FMT_FLAGS_RELATIVE_BRANCH;
 
-                        if (pParam->flags & DISUSE_IMMEDIATE8_REL)
+                        if (pParam->fUse & DISUSE_IMMEDIATE8_REL)
                         {
                             if (fPrefix)
@@ -872,5 +872,5 @@
                                 PUT_NUM_S8(offDisplacement);
                         }
-                        else if (pParam->flags & DISUSE_IMMEDIATE16_REL)
+                        else if (pParam->fUse & DISUSE_IMMEDIATE16_REL)
                         {
                             if (fPrefix)
@@ -887,5 +887,5 @@
                                 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,5 +938,5 @@
                         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,5 +1002,5 @@
                         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,5 +1066,5 @@
                         PUT_SIZE_OVERRIDE();
                         PUT_C('[');
-                        if (pParam->flags & DISUSE_POINTER_DS_BASED)
+                        if (pParam->fUse & DISUSE_POINTER_DS_BASED)
                             PUT_SZ("ds:");
                         else
@@ -1281,7 +1281,7 @@
         /* 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;
     }
Index: /trunk/src/VBox/Disassembler/DisasmReg.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41677)
+++ /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41678)
@@ -268,5 +268,5 @@
     {
         /* 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,5 +509,5 @@
     memset(pParamVal, 0, sizeof(*pParamVal));
 
-    if (DISUSE_IS_EFFECTIVE_ADDR(pParam->flags))
+    if (DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse))
     {
         // Effective address
@@ -515,7 +515,7 @@
         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,5 +523,5 @@
             }
             else
-            if (pParam->flags & DISUSE_REG_GEN16)
+            if (pParam->fUse & DISUSE_REG_GEN16)
             {
                 pParamVal->flags |= PARAM_VAL16;
@@ -529,5 +529,5 @@
             }
             else
-            if (pParam->flags & DISUSE_REG_GEN32)
+            if (pParam->fUse & DISUSE_REG_GEN32)
             {
                 pParamVal->flags |= PARAM_VAL32;
@@ -535,5 +535,5 @@
             }
             else
-            if (pParam->flags & DISUSE_REG_GEN64)
+            if (pParam->fUse & DISUSE_REG_GEN64)
             {
                 pParamVal->flags |= PARAM_VAL64;
@@ -547,7 +547,7 @@
         }
         // 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,10 +556,10 @@
                 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,5 +568,5 @@
                 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,5 +574,5 @@
             }
             else
-            if (pParam->flags & DISUSE_REG_GEN64)
+            if (pParam->fUse & DISUSE_REG_GEN64)
             {
                 uint64_t val64;
@@ -581,5 +581,5 @@
                 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,5 +590,5 @@
         }
 
-        if (pParam->flags & DISUSE_DISPLACEMENT8)
+        if (pParam->fUse & DISUSE_DISPLACEMENT8)
         {
             if (pCpu->mode == DISCPUMODE_32BIT)
@@ -601,5 +601,5 @@
         }
         else
-        if (pParam->flags & DISUSE_DISPLACEMENT16)
+        if (pParam->fUse & DISUSE_DISPLACEMENT16)
         {
             if (pCpu->mode == DISCPUMODE_32BIT)
@@ -612,5 +612,5 @@
         }
         else
-        if (pParam->flags & DISUSE_DISPLACEMENT32)
+        if (pParam->fUse & DISUSE_DISPLACEMENT32)
         {
             if (pCpu->mode == DISCPUMODE_32BIT)
@@ -620,5 +620,5 @@
         }
         else
-        if (pParam->flags & DISUSE_DISPLACEMENT64)
+        if (pParam->fUse & DISUSE_DISPLACEMENT64)
         {
             Assert(pCpu->mode == DISCPUMODE_64BIT);
@@ -626,5 +626,5 @@
         }
         else
-        if (pParam->flags & DISUSE_RIPDISPLACEMENT32)
+        if (pParam->fUse & DISUSE_RIPDISPLACEMENT32)
         {
             Assert(pCpu->mode == DISCPUMODE_64BIT);
@@ -635,5 +635,5 @@
     }
 
-    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,5 +648,5 @@
         pParamVal->type = PARMTYPE_IMMEDIATE;
 
-        if (pParam->flags & DISUSE_REG_GEN8)
+        if (pParam->fUse & DISUSE_REG_GEN8)
         {
             pParamVal->flags |= PARAM_VAL8;
@@ -655,5 +655,5 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN16)
+        if (pParam->fUse & DISUSE_REG_GEN16)
         {
             pParamVal->flags |= PARAM_VAL16;
@@ -662,5 +662,5 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN32)
+        if (pParam->fUse & DISUSE_REG_GEN32)
         {
             pParamVal->flags |= PARAM_VAL32;
@@ -669,5 +669,5 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN64)
+        if (pParam->fUse & DISUSE_REG_GEN64)
         {
             pParamVal->flags |= PARAM_VAL64;
@@ -680,12 +680,12 @@
             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,29 +702,29 @@
         }
         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,5 +735,5 @@
         }
         else
-        if (pParam->flags & (DISUSE_IMMEDIATE_ADDR_16_32))
+        if (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_32))
         {
             pParamVal->flags |= PARAM_VALFARPTR32;
@@ -767,7 +767,7 @@
 {
     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,5 +780,5 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN16)
+        if (pParam->fUse & DISUSE_REG_GEN16)
         {
             uint16_t *pu16Reg;
@@ -791,5 +791,5 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN32)
+        if (pParam->fUse & DISUSE_REG_GEN32)
         {
             uint32_t *pu32Reg;
@@ -802,5 +802,5 @@
         }
         else
-        if (pParam->flags & DISUSE_REG_GEN64)
+        if (pParam->fUse & DISUSE_REG_GEN64)
         {
             uint64_t *pu64Reg;
Index: /trunk/src/VBox/VMM/VMMAll/EMAll.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/EMAll.cpp	(revision 41677)
+++ /trunk/src/VBox/VMM/VMMAll/EMAll.cpp	(revision 41678)
@@ -1049,6 +1049,6 @@
                 /* pop [esp+xx] uses esp after the actual pop! */
                 AssertCompile(USE_REG_ESP == USE_REG_SP);
-                if (    (pDis->param1.flags & DISUSE_BASE)
-                    &&  (pDis->param1.flags & (DISUSE_REG_GEN16|DISUSE_REG_GEN32))
+                if (    (pDis->param1.fUse & DISUSE_BASE)
+                    &&  (pDis->param1.fUse & (DISUSE_REG_GEN16|DISUSE_REG_GEN32))
                     &&  pDis->param1.base.reg_gen == USE_REG_ESP
                    )
@@ -1536,5 +1536,5 @@
             {
             case PARMTYPE_IMMEDIATE:
-                if(!(param1.flags & (PARAM_VAL32|PARAM_VAL64)))
+                if(!(param1.flags  & (PARAM_VAL32|PARAM_VAL64)))
                     return VERR_EM_INTERPRETER;
                 /* fallthru */
@@ -2062,5 +2062,5 @@
     case PARMTYPE_IMMEDIATE:
     case PARMTYPE_ADDRESS:
-        if(!(param1.flags & (PARAM_VAL32|PARAM_VAL64)))
+        if(!(param1.flags  & (PARAM_VAL32|PARAM_VAL64)))
             return VERR_EM_INTERPRETER;
         addr = (RTGCPTR)param1.val.val64;
@@ -2397,5 +2397,5 @@
     case PARMTYPE_IMMEDIATE:
     case PARMTYPE_ADDRESS:
-        if(!(param1.flags & PARAM_VAL16))
+        if(!(param1.flags  & PARAM_VAL16))
             return VERR_EM_INTERPRETER;
         val = param1.val.val32;
@@ -2468,8 +2468,8 @@
 {
     NOREF(pvFault); NOREF(pcbSize);
-    if ((pDis->param1.flags == DISUSE_REG_GEN32 || pDis->param1.flags == DISUSE_REG_GEN64) && pDis->param2.flags == DISUSE_REG_CR)
+    if ((pDis->param1.fUse == DISUSE_REG_GEN32 || pDis->param1.fUse == DISUSE_REG_GEN64) && pDis->param2.fUse == DISUSE_REG_CR)
         return EMInterpretCRxRead(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_gen, pDis->param2.base.reg_ctrl);
 
-    if (pDis->param1.flags == DISUSE_REG_CR && (pDis->param2.flags == DISUSE_REG_GEN32 || pDis->param2.flags == DISUSE_REG_GEN64))
+    if (pDis->param1.fUse == DISUSE_REG_CR && (pDis->param2.fUse == DISUSE_REG_GEN32 || pDis->param2.fUse == DISUSE_REG_GEN64))
         return EMInterpretCRxWrite(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_ctrl, pDis->param2.base.reg_gen);
 
@@ -2558,10 +2558,10 @@
     NOREF(pvFault); NOREF(pcbSize);
 
-    if((pDis->param1.flags == DISUSE_REG_GEN32 || pDis->param1.flags == DISUSE_REG_GEN64) && pDis->param2.flags == DISUSE_REG_DBG)
+    if((pDis->param1.fUse == DISUSE_REG_GEN32 || pDis->param1.fUse == DISUSE_REG_GEN64) && pDis->param2.fUse == DISUSE_REG_DBG)
     {
         rc = EMInterpretDRxRead(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_gen, pDis->param2.base.reg_dbg);
     }
     else
-    if(pDis->param1.flags == DISUSE_REG_DBG && (pDis->param2.flags == DISUSE_REG_GEN32 || pDis->param2.flags == DISUSE_REG_GEN64))
+    if(pDis->param1.fUse == DISUSE_REG_DBG && (pDis->param2.fUse == DISUSE_REG_GEN32 || pDis->param2.fUse == DISUSE_REG_GEN64))
     {
         rc = EMInterpretDRxWrite(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_dbg, pDis->param2.base.reg_gen);
@@ -2593,5 +2593,5 @@
 
     case PARMTYPE_IMMEDIATE:
-        if(!(param1.flags & PARAM_VAL16))
+        if(!(param1.flags  & PARAM_VAL16))
             return VERR_EM_INTERPRETER;
         sel = (RTSEL)param1.val.val16;
Index: /trunk/src/VBox/VMM/VMMAll/IOMAll.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/IOMAll.cpp	(revision 41677)
+++ /trunk/src/VBox/VMM/VMMAll/IOMAll.cpp	(revision 41678)
@@ -68,5 +68,5 @@
 {
     NOREF(pCpu);
-    if (pParam->flags & (DISUSE_BASE | DISUSE_INDEX | DISUSE_SCALE | DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32))
+    if (pParam->fUse & (DISUSE_BASE | DISUSE_INDEX | DISUSE_SCALE | DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32))
     {
         *pcbSize  = 0;
@@ -76,7 +76,7 @@
 
     /* divide and conquer */
-    if (pParam->flags & (DISUSE_REG_GEN64 | DISUSE_REG_GEN32 | DISUSE_REG_GEN16 | DISUSE_REG_GEN8))
-    {
-        if (pParam->flags & DISUSE_REG_GEN32)
+    if (pParam->fUse & (DISUSE_REG_GEN64 | DISUSE_REG_GEN32 | DISUSE_REG_GEN16 | DISUSE_REG_GEN8))
+    {
+        if (pParam->fUse & DISUSE_REG_GEN32)
         {
             *pcbSize  = 4;
@@ -85,5 +85,5 @@
         }
 
-        if (pParam->flags & DISUSE_REG_GEN16)
+        if (pParam->fUse & DISUSE_REG_GEN16)
         {
             *pcbSize  = 2;
@@ -92,5 +92,5 @@
         }
 
-        if (pParam->flags & DISUSE_REG_GEN8)
+        if (pParam->fUse & DISUSE_REG_GEN8)
         {
             *pcbSize  = 1;
@@ -99,5 +99,5 @@
         }
 
-        Assert(pParam->flags & DISUSE_REG_GEN64);
+        Assert(pParam->fUse & DISUSE_REG_GEN64);
         *pcbSize  = 8;
         DISFetchReg64(pRegFrame, pParam->base.reg_gen, pu64Data);
@@ -106,5 +106,5 @@
     else
     {
-        if (pParam->flags & (DISUSE_IMMEDIATE64 | DISUSE_IMMEDIATE64_SX8))
+        if (pParam->fUse & (DISUSE_IMMEDIATE64 | DISUSE_IMMEDIATE64_SX8))
         {
             *pcbSize  = 8;
@@ -113,5 +113,5 @@
         }
 
-        if (pParam->flags & (DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE32_SX8))
+        if (pParam->fUse & (DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE32_SX8))
         {
             *pcbSize  = 4;
@@ -120,5 +120,5 @@
         }
 
-        if (pParam->flags & (DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE16_SX8))
+        if (pParam->fUse & (DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE16_SX8))
         {
             *pcbSize  = 2;
@@ -127,5 +127,5 @@
         }
 
-        if (pParam->flags & DISUSE_IMMEDIATE8)
+        if (pParam->fUse & DISUSE_IMMEDIATE8)
         {
             *pcbSize  = 1;
@@ -134,5 +134,5 @@
         }
 
-        if (pParam->flags & DISUSE_REG_SEG)
+        if (pParam->fUse & DISUSE_REG_SEG)
         {
             *pcbSize  = 2;
@@ -162,10 +162,10 @@
 {
     NOREF(pCpu);
-    if (pParam->flags & (DISUSE_BASE | DISUSE_INDEX | DISUSE_SCALE | DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_IMMEDIATE8 | DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE32_SX8 | DISUSE_IMMEDIATE16_SX8))
+    if (pParam->fUse & (DISUSE_BASE | DISUSE_INDEX | DISUSE_SCALE | DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_IMMEDIATE8 | DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE32_SX8 | DISUSE_IMMEDIATE16_SX8))
     {
         return false;
     }
 
-    if (pParam->flags & DISUSE_REG_GEN32)
+    if (pParam->fUse & DISUSE_REG_GEN32)
     {
         DISWriteReg32(pRegFrame, pParam->base.reg_gen, (uint32_t)u64Data);
@@ -173,5 +173,5 @@
     }
 
-    if (pParam->flags & DISUSE_REG_GEN64)
+    if (pParam->fUse & DISUSE_REG_GEN64)
     {
         DISWriteReg64(pRegFrame, pParam->base.reg_gen, u64Data);
@@ -179,5 +179,5 @@
     }
 
-    if (pParam->flags & DISUSE_REG_GEN16)
+    if (pParam->fUse & DISUSE_REG_GEN16)
     {
         DISWriteReg16(pRegFrame, pParam->base.reg_gen, (uint16_t)u64Data);
@@ -185,5 +185,5 @@
     }
 
-    if (pParam->flags & DISUSE_REG_GEN8)
+    if (pParam->fUse & DISUSE_REG_GEN8)
     {
         DISWriteReg8(pRegFrame, pParam->base.reg_gen, (uint8_t)u64Data);
@@ -191,5 +191,5 @@
     }
 
-    if (pParam->flags & DISUSE_REG_SEG)
+    if (pParam->fUse & DISUSE_REG_SEG)
     {
         DISWriteRegSeg(pRegFrame, pParam->base.reg_seg, (RTSEL)u64Data);
Index: /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp	(revision 41677)
+++ /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp	(revision 41678)
@@ -1535,8 +1535,8 @@
         {
             STAM_PROFILE_START(&pVM->iom.s.StatRZInstMov, b);
-            AssertMsg(uErrorCode == UINT32_MAX || DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.flags) == !!(uErrorCode & X86_TRAP_PF_RW), ("flags1=%#llx/%RTbool flags2=%#llx/%RTbool ErrCd=%#x\n", pDis->param1.flags, DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.flags), pDis->param2.flags, DISUSE_IS_EFFECTIVE_ADDR(pDis->param2.flags), uErrorCode));
+            AssertMsg(uErrorCode == UINT32_MAX || DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.fUse) == !!(uErrorCode & X86_TRAP_PF_RW), ("flags1=%#llx/%RTbool flags2=%#llx/%RTbool ErrCd=%#x\n", pDis->param1.fUse, DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.fUse), pDis->param2.fUse, DISUSE_IS_EFFECTIVE_ADDR(pDis->param2.fUse), uErrorCode));
             if (uErrorCode != UINT32_MAX    /* EPT+MMIO optimization */
                 ? uErrorCode & X86_TRAP_PF_RW
-                : DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.flags))
+                : DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.fUse))
                 rc = iomInterpretMOVxXWrite(pVM, pCtxCore, pDis, pRange, GCPhysFault);
             else
Index: /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp	(revision 41677)
+++ /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp	(revision 41678)
@@ -761,5 +761,5 @@
 #endif
 
-    LogFlow(("Reused instr %RGv %d at %RGv param1.flags=%x param1.reg=%d\n", pRegFrame->rip, pDis->pCurInstr->opcode, pvFault, pDis->param1.flags,  pDis->param1.base.reg_gen));
+    LogFlow(("Reused instr %RGv %d at %RGv param1.fUse=%llx param1.reg=%d\n", pRegFrame->rip, pDis->pCurInstr->opcode, pvFault, pDis->param1.fUse,  pDis->param1.base.reg_gen));
 
     /* Non-supervisor mode write means it's used for something else. */
@@ -804,6 +804,6 @@
             return false;
     }
-    if (    (    (pDis->param1.flags & DISUSE_REG_GEN32)
-             ||  (pDis->param1.flags & DISUSE_REG_GEN64))
+    if (    (    (pDis->param1.fUse & DISUSE_REG_GEN32)
+             ||  (pDis->param1.fUse & DISUSE_REG_GEN64))
         &&  (pDis->param1.base.reg_gen == USE_REG_ESP))
     {
Index: /trunk/src/VBox/VMM/VMMR3/CSAM.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/CSAM.cpp	(revision 41677)
+++ /trunk/src/VBox/VMM/VMMR3/CSAM.cpp	(revision 41678)
@@ -800,5 +800,5 @@
     {
     case OP_INT:
-        Assert(pCpu->param1.flags & DISUSE_IMMEDIATE8);
+        Assert(pCpu->param1.fUse & DISUSE_IMMEDIATE8);
         if (pCpu->param1.parval == 3)
         {
@@ -1097,5 +1097,5 @@
                      * Any register is allowed as long as source and destination are identical.
                      */
-                    if (    cpu.param1.flags != DISUSE_REG_GEN32
+                    if (    cpu.param1.fUse != DISUSE_REG_GEN32
                         ||  (   cpu.param2.flags != DISUSE_REG_GEN32
                              && (   !(cpu.param2.flags & DISUSE_REG_GEN32)
@@ -1115,5 +1115,5 @@
                 {
                     if (    (pCurInstrGC & 0x3) != 0
-                        ||  cpu.param1.flags != DISUSE_REG_GEN32
+                        ||  cpu.param1.fUse != DISUSE_REG_GEN32
                         ||  cpu.param1.base.reg_gen32 != USE_REG_EBP
                        )
@@ -1141,5 +1141,5 @@
                 {
                     if (    (pCurInstrGC & 0x3) != 0
-                        ||  cpu.param1.flags != DISUSE_REG_GEN32
+                        ||  cpu.param1.fUse != DISUSE_REG_GEN32
                         ||  cpu.param1.base.reg_gen32 != USE_REG_ESP
                        )
@@ -1328,9 +1328,9 @@
         // For our first attempt, we'll handle only simple relative jumps and calls (immediate offset coded in instruction)
         if (    ((cpu.pCurInstr->optype & DISOPTYPE_CONTROLFLOW) && (OP_PARM_VTYPE(cpu.pCurInstr->param1) == OP_PARM_J))
-            ||  (cpu.pCurInstr->opcode == OP_CALL && cpu.param1.flags == DISUSE_DISPLACEMENT32))  /* simple indirect call (call dword ptr [address]) */
+            ||  (cpu.pCurInstr->opcode == OP_CALL && cpu.param1.fUse == DISUSE_DISPLACEMENT32))  /* simple indirect call (call dword ptr [address]) */
         {
             /* We need to parse 'call dword ptr [address]' type of calls to catch cpuid instructions in some recent Linux distributions (e.g. OpenSuse 10.3) */
             if (    cpu.pCurInstr->opcode == OP_CALL
-                &&  cpu.param1.flags == DISUSE_DISPLACEMENT32)
+                &&  cpu.param1.fUse == DISUSE_DISPLACEMENT32)
             {
                 addr = 0;
@@ -1342,5 +1342,5 @@
             if (addr == 0)
             {
-                Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.flags));
+                Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.fUse));
                 rc = VINF_SUCCESS;
                 break;
@@ -1399,5 +1399,5 @@
         else
         if (    cpu.pCurInstr->opcode == OP_JMP
-            &&  (cpu.param1.flags & (DISUSE_DISPLACEMENT32|DISUSE_INDEX|DISUSE_SCALE)) == (DISUSE_DISPLACEMENT32|DISUSE_INDEX|DISUSE_SCALE)
+            &&  (cpu.param1.fUse & (DISUSE_DISPLACEMENT32|DISUSE_INDEX|DISUSE_SCALE)) == (DISUSE_DISPLACEMENT32|DISUSE_INDEX|DISUSE_SCALE)
            )
         {
Index: /trunk/src/VBox/VMM/VMMR3/EMRaw.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/EMRaw.cpp	(revision 41677)
+++ /trunk/src/VBox/VMM/VMMR3/EMRaw.cpp	(revision 41678)
@@ -990,8 +990,8 @@
 
             case OP_MOV_CR:
-                if (Cpu.param1.flags & DISUSE_REG_GEN32)
+                if (Cpu.param1.fUse & DISUSE_REG_GEN32)
                 {
                     //read
-                    Assert(Cpu.param2.flags & DISUSE_REG_CR);
+                    Assert(Cpu.param2.fUse & DISUSE_REG_CR);
                     Assert(Cpu.param2.base.reg_ctrl <= USE_REG_CR4);
                     STAM_COUNTER_INC(&pStats->StatMovReadCR[Cpu.param2.base.reg_ctrl]);
@@ -1000,5 +1000,5 @@
                 {
                     //write
-                    Assert(Cpu.param1.flags & DISUSE_REG_CR);
+                    Assert(Cpu.param1.fUse & DISUSE_REG_CR);
                     Assert(Cpu.param1.base.reg_ctrl <= USE_REG_CR4);
                     STAM_COUNTER_INC(&pStats->StatMovWriteCR[Cpu.param1.base.reg_ctrl]);
@@ -1100,5 +1100,5 @@
 
                         if (    Cpu.pCurInstr->opcode == OP_MOV_CR
-                            &&  Cpu.param1.flags == DISUSE_REG_CR /* write */
+                            &&  Cpu.param1.fUse == DISUSE_REG_CR /* write */
                            )
                         {
Index: /trunk/src/VBox/VMM/VMMR3/HWACCM.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/HWACCM.cpp	(revision 41677)
+++ /trunk/src/VBox/VMM/VMMR3/HWACCM.cpp	(revision 41678)
@@ -1833,8 +1833,8 @@
         pPatch->cbOp     = cbOp;
 
-        if (pDis->param1.flags == DISUSE_DISPLACEMENT32)
+        if (pDis->param1.fUse == DISUSE_DISPLACEMENT32)
         {
             /* write. */
-            if (pDis->param2.flags == DISUSE_REG_GEN32)
+            if (pDis->param2.fUse == DISUSE_REG_GEN32)
             {
                 pPatch->enmType     = HWACCMTPRINSTR_WRITE_REG;
@@ -1843,5 +1843,5 @@
             else
             {
-                Assert(pDis->param2.flags == DISUSE_IMMEDIATE32);
+                Assert(pDis->param2.fUse == DISUSE_IMMEDIATE32);
                 pPatch->enmType     = HWACCMTPRINSTR_WRITE_IMM;
                 pPatch->uSrcOperand = pDis->param2.parval;
@@ -1860,5 +1860,5 @@
 
             /* read */
-            Assert(pDis->param1.flags == DISUSE_REG_GEN32);
+            Assert(pDis->param1.fUse == DISUSE_REG_GEN32);
 
             /* Found:
@@ -1872,7 +1872,7 @@
             if (    rc == VINF_SUCCESS
                 &&  pDis->pCurInstr->opcode == OP_SHR
-                &&  pDis->param1.flags == DISUSE_REG_GEN32
+                &&  pDis->param1.fUse == DISUSE_REG_GEN32
                 &&  pDis->param1.base.reg_gen == uMmioReg
-                &&  pDis->param2.flags == DISUSE_IMMEDIATE8
+                &&  pDis->param2.fUse == DISUSE_IMMEDIATE8
                 &&  pDis->param2.parval == 4
                 &&  oldcbOp + cbOp < sizeof(pVM->hwaccm.s.aPatches[idx].aOpcode))
@@ -2008,5 +2008,5 @@
         pPatch->enmType = HWACCMTPRINSTR_JUMP_REPLACEMENT;
 
-        if (pDis->param1.flags == DISUSE_DISPLACEMENT32)
+        if (pDis->param1.fUse == DISUSE_DISPLACEMENT32)
         {
             /*
@@ -2028,5 +2028,5 @@
                 *
                 */
-            bool fUsesEax = (pDis->param2.flags == DISUSE_REG_GEN32 && pDis->param2.base.reg_gen == USE_REG_EAX);
+            bool fUsesEax = (pDis->param2.fUse == DISUSE_REG_GEN32 && pDis->param2.base.reg_gen == USE_REG_EAX);
 
             aPatch[off++] = 0x51;    /* push ecx */
@@ -2036,5 +2036,5 @@
             aPatch[off++] = 0x31;    /* xor edx, edx */
             aPatch[off++] = 0xD2;
-            if (pDis->param2.flags == DISUSE_REG_GEN32)
+            if (pDis->param2.fUse == DISUSE_REG_GEN32)
             {
                 if (!fUsesEax)
@@ -2046,5 +2046,5 @@
             else
             {
-                Assert(pDis->param2.flags == DISUSE_IMMEDIATE32);
+                Assert(pDis->param2.fUse == DISUSE_IMMEDIATE32);
                 aPatch[off++] = 0xB8;    /* mov eax, immediate */
                 *(uint32_t *)&aPatch[off] = pDis->param2.parval;
@@ -2079,5 +2079,5 @@
                 *
                 */
-            Assert(pDis->param1.flags == DISUSE_REG_GEN32);
+            Assert(pDis->param1.fUse == DISUSE_REG_GEN32);
 
             if (pDis->param1.base.reg_gen != USE_REG_ECX)
Index: /trunk/src/VBox/VMM/VMMR3/PATM.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/PATM.cpp	(revision 41677)
+++ /trunk/src/VBox/VMM/VMMR3/PATM.cpp	(revision 41678)
@@ -7,5 +7,5 @@
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -1701,5 +1701,5 @@
         if (pTargetGC == 0)
         {
-            Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.flags));
+            Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.fUse));
             return VERR_PATCHING_REFUSED;
         }
@@ -1748,5 +1748,5 @@
         {
             /* mov ss, src? */
-            if (    (pCpu->param1.flags & DISUSE_REG_SEG)
+            if (    (pCpu->param1.fUse & DISUSE_REG_SEG)
                 &&  (pCpu->param1.base.reg_seg == DIS_SELREG_SS))
             {
@@ -1757,7 +1757,7 @@
 #if 0 /* necessary for Haiku */
             else
-            if (    (pCpu->param2.flags & DISUSE_REG_SEG)
+            if (    (pCpu->param2.fUse & DISUSE_REG_SEG)
                 &&  (pCpu->param2.base.reg_seg == USE_REG_SS)
-                &&  (pCpu->param1.flags & (DISUSE_REG_GEN32|DISUSE_REG_GEN16)))     /** @todo memory operand must in theory be handled too */
+                &&  (pCpu->param1.fUse & (DISUSE_REG_GEN32|DISUSE_REG_GEN16)))     /** @todo memory operand must in theory be handled too */
             {
                 /* mov GPR, ss */
@@ -2243,5 +2243,5 @@
             if (pTargetGC == 0)
             {
-                Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.flags));
+                Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.fUse));
                 rc = VERR_PATCHING_REFUSED;
                 break;
@@ -2462,5 +2462,5 @@
             if (addr == 0)
             {
-                Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.flags));
+                Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.fUse));
                 rc = VERR_PATCHING_REFUSED;
                 break;
@@ -3588,5 +3588,5 @@
     if (pTargetGC == 0)
     {
-        Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.flags));
+        Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.fUse));
         rc = VERR_PATCHING_REFUSED;
         goto failure;
@@ -3680,5 +3680,5 @@
         goto failure;
 
-    if (pCpu->param2.flags != DISUSE_DISPLACEMENT32)
+    if (pCpu->param2.fUse != DISUSE_DISPLACEMENT32)
         goto failure;
 
@@ -3759,5 +3759,5 @@
     if (opsize > MAX_INSTR_SIZE)
         return VERR_PATCHING_REFUSED;
-    if (cpu.param2.flags != DISUSE_DISPLACEMENT32)
+    if (cpu.param2.fUse != DISUSE_DISPLACEMENT32)
         return VERR_PATCHING_REFUSED;
 
@@ -3921,6 +3921,6 @@
     case OP_JMP:
         Assert(pPatch->flags & PATMFL_JUMP_CONFLICT);
-        Assert(pCpu->param1.flags & DISUSE_IMMEDIATE32_REL);
-        if (!(pCpu->param1.flags & DISUSE_IMMEDIATE32_REL))
+        Assert(pCpu->param1.fUse & DISUSE_IMMEDIATE32_REL);
+        if (!(pCpu->param1.fUse & DISUSE_IMMEDIATE32_REL))
             goto failure;
 
@@ -5206,5 +5206,5 @@
         && (pConflictPatch->flags & PATMFL_CODE32)
         && (cpu.pCurInstr->opcode == OP_JMP || (cpu.pCurInstr->optype & DISOPTYPE_COND_CONTROLFLOW))
-        && (cpu.param1.flags & DISUSE_IMMEDIATE32_REL))
+        && (cpu.param1.fUse & DISUSE_IMMEDIATE32_REL))
     {
         /* Hint patches must be enabled first. */
Index: /trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp	(revision 41677)
+++ /trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp	(revision 41678)
@@ -1163,6 +1163,6 @@
         // mov DRx, GPR
         pPB[0] = 0x89;      //mov disp32, GPR
-        Assert(pCpu->param1.flags & DISUSE_REG_DBG);
-        Assert(pCpu->param2.flags & DISUSE_REG_GEN32);
+        Assert(pCpu->param1.fUse & DISUSE_REG_DBG);
+        Assert(pCpu->param2.fUse & DISUSE_REG_GEN32);
 
         dbgreg = pCpu->param1.base.reg_dbg;
@@ -1172,6 +1172,6 @@
     {
         // mov GPR, DRx
-        Assert(pCpu->param1.flags & DISUSE_REG_GEN32);
-        Assert(pCpu->param2.flags & DISUSE_REG_DBG);
+        Assert(pCpu->param1.fUse & DISUSE_REG_GEN32);
+        Assert(pCpu->param2.fUse & DISUSE_REG_DBG);
 
         pPB[0] = 0x8B;      // mov GPR, disp32
@@ -1215,12 +1215,12 @@
         ctrlreg = pCpu->param1.base.reg_ctrl;
         reg     = pCpu->param2.base.reg_gen;
-        Assert(pCpu->param1.flags & DISUSE_REG_CR);
-        Assert(pCpu->param2.flags & DISUSE_REG_GEN32);
+        Assert(pCpu->param1.fUse & DISUSE_REG_CR);
+        Assert(pCpu->param2.fUse & DISUSE_REG_GEN32);
     }
     else
     {
         // mov GPR, DRx
-        Assert(pCpu->param1.flags & DISUSE_REG_GEN32);
-        Assert(pCpu->param2.flags & DISUSE_REG_CR);
+        Assert(pCpu->param1.fUse & DISUSE_REG_GEN32);
+        Assert(pCpu->param2.fUse & DISUSE_REG_CR);
 
         pPB[0]  = 0x8B;      // mov GPR, disp32
@@ -1324,5 +1324,5 @@
     PATCHGEN_PROLOG(pVM, pPatch);
 
-    if (pCpu->param1.flags == DISUSE_REG_GEN32 || pCpu->param1.flags == DISUSE_REG_GEN16)
+    if (pCpu->param1.fUse == DISUSE_REG_GEN32 || pCpu->param1.fUse == DISUSE_REG_GEN16)
     {
         /* Register operand */
Index: /trunk/src/VBox/VMM/VMMRC/TRPMRCHandlers.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMRC/TRPMRCHandlers.cpp	(revision 41677)
+++ /trunk/src/VBox/VMM/VMMRC/TRPMRCHandlers.cpp	(revision 41678)
@@ -738,10 +738,10 @@
              * Little hack to make the code below not fail
              */
-            pCpu->param1.flags  = DISUSE_IMMEDIATE8;
+            pCpu->param1.fUse  = DISUSE_IMMEDIATE8;
             pCpu->param1.parval = 3;
             /* fallthru */
         case OP_INT:
         {
-            Assert(pCpu->param1.flags & DISUSE_IMMEDIATE8);
+            Assert(pCpu->param1.fUse & DISUSE_IMMEDIATE8);
             Assert(!(PATMIsPatchGCAddr(pVM, PC)));
             if (pCpu->param1.parval == 3)
@@ -840,10 +840,10 @@
              * Little hack to make the code below not fail
              */
-            pCpu->param1.flags  = DISUSE_IMMEDIATE8;
+            pCpu->param1.fUse  = DISUSE_IMMEDIATE8;
             pCpu->param1.parval = 3;
             /* fall thru */
         case OP_INT:
         {
-            Assert(pCpu->param1.flags & DISUSE_IMMEDIATE8);
+            Assert(pCpu->param1.fUse & DISUSE_IMMEDIATE8);
             rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->param1.parval, pCpu->opsize, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
             if (RT_SUCCESS(rc) && rc != VINF_EM_RAW_GUEST_TRAP)
Index: /trunk/src/VBox/VMM/include/CSAMInternal.h
===================================================================
--- /trunk/src/VBox/VMM/include/CSAMInternal.h	(revision 41677)
+++ /trunk/src/VBox/VMM/include/CSAMInternal.h	(revision 41678)
@@ -251,15 +251,15 @@
 {
     uint32_t disp;
-    if (pCpu->param1.flags & DISUSE_IMMEDIATE8_REL)
+    if (pCpu->param1.fUse & DISUSE_IMMEDIATE8_REL)
     {
         disp = (int32_t)(char)pCpu->param1.parval;
     }
     else
-    if (pCpu->param1.flags & DISUSE_IMMEDIATE16_REL)
+    if (pCpu->param1.fUse & DISUSE_IMMEDIATE16_REL)
     {
         disp = (int32_t)(uint16_t)pCpu->param1.parval;
     }
     else
-    if (pCpu->param1.flags & DISUSE_IMMEDIATE32_REL)
+    if (pCpu->param1.fUse & DISUSE_IMMEDIATE32_REL)
     {
         disp = (int32_t)pCpu->param1.parval;
@@ -267,5 +267,5 @@
     else
     {
-        Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.flags));
+        Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.fUse));
         return 0;
     }
Index: /trunk/src/VBox/VMM/include/PATMInternal.h
===================================================================
--- /trunk/src/VBox/VMM/include/PATMInternal.h	(revision 41677)
+++ /trunk/src/VBox/VMM/include/PATMInternal.h	(revision 41678)
@@ -761,15 +761,15 @@
 {
     uint32_t disp;
-    if (pCpu->param1.flags & DISUSE_IMMEDIATE8_REL)
+    if (pCpu->param1.fUse & DISUSE_IMMEDIATE8_REL)
     {
         disp = (int32_t)(char)pCpu->param1.parval;
     }
     else
-    if (pCpu->param1.flags & DISUSE_IMMEDIATE16_REL)
+    if (pCpu->param1.fUse & DISUSE_IMMEDIATE16_REL)
     {
         disp = (int32_t)(uint16_t)pCpu->param1.parval;
     }
     else
-    if (pCpu->param1.flags & DISUSE_IMMEDIATE32_REL)
+    if (pCpu->param1.fUse & DISUSE_IMMEDIATE32_REL)
     {
         disp = (int32_t)pCpu->param1.parval;
@@ -777,5 +777,5 @@
     else
     {
-        Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.flags));
+        Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.fUse));
         return 0;
     }