vbox的更動 41678 路徑 trunk/src/VBox/Disassembler/DisasmReg.cpp

時間撮記:

2012-6-13 上午09:37:47 (12 年 以前)

作者:

vboxsync

訊息:

OP_PARAMETER::flags -> fUse.

檔案:

• trunk/src/VBox/Disassembler/DisasmReg.cpp (修改) (28 筆差異)

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;