Changeset 41789 in vbox for trunk/src/VBox

Timestamp:

Jun 16, 2012 8:24:50 PM (13 years ago)

Author:

vboxsync

Message:

DIS: pCpu -> pDis.

Location:

trunk/src/VBox/Disassembler

Files:

• Disasm.cpp (modified) (6 diffs)
• DisasmCore.cpp (modified) (170 diffs)
• DisasmFormatBytes.cpp (modified) (2 diffs)
• DisasmFormatYasm.cpp (modified) (61 diffs)
• DisasmInternal.h (modified) (1 diff)
• DisasmReg.cpp (modified) (14 diffs)
• testcase/tstDisasm-2.cpp (modified) (4 diffs)

trunk/src/VBox/Disassembler/Disasm.cpp

@@ -33 +33 @@
  *
  * @returns VBox error code
- * @param   pCpu            Pointer to cpu structure which have DISCPUSTATE::mode
- *                          set correctly.
  * @param   pvInstr         Pointer to the instruction to disassemble.
+ * @param   enmCpuMode      The CPU state.
+ * @param   pDis            The disassembler state (output).
  * @param   pcbInstr        Where to store the size of the instruction. NULL is
  *                          allowed.
@@ -43 +43 @@
  * @todo    Define output callback.
  */
-DISDECL(int) DISInstrToStr(void const *pvInstr, DISCPUMODE enmCpuMode, PDISCPUSTATE pCpu, uint32_t *pcbInstr,
+DISDECL(int) DISInstrToStr(void const *pvInstr, DISCPUMODE enmCpuMode, PDISCPUSTATE pDis, uint32_t *pcbInstr,
                            char *pszOutput, size_t cbOutput)
 {
     return DISInstrToStrEx((uintptr_t)pvInstr, enmCpuMode, NULL, NULL, DISOPTYPE_ALL,
-                           pCpu, pcbInstr, pszOutput, cbOutput);
+                           pDis, pcbInstr, pszOutput, cbOutput);
 }
 
@@ -59 +59 @@
  * @param   pvUser          The user argument (found in
  *                          DISCPUSTATE::pvUser).
- * @param   pCpu            Where to return the disassembled instruction.
+ * @param   pDis            The disassembler state (output).
  * @param   pcbInstr        Where to store the size of the instruction. NULL is
  *                          allowed.
@@ -68 +68 @@
  */
 DISDECL(int) DISInstrToStrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
-                                     PDISCPUSTATE pCpu, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput)
+                                     PDISCPUSTATE pDis, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput)
 
 {
     return DISInstrToStrEx(uInstrAddr, enmCpuMode, pfnReadBytes, pvUser, DISOPTYPE_ALL,
-                           pCpu, pcbInstr, pszOutput, cbOutput);
+                           pDis, pcbInstr, pszOutput, cbOutput);
 }
 
@@ -83 +83 @@
  * @param   pfnCallback     The byte fetcher callback.
  * @param   uFilter         Instruction filter.
- * @param   pCpu            Where to return the disassembled instruction.
+ * @param   pDis            Where to return the disassembled instruction info.
  * @param   pcbInstr        Where to store the size of the instruction. NULL is
  *                          allowed.
@@ -93 +93 @@
 DISDECL(int) DISInstrToStrEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode,
                              PFNDISREADBYTES pfnReadBytes, void *pvUser, uint32_t uFilter,
-                             PDISCPUSTATE pCpu, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput)
+                             PDISCPUSTATE pDis, uint32_t *pcbInstr, char *pszOutput, size_t cbOutput)
 {
-    int rc = DISInstEx(uInstrAddr, enmCpuMode, uFilter, pfnReadBytes, pvUser, pCpu, pcbInstr);
+    int rc = DISInstEx(uInstrAddr, enmCpuMode, uFilter, pfnReadBytes, pvUser, pDis, pcbInstr);
     if (RT_SUCCESS(rc) && pszOutput && cbOutput)
     {
-        size_t cch = DISFormatYasmEx(pCpu, pszOutput, cbOutput,
+        size_t cch = DISFormatYasmEx(pDis, pszOutput, cbOutput,
                                      DIS_FMT_FLAGS_BYTES_LEFT | DIS_FMT_FLAGS_BYTES_BRACKETS | DIS_FMT_FLAGS_BYTES_SPACED
                                      | DIS_FMT_FLAGS_RELATIVE_BRANCH | DIS_FMT_FLAGS_ADDR_LEFT,

trunk/src/VBox/Disassembler/DisasmCore.cpp

@@ -47 +47 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-static void     disasmModRMReg(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam, int fRegAddr);
-static void     disasmModRMReg16(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam);
-static void     disasmModRMSReg(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam);
+static void     disasmModRMReg(PDISCPUSTATE pDis, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam, int fRegAddr);
+static void     disasmModRMReg16(PDISCPUSTATE pDis, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam);
+static void     disasmModRMSReg(PDISCPUSTATE pDis, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam);
 
 
@@ -252 +252 @@
  * The caller shall fend off reads beyond the DISCPUSTATE::abInstr buffer.
  *
- * @param   pCpu                The disassembler state.
+ * @param   pDis                The disassembler state.
  * @param   offInstr            The offset of the read request.
  * @param   cbMin               The size of the read request that needs to be
  *                              satisfied.
  */
-DECL_NO_INLINE(static, void) disReadMore(PDISCPUSTATE pCpu, uint8_t offInstr, uint8_t cbMin)
-{
-    Assert(cbMin + offInstr <= sizeof(pCpu->abInstr));
+DECL_NO_INLINE(static, void) disReadMore(PDISCPUSTATE pDis, uint8_t offInstr, uint8_t cbMin)
+{
+    Assert(cbMin + offInstr <= sizeof(pDis->abInstr));
 
     /*
@@ -265 +265 @@
      * been read and to make sure we don't leave unread gaps.
      */
-    if (offInstr < pCpu->cbCachedInstr)
-    {
-        Assert(offInstr + cbMin > pCpu->cbCachedInstr);
-        cbMin -= pCpu->cbCachedInstr - offInstr;
-        offInstr = pCpu->cbCachedInstr;
-    }
-    else if (offInstr > pCpu->cbCachedInstr)
-    {
-        cbMin += offInstr - pCpu->cbCachedInstr;
-        offInstr = pCpu->cbCachedInstr;
+    if (offInstr < pDis->cbCachedInstr)
+    {
+        Assert(offInstr + cbMin > pDis->cbCachedInstr);
+        cbMin -= pDis->cbCachedInstr - offInstr;
+        offInstr = pDis->cbCachedInstr;
+    }
+    else if (offInstr > pDis->cbCachedInstr)
+    {
+        cbMin += offInstr - pDis->cbCachedInstr;
+        offInstr = pDis->cbCachedInstr;
     }
 
@@ -282 +282 @@
      * DISInstrEx API.)
      */
-    int rc = pCpu->pfnReadBytes(pCpu, offInstr, cbMin, sizeof(pCpu->abInstr) - offInstr);
+    int rc = pDis->pfnReadBytes(pDis, offInstr, cbMin, sizeof(pDis->abInstr) - offInstr);
     if (RT_SUCCESS(rc))
     {
-        Assert(pCpu->cbCachedInstr >= offInstr + cbMin);
-        Assert(pCpu->cbCachedInstr <= sizeof(pCpu->abInstr));
+        Assert(pDis->cbCachedInstr >= offInstr + cbMin);
+        Assert(pDis->cbCachedInstr <= sizeof(pDis->abInstr));
     }
     else
     {
         Log(("disReadMore failed with rc=%Rrc!!\n", rc));
-        pCpu->rc = VERR_DIS_MEM_READ;
+        pDis->rc = VERR_DIS_MEM_READ;
     }
 }
@@ -300 +300 @@
  *
  * @returns The requested byte.
- * @param   pCpu                The disassembler state.
+ * @param   pDis                The disassembler state.
  * @param   offInstr            The offset of the byte relative to the
  *                              instruction.
  */
-DECL_NO_INLINE(static, uint8_t) disReadByteSlow(PDISCPUSTATE pCpu, size_t offInstr)
+DECL_NO_INLINE(static, uint8_t) disReadByteSlow(PDISCPUSTATE pDis, size_t offInstr)
 {
     if (RT_UNLIKELY(offInstr >= DIS_MAX_INSTR_LENGTH))
     {
         Log(("disReadByte: too long instruction...\n"));
-        pCpu->rc = VERR_DIS_TOO_LONG_INSTR;
+        pDis->rc = VERR_DIS_TOO_LONG_INSTR;
         return 0;
     }
 
-    disReadMore(pCpu, (uint8_t)offInstr, 1);
-    return pCpu->abInstr[offInstr];
+    disReadMore(pDis, (uint8_t)offInstr, 1);
+    return pDis->abInstr[offInstr];
 }
 
@@ -322 +322 @@
  *
  * @returns The requested byte.
- * @param   pCpu                The disassembler state.
+ * @param   pDis                The disassembler state.
  * @param   uAddress            The address.
  */
-DECLINLINE(uint8_t) disReadByte(PDISCPUSTATE pCpu, size_t offInstr)
-{
-    if (RT_UNLIKELY(offInstr >= pCpu->cbCachedInstr))
-        return disReadByteSlow(pCpu, offInstr);
-
-    return pCpu->abInstr[offInstr];
+DECLINLINE(uint8_t) disReadByte(PDISCPUSTATE pDis, size_t offInstr)
+{
+    if (RT_UNLIKELY(offInstr >= pDis->cbCachedInstr))
+        return disReadByteSlow(pDis, offInstr);
+
+    return pDis->abInstr[offInstr];
 }
 
@@ -338 +338 @@
  *
  * @returns The requested word.
- * @param   pCpu                The disassembler state.
+ * @param   pDis                The disassembler state.
  * @param   offInstr            The offset of the word relative to the
  *                              instruction.
  */
-DECL_NO_INLINE(static, uint16_t) disReadWordSlow(PDISCPUSTATE pCpu, size_t offInstr)
+DECL_NO_INLINE(static, uint16_t) disReadWordSlow(PDISCPUSTATE pDis, size_t offInstr)
 {
     if (RT_UNLIKELY(offInstr + 2 > DIS_MAX_INSTR_LENGTH))
     {
         Log(("disReadWord: too long instruction...\n"));
-        pCpu->rc = VERR_DIS_TOO_LONG_INSTR;
+        pDis->rc = VERR_DIS_TOO_LONG_INSTR;
         if (offInstr < DIS_MAX_INSTR_LENGTH)
-            return pCpu->abInstr[offInstr];
+            return pDis->abInstr[offInstr];
         return 0;
     }
 
-    disReadMore(pCpu, (uint8_t)offInstr, 2);
+    disReadMore(pDis, (uint8_t)offInstr, 2);
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint16_t const *)&pCpu->abInstr[offInstr];
+    return *(uint16_t const *)&pDis->abInstr[offInstr];
 #else
-    return RT_MAKE_U16(pCpu->abInstr[offInstr], pCpu->abInstr[offInstr + 1]);
+    return RT_MAKE_U16(pDis->abInstr[offInstr], pDis->abInstr[offInstr + 1]);
 #endif
 }
@@ -366 +366 @@
  *
  * @returns The requested word.
- * @param   pCpu                The disassembler state.
+ * @param   pDis                The disassembler state.
  * @param   offInstr            The offset of the qword relative to the
  *                              instruction.
  */
-DECLINLINE(uint16_t) disReadWord(PDISCPUSTATE pCpu, size_t offInstr)
-{
-    if (RT_UNLIKELY(offInstr + 2 > pCpu->cbCachedInstr))
-        return disReadWordSlow(pCpu, offInstr);
+DECLINLINE(uint16_t) disReadWord(PDISCPUSTATE pDis, size_t offInstr)
+{
+    if (RT_UNLIKELY(offInstr + 2 > pDis->cbCachedInstr))
+        return disReadWordSlow(pDis, offInstr);
 
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint16_t const *)&pCpu->abInstr[offInstr];
+    return *(uint16_t const *)&pDis->abInstr[offInstr];
 #else
-    return RT_MAKE_U16(pCpu->abInstr[offInstr], pCpu->abInstr[offInstr + 1]);
+    return RT_MAKE_U16(pDis->abInstr[offInstr], pDis->abInstr[offInstr + 1]);
 #endif
 }
@@ -387 +387 @@
  *
  * @returns The requested dword.
- * @param   pCpu                The disassembler state.
+ * @param   pDis                The disassembler state.
  * @param   offInstr            The offset of the dword relative to the
  *                              instruction.
  */
-DECL_NO_INLINE(static, uint32_t) disReadDWordSlow(PDISCPUSTATE pCpu, size_t offInstr)
+DECL_NO_INLINE(static, uint32_t) disReadDWordSlow(PDISCPUSTATE pDis, size_t offInstr)
 {
     if (RT_UNLIKELY(offInstr + 4 > DIS_MAX_INSTR_LENGTH))
     {
         Log(("disReadDWord: too long instruction...\n"));
-        pCpu->rc = VERR_DIS_TOO_LONG_INSTR;
+        pDis->rc = VERR_DIS_TOO_LONG_INSTR;
         switch ((RTUINTPTR)DIS_MAX_INSTR_LENGTH - offInstr)
         {
             case 1:
-                return RT_MAKE_U32_FROM_U8(pCpu->abInstr[offInstr], 0, 0, 0);
+                return RT_MAKE_U32_FROM_U8(pDis->abInstr[offInstr], 0, 0, 0);
             case 2:
-                return RT_MAKE_U32_FROM_U8(pCpu->abInstr[offInstr], pCpu->abInstr[offInstr + 1], 0, 0);
+                return RT_MAKE_U32_FROM_U8(pDis->abInstr[offInstr], pDis->abInstr[offInstr + 1], 0, 0);
             case 3:
-                return RT_MAKE_U32_FROM_U8(pCpu->abInstr[offInstr], pCpu->abInstr[offInstr + 1], pCpu->abInstr[offInstr + 2], 0);
+                return RT_MAKE_U32_FROM_U8(pDis->abInstr[offInstr], pDis->abInstr[offInstr + 1], pDis->abInstr[offInstr + 2], 0);
         }
         return 0;
     }
 
-    disReadMore(pCpu, (uint8_t)offInstr, 4);
+    disReadMore(pDis, (uint8_t)offInstr, 4);
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint32_t const *)&pCpu->abInstr[offInstr];
+    return *(uint32_t const *)&pDis->abInstr[offInstr];
 #else
-    return RT_MAKE_U32_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
-                               pCpu->abInstr[offInstr + 2], pCpu->abInstr[offInstr + 3]);
+    return RT_MAKE_U32_FROM_U8(pDis->abInstr[offInstr    ], pDis->abInstr[offInstr + 1],
+                               pDis->abInstr[offInstr + 2], pDis->abInstr[offInstr + 3]);
 #endif
 }
@@ -423 +423 @@
  *
  * @returns The requested dword.
- * @param   pCpu                The disassembler state.
+ * @param   pDis                The disassembler state.
  * @param   offInstr            The offset of the qword relative to the
  *                              instruction.
  */
-DECLINLINE(uint32_t) disReadDWord(PDISCPUSTATE pCpu, size_t offInstr)
-{
-    if (RT_UNLIKELY(offInstr + 4 > pCpu->cbCachedInstr))
-        return disReadDWordSlow(pCpu, offInstr);
+DECLINLINE(uint32_t) disReadDWord(PDISCPUSTATE pDis, size_t offInstr)
+{
+    if (RT_UNLIKELY(offInstr + 4 > pDis->cbCachedInstr))
+        return disReadDWordSlow(pDis, offInstr);
 
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint32_t const *)&pCpu->abInstr[offInstr];
+    return *(uint32_t const *)&pDis->abInstr[offInstr];
 #else
-    return RT_MAKE_U32_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
-                               pCpu->abInstr[offInstr + 2], pCpu->abInstr[offInstr + 3]);
+    return RT_MAKE_U32_FROM_U8(pDis->abInstr[offInstr    ], pDis->abInstr[offInstr + 1],
+                               pDis->abInstr[offInstr + 2], pDis->abInstr[offInstr + 3]);
 #endif
 }
@@ -445 +445 @@
  *
  * @returns The requested qword.
- * @param   pCpu                The disassembler state.
+ * @param   pDis                The disassembler state.
  * @param   offInstr            The offset of the qword relative to the
  *                              instruction.
  */
-DECL_NO_INLINE(static, uint64_t) disReadQWordSlow(PDISCPUSTATE pCpu, size_t offInstr)
+DECL_NO_INLINE(static, uint64_t) disReadQWordSlow(PDISCPUSTATE pDis, size_t offInstr)
 {
     if (RT_UNLIKELY(offInstr + 8 > DIS_MAX_INSTR_LENGTH))
     {
         Log(("disReadQWord: too long instruction...\n"));
-        pCpu->rc = VERR_DIS_TOO_LONG_INSTR;
+        pDis->rc = VERR_DIS_TOO_LONG_INSTR;
         switch ((RTUINTPTR)DIS_MAX_INSTR_LENGTH - offInstr)
         {
             case 1:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr], 0, 0, 0,   0, 0, 0, 0);
+                return RT_MAKE_U64_FROM_U8(pDis->abInstr[offInstr], 0, 0, 0,   0, 0, 0, 0);
             case 2:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr], pCpu->abInstr[offInstr + 1], 0, 0,   0, 0, 0, 0);
+                return RT_MAKE_U64_FROM_U8(pDis->abInstr[offInstr], pDis->abInstr[offInstr + 1], 0, 0,   0, 0, 0, 0);
             case 3:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
-                                           pCpu->abInstr[offInstr + 2], 0,   0, 0, 0, 0);
+                return RT_MAKE_U64_FROM_U8(pDis->abInstr[offInstr    ], pDis->abInstr[offInstr + 1],
+                                           pDis->abInstr[offInstr + 2], 0,   0, 0, 0, 0);
             case 4:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
-                                           pCpu->abInstr[offInstr + 2], pCpu->abInstr[offInstr + 3],
-                                           pCpu->abInstr[offInstr + 4], 0, 0, 0);
+                return RT_MAKE_U64_FROM_U8(pDis->abInstr[offInstr    ], pDis->abInstr[offInstr + 1],
+                                           pDis->abInstr[offInstr + 2], pDis->abInstr[offInstr + 3],
+                                           pDis->abInstr[offInstr + 4], 0, 0, 0);
             case 5:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
-                                           pCpu->abInstr[offInstr + 2], pCpu->abInstr[offInstr + 3],
-                                           pCpu->abInstr[offInstr + 4], pCpu->abInstr[offInstr + 5], 0, 0);
+                return RT_MAKE_U64_FROM_U8(pDis->abInstr[offInstr    ], pDis->abInstr[offInstr + 1],
+                                           pDis->abInstr[offInstr + 2], pDis->abInstr[offInstr + 3],
+                                           pDis->abInstr[offInstr + 4], pDis->abInstr[offInstr + 5], 0, 0);
             case 6:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
-                                           pCpu->abInstr[offInstr + 2], pCpu->abInstr[offInstr + 3],
-                                           pCpu->abInstr[offInstr + 4], pCpu->abInstr[offInstr + 5],
-                                           pCpu->abInstr[offInstr + 6], 0);
+                return RT_MAKE_U64_FROM_U8(pDis->abInstr[offInstr    ], pDis->abInstr[offInstr + 1],
+                                           pDis->abInstr[offInstr + 2], pDis->abInstr[offInstr + 3],
+                                           pDis->abInstr[offInstr + 4], pDis->abInstr[offInstr + 5],
+                                           pDis->abInstr[offInstr + 6], 0);
         }
         return 0;
     }
 
-    disReadMore(pCpu, (uint8_t)offInstr, 8);
+    disReadMore(pDis, (uint8_t)offInstr, 8);
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint64_t const *)&pCpu->abInstr[offInstr];
+    return *(uint64_t const *)&pDis->abInstr[offInstr];
 #else
-    return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
-                               pCpu->abInstr[offInstr + 2], pCpu->abInstr[offInstr + 3],
-                               pCpu->abInstr[offInstr + 4], pCpu->abInstr[offInstr + 5],
-                               pCpu->abInstr[offInstr + 6], pCpu->abInstr[offInstr + 7]);
+    return RT_MAKE_U64_FROM_U8(pDis->abInstr[offInstr    ], pDis->abInstr[offInstr + 1],
+                               pDis->abInstr[offInstr + 2], pDis->abInstr[offInstr + 3],
+                               pDis->abInstr[offInstr + 4], pDis->abInstr[offInstr + 5],
+                               pDis->abInstr[offInstr + 6], pDis->abInstr[offInstr + 7]);
 #endif
 }
@@ -497 +497 @@
  *
  * @returns The requested qword.
- * @param   pCpu                The disassembler state.
+ * @param   pDis                The disassembler state.
  * @param   uAddress            The address.
  */
-DECLINLINE(uint64_t) disReadQWord(PDISCPUSTATE pCpu, size_t offInstr)
-{
-    if (RT_UNLIKELY(offInstr + 8 > pCpu->cbCachedInstr))
-        return disReadQWordSlow(pCpu, offInstr);
+DECLINLINE(uint64_t) disReadQWord(PDISCPUSTATE pDis, size_t offInstr)
+{
+    if (RT_UNLIKELY(offInstr + 8 > pDis->cbCachedInstr))
+        return disReadQWordSlow(pDis, offInstr);
 
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint64_t const *)&pCpu->abInstr[offInstr];
+    return *(uint64_t const *)&pDis->abInstr[offInstr];
 #else
-    return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
-                               pCpu->abInstr[offInstr + 2], pCpu->abInstr[offInstr + 3],
-                               pCpu->abInstr[offInstr + 4], pCpu->abInstr[offInstr + 5],
-                               pCpu->abInstr[offInstr + 6], pCpu->abInstr[offInstr + 7]);
+    return RT_MAKE_U64_FROM_U8(pDis->abInstr[offInstr    ], pDis->abInstr[offInstr + 1],
+                               pDis->abInstr[offInstr + 2], pDis->abInstr[offInstr + 3],
+                               pDis->abInstr[offInstr + 4], pDis->abInstr[offInstr + 5],
+                               pDis->abInstr[offInstr + 6], pDis->abInstr[offInstr + 7]);
 #endif
 }
@@ -519 +519 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t disParseInstruction(size_t offInstr, PCDISOPCODE pOp, PDISCPUSTATE pCpu)
+static size_t disParseInstruction(size_t offInstr, PCDISOPCODE pOp, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     bool fFiltered = false;
 
-    Assert(pOp); Assert(pCpu);
+    Assert(pOp); Assert(pDis);
 
     // Store the opcode format string for disasmPrintf
-    pCpu->pCurInstr = pOp;
+    pDis->pCurInstr = pOp;
 
     /*
@@ -533 +533 @@
      * Note! Multibyte opcodes are always marked harmless until the final byte.
      */
-    if ((pOp->fOpType & pCpu->fFilter) == 0)
+    if ((pOp->fOpType & pDis->fFilter) == 0)
     {
         fFiltered = true;
-        pCpu->pfnDisasmFnTable = g_apfnCalcSize;
+        pDis->pfnDisasmFnTable = g_apfnCalcSize;
     }
     else
     {
         /* Not filtered out -> full disassembly */
-        pCpu->pfnDisasmFnTable = g_apfnFullDisasm;
+        pDis->pfnDisasmFnTable = g_apfnFullDisasm;
     }
 
     // Should contain the parameter type on input
-    pCpu->Param1.fParam = pOp->fParam1;
-    pCpu->Param2.fParam = pOp->fParam2;
-    pCpu->Param3.fParam = pOp->fParam3;
+    pDis->Param1.fParam = pOp->fParam1;
+    pDis->Param2.fParam = pOp->fParam2;
+    pDis->Param3.fParam = pOp->fParam3;
 
     /* Correct the operand size if the instruction is marked as forced or default 64 bits */
-    if (pCpu->uCpuMode == DISCPUMODE_64BIT)
+    if (pDis->uCpuMode == DISCPUMODE_64BIT)
     {
         if (pOp->fOpType & DISOPTYPE_FORCED_64_OP_SIZE)
-            pCpu->uOpMode = DISCPUMODE_64BIT;
+            pDis->uOpMode = DISCPUMODE_64BIT;
         else
         if (    (pOp->fOpType & DISOPTYPE_DEFAULT_64_OP_SIZE)
-            &&  !(pCpu->fPrefix & DISPREFIX_OPSIZE))
-            pCpu->uOpMode = DISCPUMODE_64BIT;
+            &&  !(pDis->fPrefix & DISPREFIX_OPSIZE))
+            pDis->uOpMode = DISCPUMODE_64BIT;
     }
     else
@@ -563 +563 @@
     {
         /* Forced 32 bits operand size for certain instructions (mov crx, mov drx). */
-        Assert(pCpu->uCpuMode != DISCPUMODE_64BIT);
-        pCpu->uOpMode = DISCPUMODE_32BIT;
+        Assert(pDis->uCpuMode != DISCPUMODE_64BIT);
+        pDis->uOpMode = DISCPUMODE_32BIT;
     }
 
     if (pOp->idxParse1 != IDX_ParseNop)
     {
-        size += pCpu->pfnDisasmFnTable[pOp->idxParse1](offInstr, pOp, &pCpu->Param1, pCpu);
-        if (fFiltered == false) pCpu->Param1.cb = DISGetParamSize(pCpu, &pCpu->Param1);
+        size += pDis->pfnDisasmFnTable[pOp->idxParse1](offInstr, pOp, &pDis->Param1, pDis);
+        if (fFiltered == false) pDis->Param1.cb = DISGetParamSize(pDis, &pDis->Param1);
     }
 
     if (pOp->idxParse2 != IDX_ParseNop)
     {
-        size += pCpu->pfnDisasmFnTable[pOp->idxParse2](offInstr+size, pOp, &pCpu->Param2, pCpu);
-        if (fFiltered == false) pCpu->Param2.cb = DISGetParamSize(pCpu, &pCpu->Param2);
+        size += pDis->pfnDisasmFnTable[pOp->idxParse2](offInstr+size, pOp, &pDis->Param2, pDis);
+        if (fFiltered == false) pDis->Param2.cb = DISGetParamSize(pDis, &pDis->Param2);
     }
 
     if (pOp->idxParse3 != IDX_ParseNop)
     {
-        size += pCpu->pfnDisasmFnTable[pOp->idxParse3](offInstr+size, pOp, &pCpu->Param3, pCpu);
-        if (fFiltered == false) pCpu->Param3.cb = DISGetParamSize(pCpu, &pCpu->Param3);
+        size += pDis->pfnDisasmFnTable[pOp->idxParse3](offInstr+size, pOp, &pDis->Param3, pDis);
+        if (fFiltered == false) pDis->Param3.cb = DISGetParamSize(pDis, &pDis->Param3);
     }
     // else simple one byte instruction
@@ -591 +591 @@
 /* Floating point opcode parsing */
 //*****************************************************************************
-static size_t ParseEscFP(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseEscFP(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     int index;
@@ -599 +599 @@
     NOREF(pOp);
 
-    ModRM = disReadByte(pCpu, offInstr);
-
-    index = pCpu->bOpCode - 0xD8;
+    ModRM = disReadByte(pDis, offInstr);
+
+    index = pDis->bOpCode - 0xD8;
     if (ModRM <= 0xBF)
     {
         fpop            = &(g_apMapX86_FP_Low[index])[MODRM_REG(ModRM)];
-        pCpu->pCurInstr = (PCDISOPCODE)fpop;
+        pDis->pCurInstr = (PCDISOPCODE)fpop;
 
         // Should contain the parameter type on input
-        pCpu->Param1.fParam = fpop->fParam1;
-        pCpu->Param2.fParam = fpop->fParam2;
+        pDis->Param1.fParam = fpop->fParam1;
+        pDis->Param2.fParam = fpop->fParam2;
     }
     else
     {
         fpop            = &(g_apMapX86_FP_High[index])[ModRM - 0xC0];
-        pCpu->pCurInstr = (PCDISOPCODE)fpop;
+        pDis->pCurInstr = (PCDISOPCODE)fpop;
     }
 
@@ -621 +621 @@
      * @note Multibyte opcodes are always marked harmless until the final byte.
      */
-    if ((fpop->fOpType & pCpu->fFilter) == 0)
-        pCpu->pfnDisasmFnTable = g_apfnCalcSize;
+    if ((fpop->fOpType & pDis->fFilter) == 0)
+        pDis->pfnDisasmFnTable = g_apfnCalcSize;
     else
         /* Not filtered out -> full disassembly */
-        pCpu->pfnDisasmFnTable = g_apfnFullDisasm;
+        pDis->pfnDisasmFnTable = g_apfnFullDisasm;
 
     /* Correct the operand size if the instruction is marked as forced or default 64 bits */
-    if (pCpu->uCpuMode == DISCPUMODE_64BIT)
+    if (pDis->uCpuMode == DISCPUMODE_64BIT)
     {
         /* Note: redundant, but just in case this ever changes */
         if (fpop->fOpType & DISOPTYPE_FORCED_64_OP_SIZE)
-            pCpu->uOpMode = DISCPUMODE_64BIT;
+            pDis->uOpMode = DISCPUMODE_64BIT;
         else
         if (    (fpop->fOpType & DISOPTYPE_DEFAULT_64_OP_SIZE)
-            &&  !(pCpu->fPrefix & DISPREFIX_OPSIZE))
-            pCpu->uOpMode = DISCPUMODE_64BIT;
+            &&  !(pDis->fPrefix & DISPREFIX_OPSIZE))
+            pDis->uOpMode = DISCPUMODE_64BIT;
     }
 
@@ -644 +644 @@
 
     if (fpop->idxParse1 != IDX_ParseNop)
-        size += pCpu->pfnDisasmFnTable[fpop->idxParse1](offInstr+size, (PCDISOPCODE)fpop, pParam, pCpu);
+        size += pDis->pfnDisasmFnTable[fpop->idxParse1](offInstr+size, (PCDISOPCODE)fpop, pParam, pDis);
 
     if (fpop->idxParse2 != IDX_ParseNop)
-        size += pCpu->pfnDisasmFnTable[fpop->idxParse2](offInstr+size, (PCDISOPCODE)fpop, pParam, pCpu);
+        size += pDis->pfnDisasmFnTable[fpop->idxParse2](offInstr+size, (PCDISOPCODE)fpop, pParam, pDis);
 
     return size;
@@ -656 +656 @@
 // Scale  Index  Base
 //*****************************************************************************
-static void UseSIB(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static void UseSIB(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr); NOREF(pOp);
 
-    unsigned scale = pCpu->SIB.Bits.Scale;
-    unsigned base  = pCpu->SIB.Bits.Base;
-    unsigned index = pCpu->SIB.Bits.Index;
+    unsigned scale = pDis->SIB.Bits.Scale;
+    unsigned base  = pDis->SIB.Bits.Base;
+    unsigned index = pDis->SIB.Bits.Index;
 
     unsigned regtype;
-    if (pCpu->uAddrMode == DISCPUMODE_32BIT)
+    if (pDis->uAddrMode == DISCPUMODE_32BIT)
         regtype    = DISUSE_REG_GEN32;
     else
@@ -682 +682 @@
     }
 
-    if (base == 5 && pCpu->ModRM.Bits.Mod == 0)
+    if (base == 5 && pDis->ModRM.Bits.Mod == 0)
     {
         // [scaled index] + disp32
-        if (pCpu->uAddrMode == DISCPUMODE_32BIT)
+        if (pDis->uAddrMode == DISCPUMODE_32BIT)
         {
             pParam->fUse |= DISUSE_DISPLACEMENT32;
-            pParam->uDisp.i32 = pCpu->i32SibDisp;
+            pParam->uDisp.i32 = pDis->i32SibDisp;
         }
         else
         {   /* sign-extend to 64 bits */
             pParam->fUse |= DISUSE_DISPLACEMENT64;
-            pParam->uDisp.i64 = pCpu->i32SibDisp;
+            pParam->uDisp.i64 = pDis->i32SibDisp;
         }
     }
@@ -705 +705 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseSIB(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseSIB(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     unsigned size = sizeof(uint8_t);
@@ -711 +711 @@
     NOREF(pOp); NOREF(pParam);
 
-    SIB = disReadByte(pCpu, offInstr);
+    SIB = disReadByte(pDis, offInstr);
     offInstr += size;
 
-    pCpu->SIB.Bits.Base  = SIB_BASE(SIB);
-    pCpu->SIB.Bits.Index = SIB_INDEX(SIB);
-    pCpu->SIB.Bits.Scale = SIB_SCALE(SIB);
-
-    if (pCpu->fPrefix & DISPREFIX_REX)
+    pDis->SIB.Bits.Base  = SIB_BASE(SIB);
+    pDis->SIB.Bits.Index = SIB_INDEX(SIB);
+    pDis->SIB.Bits.Scale = SIB_SCALE(SIB);
+
+    if (pDis->fPrefix & DISPREFIX_REX)
     {
         /* REX.B extends the Base field if not scaled index + disp32 */
-        if (!(pCpu->SIB.Bits.Base == 5 && pCpu->ModRM.Bits.Mod == 0))
-            pCpu->SIB.Bits.Base  |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
-
-        pCpu->SIB.Bits.Index |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_X)) << 3);
-    }
-
-    if (    pCpu->SIB.Bits.Base == 5
-        &&  pCpu->ModRM.Bits.Mod == 0)
+        if (!(pDis->SIB.Bits.Base == 5 && pDis->ModRM.Bits.Mod == 0))
+            pDis->SIB.Bits.Base  |= ((!!(pDis->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
+
+        pDis->SIB.Bits.Index |= ((!!(pDis->fRexPrefix & DISPREFIX_REX_FLAGS_X)) << 3);
+    }
+
+    if (    pDis->SIB.Bits.Base == 5
+        &&  pDis->ModRM.Bits.Mod == 0)
     {
         /* Additional 32 bits displacement. No change in long mode. */
-        pCpu->i32SibDisp = disReadDWord(pCpu, offInstr);
+        pDis->i32SibDisp = disReadDWord(pDis, offInstr);
         size += sizeof(int32_t);
     }
@@ -738 +738 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseSIB_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseSIB_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     unsigned size = sizeof(uint8_t);
@@ -744 +744 @@
     NOREF(pOp); NOREF(pParam);
 
-    SIB = disReadByte(pCpu, offInstr);
-
-    pCpu->SIB.Bits.Base  = SIB_BASE(SIB);
-    pCpu->SIB.Bits.Index = SIB_INDEX(SIB);
-    pCpu->SIB.Bits.Scale = SIB_SCALE(SIB);
-
-    if (pCpu->fPrefix & DISPREFIX_REX)
+    SIB = disReadByte(pDis, offInstr);
+
+    pDis->SIB.Bits.Base  = SIB_BASE(SIB);
+    pDis->SIB.Bits.Index = SIB_INDEX(SIB);
+    pDis->SIB.Bits.Scale = SIB_SCALE(SIB);
+
+    if (pDis->fPrefix & DISPREFIX_REX)
     {
         /* REX.B extends the Base field. */
-        pCpu->SIB.Bits.Base  |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
+        pDis->SIB.Bits.Base  |= ((!!(pDis->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
         /* REX.X extends the Index field. */
-        pCpu->SIB.Bits.Index |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_X)) << 3);
-    }
-
-    if (    pCpu->SIB.Bits.Base == 5
-        &&  pCpu->ModRM.Bits.Mod == 0)
+        pDis->SIB.Bits.Index |= ((!!(pDis->fRexPrefix & DISPREFIX_REX_FLAGS_X)) << 3);
+    }
+
+    if (    pDis->SIB.Bits.Base == 5
+        &&  pDis->ModRM.Bits.Mod == 0)
     {
         /* Additional 32 bits displacement. No change in long mode. */
@@ -771 +771 @@
 // Mod    Reg/Opcode  R/M
 //*****************************************************************************
-static size_t UseModRM(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t UseModRM(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     unsigned vtype = OP_PARM_VTYPE(pParam->fParam);
-    unsigned reg = pCpu->ModRM.Bits.Reg;
-    unsigned mod = pCpu->ModRM.Bits.Mod;
-    unsigned rm  = pCpu->ModRM.Bits.Rm;
+    unsigned reg = pDis->ModRM.Bits.Reg;
+    unsigned mod = pDis->ModRM.Bits.Mod;
+    unsigned rm  = pDis->ModRM.Bits.Rm;
 
     switch (vtype)
     {
     case OP_PARM_G: //general purpose register
-        disasmModRMReg(pCpu, pOp, reg, pParam, 0);
+        disasmModRMReg(pDis, pOp, reg, pParam, 0);
         return 0;
 
@@ -792 +792 @@
                 pParam->fUse |= DISUSE_REG_CR;
 
-                if (    pCpu->pCurInstr->uOpcode == OP_MOV_CR
-                    &&  pCpu->uOpMode == DISCPUMODE_32BIT
-                    &&  (pCpu->fPrefix & DISPREFIX_LOCK))
+                if (    pDis->pCurInstr->uOpcode == OP_MOV_CR
+                    &&  pDis->uOpMode == DISCPUMODE_32BIT
+                    &&  (pDis->fPrefix & DISPREFIX_LOCK))
                 {
-                    pCpu->fPrefix &= ~DISPREFIX_LOCK;
+                    pDis->fPrefix &= ~DISPREFIX_LOCK;
                     pParam->Base.idxCtrlReg = DISCREG_CR8;
                 }
@@ -816 +816 @@
             case OP_PARM_S: //segment register
                 reg &= 7;   /* REX.R has no effect here */
-                disasmModRMSReg(pCpu, pOp, reg, pParam);
+                disasmModRMSReg(pDis, pOp, reg, pParam);
                 pParam->fUse |= DISUSE_REG_SEG;
                 return 0;
@@ -842 +842 @@
     /* @todo bound */
 
-    if (pCpu->uAddrMode != DISCPUMODE_16BIT)
-    {
-        Assert(pCpu->uAddrMode == DISCPUMODE_32BIT || pCpu->uAddrMode == DISCPUMODE_64BIT);
+    if (pDis->uAddrMode != DISCPUMODE_16BIT)
+    {
+        Assert(pDis->uAddrMode == DISCPUMODE_32BIT || pDis->uAddrMode == DISCPUMODE_64BIT);
 
         /*
@@ -854 +854 @@
             if (rm == 4)
             {   /* SIB byte follows ModRM */
-                UseSIB(offInstr, pOp, pParam, pCpu);
+                UseSIB(offInstr, pOp, pParam, pDis);
             }
             else
@@ -860 +860 @@
             {
                 /* 32 bits displacement */
-                if (pCpu->uCpuMode != DISCPUMODE_64BIT)
+                if (pDis->uCpuMode != DISCPUMODE_64BIT)
                 {
                     pParam->fUse |= DISUSE_DISPLACEMENT32;
-                    pParam->uDisp.i32 = pCpu->i32SibDisp;
+                    pParam->uDisp.i32 = pDis->i32SibDisp;
                 }
                 else
                 {
                     pParam->fUse |= DISUSE_RIPDISPLACEMENT32;
-                    pParam->uDisp.i32 = pCpu->i32SibDisp;
+                    pParam->uDisp.i32 = pDis->i32SibDisp;
                 }
             }
@@ -874 +874 @@
             {   //register address
                 pParam->fUse |= DISUSE_BASE;
-                disasmModRMReg(pCpu, pOp, rm, pParam, 1);
+                disasmModRMReg(pDis, pOp, rm, pParam, 1);
             }
             break;
@@ -880 +880 @@
         case 1: //effective address + 8 bits displacement
             if (rm == 4) {//SIB byte follows ModRM
-                UseSIB(offInstr, pOp, pParam, pCpu);
+                UseSIB(offInstr, pOp, pParam, pDis);
             }
             else
             {
                 pParam->fUse |= DISUSE_BASE;
-                disasmModRMReg(pCpu, pOp, rm, pParam, 1);
+                disasmModRMReg(pDis, pOp, rm, pParam, 1);
             }
-            pParam->uDisp.i8 = pCpu->i32SibDisp;
+            pParam->uDisp.i8 = pDis->i32SibDisp;
             pParam->fUse |= DISUSE_DISPLACEMENT8;
             break;
@@ -893 +893 @@
         case 2: //effective address + 32 bits displacement
             if (rm == 4) {//SIB byte follows ModRM
-                UseSIB(offInstr, pOp, pParam, pCpu);
+                UseSIB(offInstr, pOp, pParam, pDis);
             }
             else
             {
                 pParam->fUse |= DISUSE_BASE;
-                disasmModRMReg(pCpu, pOp, rm, pParam, 1);
+                disasmModRMReg(pDis, pOp, rm, pParam, 1);
             }
-            pParam->uDisp.i32 = pCpu->i32SibDisp;
+            pParam->uDisp.i32 = pDis->i32SibDisp;
             pParam->fUse |= DISUSE_DISPLACEMENT32;
             break;
 
         case 3: //registers
-            disasmModRMReg(pCpu, pOp, rm, pParam, 0);
+            disasmModRMReg(pDis, pOp, rm, pParam, 0);
             break;
         }
@@ -916 +916 @@
             if (rm == 6)
             {//16 bits displacement
-                pParam->uDisp.i16 = pCpu->i32SibDisp;
+                pParam->uDisp.i16 = pDis->i32SibDisp;
                 pParam->fUse |= DISUSE_DISPLACEMENT16;
             }
@@ -922 +922 @@
             {
                 pParam->fUse |= DISUSE_BASE;
-                disasmModRMReg16(pCpu, pOp, rm, pParam);
+                disasmModRMReg16(pDis, pOp, rm, pParam);
             }
             break;
 
         case 1: //effective address + 8 bits displacement
-            disasmModRMReg16(pCpu, pOp, rm, pParam);
-            pParam->uDisp.i8 = pCpu->i32SibDisp;
+            disasmModRMReg16(pDis, pOp, rm, pParam);
+            pParam->uDisp.i8 = pDis->i32SibDisp;
             pParam->fUse |= DISUSE_BASE | DISUSE_DISPLACEMENT8;
             break;
 
         case 2: //effective address + 16 bits displacement
-            disasmModRMReg16(pCpu, pOp, rm, pParam);
-            pParam->uDisp.i16 = pCpu->i32SibDisp;
+            disasmModRMReg16(pDis, pOp, rm, pParam);
+            pParam->uDisp.i16 = pDis->i32SibDisp;
             pParam->fUse |= DISUSE_BASE | DISUSE_DISPLACEMENT16;
             break;
 
         case 3: //registers
-            disasmModRMReg(pCpu, pOp, rm, pParam, 0);
+            disasmModRMReg(pDis, pOp, rm, pParam, 0);
             break;
         }
@@ -948 +948 @@
 // Query the size of the ModRM parameters and fetch the immediate data (if any)
 //*****************************************************************************
-static size_t QueryModRM(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu, size_t *pSibInc)
+static size_t QueryModRM(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis, size_t *pSibInc)
 {
     size_t sibinc;
     size_t size = 0;
-    // unsigned reg = pCpu->ModRM.Bits.Reg;
-    unsigned mod = pCpu->ModRM.Bits.Mod;
-    unsigned rm  = pCpu->ModRM.Bits.Rm;
+    // unsigned reg = pDis->ModRM.Bits.Reg;
+    unsigned mod = pDis->ModRM.Bits.Mod;
+    unsigned rm  = pDis->ModRM.Bits.Rm;
 
     if (!pSibInc)
@@ -961 +961 @@
     *pSibInc = 0;
 
-    if (pCpu->uAddrMode != DISCPUMODE_16BIT)
-    {
-        Assert(pCpu->uAddrMode == DISCPUMODE_32BIT || pCpu->uAddrMode == DISCPUMODE_64BIT);
+    if (pDis->uAddrMode != DISCPUMODE_16BIT)
+    {
+        Assert(pDis->uAddrMode == DISCPUMODE_32BIT || pDis->uAddrMode == DISCPUMODE_64BIT);
 
         /*
@@ -970 +970 @@
         if (mod != 3 && rm == 4)
         {   /* SIB byte follows ModRM */
-            *pSibInc = ParseSIB(offInstr, pOp, pParam, pCpu);
+            *pSibInc = ParseSIB(offInstr, pOp, pParam, pDis);
             offInstr += *pSibInc;
             size += *pSibInc;
@@ -979 +979 @@
         case 0: /* Effective address */
             if (rm == 5) {  /* 32 bits displacement */
-                pCpu->i32SibDisp = disReadDWord(pCpu, offInstr);
+                pDis->i32SibDisp = disReadDWord(pDis, offInstr);
                 size += sizeof(int32_t);
             }
@@ -986 +986 @@
 
         case 1: /* Effective address + 8 bits displacement */
-            pCpu->i32SibDisp = (int8_t)disReadByte(pCpu, offInstr);
+            pDis->i32SibDisp = (int8_t)disReadByte(pDis, offInstr);
             size += sizeof(char);
             break;
 
         case 2: /* Effective address + 32 bits displacement */
-            pCpu->i32SibDisp = disReadDWord(pCpu, offInstr);
+            pDis->i32SibDisp = disReadDWord(pDis, offInstr);
             size += sizeof(int32_t);
             break;
@@ -1006 +1006 @@
         case 0: /* Effective address */
             if (rm == 6) {
-                pCpu->i32SibDisp = disReadWord(pCpu, offInstr);
+                pDis->i32SibDisp = disReadWord(pDis, offInstr);
                 size += sizeof(uint16_t);
             }
@@ -1013 +1013 @@
 
         case 1: /* Effective address + 8 bits displacement */
-            pCpu->i32SibDisp = (int8_t)disReadByte(pCpu, offInstr);
+            pDis->i32SibDisp = (int8_t)disReadByte(pDis, offInstr);
             size += sizeof(char);
             break;
 
         case 2: /* Effective address + 32 bits displacement */
-            pCpu->i32SibDisp = (int16_t)disReadWord(pCpu, offInstr);
+            pDis->i32SibDisp = (int16_t)disReadWord(pDis, offInstr);
             size += sizeof(uint16_t);
             break;
@@ -1031 +1031 @@
 // Query the size of the ModRM parameters and fetch the immediate data (if any)
 //*****************************************************************************
-static size_t QueryModRM_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu, size_t *pSibInc)
+static size_t QueryModRM_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis, size_t *pSibInc)
 {
     size_t sibinc;
     size_t size = 0;
-    // unsigned reg = pCpu->ModRM.Bits.Reg;
-    unsigned mod = pCpu->ModRM.Bits.Mod;
-    unsigned rm  = pCpu->ModRM.Bits.Rm;
+    // unsigned reg = pDis->ModRM.Bits.Reg;
+    unsigned mod = pDis->ModRM.Bits.Mod;
+    unsigned rm  = pDis->ModRM.Bits.Rm;
 
     if (!pSibInc)
@@ -1044 +1044 @@
     *pSibInc = 0;
 
-    if (pCpu->uAddrMode != DISCPUMODE_16BIT)
-    {
-        Assert(pCpu->uAddrMode == DISCPUMODE_32BIT || pCpu->uAddrMode == DISCPUMODE_64BIT);
+    if (pDis->uAddrMode != DISCPUMODE_16BIT)
+    {
+        Assert(pDis->uAddrMode == DISCPUMODE_32BIT || pDis->uAddrMode == DISCPUMODE_64BIT);
         /*
          * Note: displacements in long mode are 8 or 32 bits and sign-extended to 64 bits
@@ -1052 +1052 @@
         if (mod != 3 && rm == 4)
         {   /* SIB byte follows ModRM */
-            *pSibInc = ParseSIB_SizeOnly(offInstr, pOp, pParam, pCpu);
+            *pSibInc = ParseSIB_SizeOnly(offInstr, pOp, pParam, pDis);
             offInstr += *pSibInc;
             size += *pSibInc;
@@ -1106 +1106 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseIllegal(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseIllegal(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
     AssertFailed();
     return 0;
@@ -1114 +1114 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseModRM(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseModRM(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = sizeof(uint8_t);   //ModRM byte
     size_t sibinc;
 
-    unsigned ModRM = disReadByte(pCpu, offInstr);
+    unsigned ModRM = disReadByte(pDis, offInstr);
     offInstr += sizeof(uint8_t);
 
-    pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM);
-    pCpu->ModRM.Bits.Mod = MODRM_MOD(ModRM);
-    pCpu->ModRM.Bits.Reg = MODRM_REG(ModRM);
+    pDis->ModRM.Bits.Rm  = MODRM_RM(ModRM);
+    pDis->ModRM.Bits.Mod = MODRM_MOD(ModRM);
+    pDis->ModRM.Bits.Reg = MODRM_REG(ModRM);
 
     /* Disregard the mod bits for certain instructions (mov crx, mov drx).
@@ -1133 +1133 @@
      */
     if (pOp->fOpType & DISOPTYPE_MOD_FIXED_11)
-        pCpu->ModRM.Bits.Mod = 3;
-
-    if (pCpu->fPrefix & DISPREFIX_REX)
-    {
-        Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
+        pDis->ModRM.Bits.Mod = 3;
+
+    if (pDis->fPrefix & DISPREFIX_REX)
+    {
+        Assert(pDis->uCpuMode == DISCPUMODE_64BIT);
 
         /* REX.R extends the Reg field. */
-        pCpu->ModRM.Bits.Reg |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_R)) << 3);
+        pDis->ModRM.Bits.Reg |= ((!!(pDis->fRexPrefix & DISPREFIX_REX_FLAGS_R)) << 3);
 
         /* REX.B extends the Rm field if there is no SIB byte nor a 32 bits displacement */
-        if (!(    pCpu->ModRM.Bits.Mod != 3
-              &&  pCpu->ModRM.Bits.Rm  == 4)
+        if (!(    pDis->ModRM.Bits.Mod != 3
+              &&  pDis->ModRM.Bits.Rm  == 4)
             &&
-            !(    pCpu->ModRM.Bits.Mod == 0
-              &&  pCpu->ModRM.Bits.Rm  == 5))
+            !(    pDis->ModRM.Bits.Mod == 0
+              &&  pDis->ModRM.Bits.Rm  == 5))
         {
-            pCpu->ModRM.Bits.Rm |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
-        }
-    }
-    size += QueryModRM(offInstr, pOp, pParam, pCpu, &sibinc);
+            pDis->ModRM.Bits.Rm |= ((!!(pDis->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
+        }
+    }
+    size += QueryModRM(offInstr, pOp, pParam, pDis, &sibinc);
     offInstr += sibinc;
 
-    UseModRM(offInstr, pOp, pParam, pCpu);
+    UseModRM(offInstr, pOp, pParam, pDis);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseModRM_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseModRM_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = sizeof(uint8_t);   //ModRM byte
     size_t sibinc;
 
-    unsigned ModRM = disReadByte(pCpu, offInstr);
+    unsigned ModRM = disReadByte(pDis, offInstr);
     offInstr += sizeof(uint8_t);
 
-    pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM);
-    pCpu->ModRM.Bits.Mod = MODRM_MOD(ModRM);
-    pCpu->ModRM.Bits.Reg = MODRM_REG(ModRM);
+    pDis->ModRM.Bits.Rm  = MODRM_RM(ModRM);
+    pDis->ModRM.Bits.Mod = MODRM_MOD(ModRM);
+    pDis->ModRM.Bits.Reg = MODRM_REG(ModRM);
 
     /* Disregard the mod bits for certain instructions (mov crx, mov drx).
@@ -1179 +1179 @@
      */
     if (pOp->fOpType & DISOPTYPE_MOD_FIXED_11)
-        pCpu->ModRM.Bits.Mod = 3;
-
-    if (pCpu->fPrefix & DISPREFIX_REX)
-    {
-        Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
+        pDis->ModRM.Bits.Mod = 3;
+
+    if (pDis->fPrefix & DISPREFIX_REX)
+    {
+        Assert(pDis->uCpuMode == DISCPUMODE_64BIT);
 
         /* REX.R extends the Reg field. */
-        pCpu->ModRM.Bits.Reg |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_R)) << 3);
+        pDis->ModRM.Bits.Reg |= ((!!(pDis->fRexPrefix & DISPREFIX_REX_FLAGS_R)) << 3);
 
         /* REX.B extends the Rm field if there is no SIB byte nor a 32 bits displacement */
-        if (!(    pCpu->ModRM.Bits.Mod != 3
-              &&  pCpu->ModRM.Bits.Rm  == 4)
+        if (!(    pDis->ModRM.Bits.Mod != 3
+              &&  pDis->ModRM.Bits.Rm  == 4)
             &&
-            !(    pCpu->ModRM.Bits.Mod == 0
-              &&  pCpu->ModRM.Bits.Rm  == 5))
+            !(    pDis->ModRM.Bits.Mod == 0
+              &&  pDis->ModRM.Bits.Rm  == 5))
         {
-            pCpu->ModRM.Bits.Rm |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
-        }
-    }
-
-    size += QueryModRM_SizeOnly(offInstr, pOp, pParam, pCpu, &sibinc);
+            pDis->ModRM.Bits.Rm |= ((!!(pDis->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
+        }
+    }
+
+    size += QueryModRM_SizeOnly(offInstr, pOp, pParam, pDis, &sibinc);
     offInstr += sibinc;
 
@@ -1207 +1207 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseModFence(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseModFence(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     ////AssertMsgFailed(("??\n"));
     //nothing to do apparently
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
     return 0;
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmByte(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmByte(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(pOp);
-    pParam->uValue = disReadByte(pCpu, offInstr);
+    pParam->uValue = disReadByte(pDis, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE8;
     pParam->cb     = sizeof(uint8_t);
@@ -1226 +1226 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmByte_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmByte_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
     return sizeof(uint8_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmByteSX(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmByteSX(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(pOp);
-    if (pCpu->uOpMode == DISCPUMODE_32BIT)
-    {
-        pParam->uValue = (uint32_t)(int8_t)disReadByte(pCpu, offInstr);
+    if (pDis->uOpMode == DISCPUMODE_32BIT)
+    {
+        pParam->uValue = (uint32_t)(int8_t)disReadByte(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE32_SX8;
         pParam->cb     = sizeof(uint32_t);
     }
     else
-    if (pCpu->uOpMode == DISCPUMODE_64BIT)
-    {
-        pParam->uValue = (uint64_t)(int8_t)disReadByte(pCpu, offInstr);
+    if (pDis->uOpMode == DISCPUMODE_64BIT)
+    {
+        pParam->uValue = (uint64_t)(int8_t)disReadByte(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE64_SX8;
         pParam->cb     = sizeof(uint64_t);
@@ -1251 +1251 @@
     else
     {
-        pParam->uValue = (uint16_t)(int8_t)disReadByte(pCpu, offInstr);
+        pParam->uValue = (uint16_t)(int8_t)disReadByte(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE16_SX8;
         pParam->cb     = sizeof(uint16_t);
@@ -1259 +1259 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmByteSX_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmByteSX_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
     return sizeof(uint8_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmUshort(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmUshort(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(pOp);
-    pParam->uValue = disReadWord(pCpu, offInstr);
+    pParam->uValue = disReadWord(pDis, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
@@ -1276 +1276 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmUshort_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmUshort_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
     return sizeof(uint16_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmUlong(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmUlong(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(pOp);
-    pParam->uValue = disReadDWord(pCpu, offInstr);
+    pParam->uValue = disReadDWord(pDis, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE32;
     pParam->cb     = sizeof(uint32_t);
@@ -1293 +1293 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmUlong_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmUlong_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
     return sizeof(uint32_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmQword(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmQword(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(pOp);
-    pParam->uValue = disReadQWord(pCpu, offInstr);
+    pParam->uValue = disReadQWord(pDis, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE64;
     pParam->cb     = sizeof(uint64_t);
@@ -1310 +1310 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmQword_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmQword_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
     return sizeof(uint64_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmV(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmV(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(pOp);
-    if (pCpu->uOpMode == DISCPUMODE_32BIT)
-    {
-        pParam->uValue = disReadDWord(pCpu, offInstr);
+    if (pDis->uOpMode == DISCPUMODE_32BIT)
+    {
+        pParam->uValue = disReadDWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
@@ -1328 +1328 @@
     }
 
-    if (pCpu->uOpMode == DISCPUMODE_64BIT)
-    {
-        pParam->uValue = disReadQWord(pCpu, offInstr);
+    if (pDis->uOpMode == DISCPUMODE_64BIT)
+    {
+        pParam->uValue = disReadQWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
@@ -1336 +1336 @@
     }
 
-    pParam->uValue = disReadWord(pCpu, offInstr);
+    pParam->uValue = disReadWord(pDis, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
@@ -1343 +1343 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmV_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmV_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr); NOREF(pOp); NOREF(pParam);
-    if (pCpu->uOpMode == DISCPUMODE_32BIT)
+    if (pDis->uOpMode == DISCPUMODE_32BIT)
         return sizeof(uint32_t);
-    if (pCpu->uOpMode == DISCPUMODE_64BIT)
+    if (pDis->uOpMode == DISCPUMODE_64BIT)
         return sizeof(uint64_t);
     return sizeof(uint16_t);
@@ -1354 +1354 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmZ(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmZ(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(pOp);
     /* Word for 16-bit operand-size or doubleword for 32 or 64-bit operand-size. */
-    if (pCpu->uOpMode == DISCPUMODE_16BIT)
-    {
-        pParam->uValue = disReadWord(pCpu, offInstr);
+    if (pDis->uOpMode == DISCPUMODE_16BIT)
+    {
+        pParam->uValue = disReadWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE16;
         pParam->cb     = sizeof(uint16_t);
@@ -1367 +1367 @@
 
     /* 64 bits op mode means *sign* extend to 64 bits. */
-    if (pCpu->uOpMode == DISCPUMODE_64BIT)
-    {
-        pParam->uValue = (uint64_t)(int32_t)disReadDWord(pCpu, offInstr);
+    if (pDis->uOpMode == DISCPUMODE_64BIT)
+    {
+        pParam->uValue = (uint64_t)(int32_t)disReadDWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
@@ -1375 +1375 @@
     else
     {
-        pParam->uValue = disReadDWord(pCpu, offInstr);
+        pParam->uValue = disReadDWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
@@ -1383 +1383 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmZ_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmZ_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr); NOREF(pOp); NOREF(pParam);
     /* Word for 16-bit operand-size or doubleword for 32 or 64-bit operand-size. */
-    if (pCpu->uOpMode == DISCPUMODE_16BIT)
+    if (pDis->uOpMode == DISCPUMODE_16BIT)
         return sizeof(uint16_t);
     return sizeof(uint32_t);
@@ -1395 +1395 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-static size_t ParseImmBRel(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmBRel(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(pOp);
-    pParam->uValue = disReadByte(pCpu, offInstr);
+    pParam->uValue = disReadByte(pDis, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE8_REL;
     pParam->cb     = sizeof(uint8_t);
@@ -1406 +1406 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-static size_t ParseImmBRel_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmBRel_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pDis);
     return sizeof(char);
 }
@@ -1414 +1414 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-static size_t ParseImmVRel(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmVRel(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(pOp);
-    if (pCpu->uOpMode == DISCPUMODE_32BIT)
-    {
-        pParam->uValue = disReadDWord(pCpu, offInstr);
+    if (pDis->uOpMode == DISCPUMODE_32BIT)
+    {
+        pParam->uValue = disReadDWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE32_REL;
         pParam->cb     = sizeof(int32_t);
@@ -1425 +1425 @@
     }
 
-    if (pCpu->uOpMode == DISCPUMODE_64BIT)
+    if (pDis->uOpMode == DISCPUMODE_64BIT)
     {
         /* 32 bits relative immediate sign extended to 64 bits. */
-        pParam->uValue = (uint64_t)(int32_t)disReadDWord(pCpu, offInstr);
+        pParam->uValue = (uint64_t)(int32_t)disReadDWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE64_REL;
         pParam->cb     = sizeof(int64_t);
@@ -1434 +1434 @@
     }
 
-    pParam->uValue = disReadWord(pCpu, offInstr);
+    pParam->uValue = disReadWord(pDis, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE16_REL;
     pParam->cb     = sizeof(int16_t);
@@ -1442 +1442 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-static size_t ParseImmVRel_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmVRel_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr); NOREF(pOp); NOREF(pParam);
-    if (pCpu->uOpMode == DISCPUMODE_16BIT)
+    if (pDis->uOpMode == DISCPUMODE_16BIT)
         return sizeof(int16_t);
     /* Both 32 & 64 bits mode use 32 bits relative immediates. */
@@ -1452 +1452 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmAddr(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    if (pCpu->uAddrMode == DISCPUMODE_32BIT)
+static size_t ParseImmAddr(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
+{
+    if (pDis->uAddrMode == DISCPUMODE_32BIT)
     {
         if (OP_PARM_VSUBTYPE(pParam->fParam) == OP_PARM_p)
         {
             /* far 16:32 pointer */
-            pParam->uValue = disReadDWord(pCpu, offInstr);
-            *((uint32_t*)&pParam->uValue+1) = disReadWord(pCpu, offInstr+sizeof(uint32_t));
+            pParam->uValue = disReadDWord(pDis, offInstr);
+            *((uint32_t*)&pParam->uValue+1) = disReadWord(pDis, offInstr+sizeof(uint32_t));
             pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
             pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
@@ -1472 +1472 @@
          * so we treat it like displacement.
          */
-        pParam->uDisp.i32 = disReadDWord(pCpu, offInstr);
+        pParam->uDisp.i32 = disReadDWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_DISPLACEMENT32;
         pParam->cb     = sizeof(uint32_t);
@@ -1478 +1478 @@
     }
 
-    if (pCpu->uAddrMode == DISCPUMODE_64BIT)
+    if (pDis->uAddrMode == DISCPUMODE_64BIT)
     {
         Assert(OP_PARM_VSUBTYPE(pParam->fParam) != OP_PARM_p);
@@ -1487 +1487 @@
          * so we treat it like displacement.
          */
-        pParam->uDisp.i64 = disReadQWord(pCpu, offInstr);
+        pParam->uDisp.i64 = disReadQWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_DISPLACEMENT64;
         pParam->cb     = sizeof(uint64_t);
@@ -1495 +1495 @@
     {
         /* far 16:16 pointer */
-        pParam->uValue = disReadDWord(pCpu, offInstr);
+        pParam->uValue = disReadDWord(pDis, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
         pParam->cb     = 2*sizeof(uint16_t);
@@ -1507 +1507 @@
      * so we treat it like displacement.
      */
-    pParam->uDisp.i16 = disReadWord(pCpu, offInstr);
+    pParam->uDisp.i16 = disReadWord(pDis, offInstr);
     pParam->fUse  |= DISUSE_DISPLACEMENT16;
     pParam->cb     = sizeof(uint16_t);
@@ -1514 +1514 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmAddr_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmAddr_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr); NOREF(pOp);
-    if (pCpu->uAddrMode == DISCPUMODE_32BIT)
+    if (pDis->uAddrMode == DISCPUMODE_32BIT)
     {
         if (OP_PARM_VSUBTYPE(pParam->fParam) == OP_PARM_p)
@@ -1528 +1528 @@
         }
     }
-    if (pCpu->uAddrMode == DISCPUMODE_64BIT)
+    if (pDis->uAddrMode == DISCPUMODE_64BIT)
     {
         Assert(OP_PARM_VSUBTYPE(pParam->fParam) != OP_PARM_p);
@@ -1547 +1547 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmAddrF(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmAddrF(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     // immediate far pointers - only 16:16 or 16:32; determined by operand, *not* address size!
-    Assert(pCpu->uOpMode == DISCPUMODE_16BIT || pCpu->uOpMode == DISCPUMODE_32BIT);
+    Assert(pDis->uOpMode == DISCPUMODE_16BIT || pDis->uOpMode == DISCPUMODE_32BIT);
     Assert(OP_PARM_VSUBTYPE(pParam->fParam) == OP_PARM_p);
-    if (pCpu->uOpMode == DISCPUMODE_32BIT)
+    if (pDis->uOpMode == DISCPUMODE_32BIT)
     {
         // far 16:32 pointer
-        pParam->uValue = disReadDWord(pCpu, offInstr);
-        *((uint32_t*)&pParam->uValue+1) = disReadWord(pCpu, offInstr+sizeof(uint32_t));
+        pParam->uValue = disReadDWord(pDis, offInstr);
+        *((uint32_t*)&pParam->uValue+1) = disReadWord(pDis, offInstr+sizeof(uint32_t));
         pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
         pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
@@ -1563 +1563 @@
 
     // far 16:16 pointer
-    pParam->uValue = disReadDWord(pCpu, offInstr);
+    pParam->uValue = disReadDWord(pDis, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
     pParam->cb     = 2*sizeof(uint16_t);
@@ -1570 +1570 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmAddrF_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmAddrF_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr); NOREF(pOp);
     // immediate far pointers - only 16:16 or 16:32
-    Assert(pCpu->uOpMode == DISCPUMODE_16BIT || pCpu->uOpMode == DISCPUMODE_32BIT);
+    Assert(pDis->uOpMode == DISCPUMODE_16BIT || pDis->uOpMode == DISCPUMODE_32BIT);
     Assert(OP_PARM_VSUBTYPE(pParam->fParam) == OP_PARM_p);
-    if (pCpu->uOpMode == DISCPUMODE_32BIT)
+    if (pDis->uOpMode == DISCPUMODE_32BIT)
     {
         // far 16:32 pointer
@@ -1589 +1589 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseFixedReg(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseFixedReg(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr);
@@ -1611 +1611 @@
     {
         /* 32-bit EAX..EDI registers. */
-        if (pCpu->uOpMode == DISCPUMODE_32BIT)
+        if (pDis->uOpMode == DISCPUMODE_32BIT)
         {
             /* Use 32-bit registers. */
@@ -1619 +1619 @@
         }
         else
-        if (pCpu->uOpMode == DISCPUMODE_64BIT)
+        if (pDis->uOpMode == DISCPUMODE_64BIT)
         {
             /* Use 64-bit registers. */
             pParam->Base.idxGenReg = pParam->fParam - OP_PARM_REG_GEN32_START;
             if (    (pOp->fOpType & DISOPTYPE_REXB_EXTENDS_OPREG)
-                &&  pParam == &pCpu->Param1             /* ugly assumption that it only applies to the first parameter */
-                &&  (pCpu->fPrefix & DISPREFIX_REX)
-                &&  (pCpu->fRexPrefix & DISPREFIX_REX_FLAGS))
+                &&  pParam == &pDis->Param1             /* ugly assumption that it only applies to the first parameter */
+                &&  (pDis->fPrefix & DISPREFIX_REX)
+                &&  (pDis->fRexPrefix & DISPREFIX_REX_FLAGS))
                 pParam->Base.idxGenReg += 8;
 
@@ -1665 +1665 @@
         pParam->cb     = 1;
 
-        if (pCpu->uOpMode == DISCPUMODE_64BIT)
+        if (pDis->uOpMode == DISCPUMODE_64BIT)
         {
             if (    (pOp->fOpType & DISOPTYPE_REXB_EXTENDS_OPREG)
-                &&  pParam == &pCpu->Param1             /* ugly assumption that it only applies to the first parameter */
-                &&  (pCpu->fPrefix & DISPREFIX_REX)
-                &&  (pCpu->fRexPrefix & DISPREFIX_REX_FLAGS))
+                &&  pParam == &pDis->Param1             /* ugly assumption that it only applies to the first parameter */
+                &&  (pDis->fPrefix & DISPREFIX_REX)
+                &&  (pDis->fRexPrefix & DISPREFIX_REX_FLAGS))
                 pParam->Base.idxGenReg += 8;              /* least significant byte of R8-R15 */
         }
@@ -1690 +1690 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseXv(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseXv(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr);
 
     pParam->fUse |= DISUSE_POINTER_DS_BASED;
-    if (pCpu->uAddrMode == DISCPUMODE_32BIT)
+    if (pDis->uAddrMode == DISCPUMODE_32BIT)
     {
         pParam->Base.idxGenReg = DISGREG_ESI;
@@ -1701 +1701 @@
     }
     else
-    if (pCpu->uAddrMode == DISCPUMODE_64BIT)
+    if (pDis->uAddrMode == DISCPUMODE_64BIT)
     {
         pParam->Base.idxGenReg = DISGREG_RSI;
@@ -1715 +1715 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseXb(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseXb(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr); NOREF(pOp);
 
     pParam->fUse |= DISUSE_POINTER_DS_BASED;
-    if (pCpu->uAddrMode == DISCPUMODE_32BIT)
+    if (pDis->uAddrMode == DISCPUMODE_32BIT)
     {
         pParam->Base.idxGenReg = DISGREG_ESI;
@@ -1726 +1726 @@
     }
     else
-    if (pCpu->uAddrMode == DISCPUMODE_64BIT)
+    if (pDis->uAddrMode == DISCPUMODE_64BIT)
     {
         pParam->Base.idxGenReg = DISGREG_RSI;
@@ -1740 +1740 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseYv(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseYv(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr);
 
     pParam->fUse |= DISUSE_POINTER_ES_BASED;
-    if (pCpu->uAddrMode == DISCPUMODE_32BIT)
+    if (pDis->uAddrMode == DISCPUMODE_32BIT)
     {
         pParam->Base.idxGenReg = DISGREG_EDI;
@@ -1751 +1751 @@
     }
     else
-    if (pCpu->uAddrMode == DISCPUMODE_64BIT)
+    if (pDis->uAddrMode == DISCPUMODE_64BIT)
     {
         pParam->Base.idxGenReg = DISGREG_RDI;
@@ -1765 +1765 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseYb(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseYb(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     NOREF(offInstr); NOREF(pOp);
 
     pParam->fUse |= DISUSE_POINTER_ES_BASED;
-    if (pCpu->uAddrMode == DISCPUMODE_32BIT)
+    if (pDis->uAddrMode == DISCPUMODE_32BIT)
     {
         pParam->Base.idxGenReg = DISGREG_EDI;
@@ -1776 +1776 @@
     }
     else
-    if (pCpu->uAddrMode == DISCPUMODE_64BIT)
+    if (pDis->uAddrMode == DISCPUMODE_64BIT)
     {
         pParam->Base.idxGenReg = DISGREG_RDI;
@@ -1790 +1790 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseTwoByteEsc(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseTwoByteEsc(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     PCDISOPCODE   pOpcode;
@@ -1797 +1797 @@
 
     /* 2nd byte */
-    pCpu->bOpCode = disReadByte(pCpu, offInstr);
+    pDis->bOpCode = disReadByte(pDis, offInstr);
 
     /* default to the non-prefixed table. */
-    pOpcode      = &g_aTwoByteMapX86[pCpu->bOpCode];
+    pOpcode      = &g_aTwoByteMapX86[pDis->bOpCode];
 
     /* Handle opcode table extensions that rely on the address, repe or repne prefix byte.  */
     /** @todo Should we take the first or last prefix byte in case of multiple prefix bytes??? */
-    if (pCpu->bLastPrefix)
-    {
-        switch (pCpu->bLastPrefix)
+    if (pDis->bLastPrefix)
+    {
+        switch (pDis->bLastPrefix)
         {
         case OP_OPSIZE: /* 0x66 */
-            if (g_aTwoByteMapX86_PF66[pCpu->bOpCode].uOpcode != OP_INVALID)
+            if (g_aTwoByteMapX86_PF66[pDis->bOpCode].uOpcode != OP_INVALID)
             {
                 /* Table entry is valid, so use the extension table. */
-                pOpcode = &g_aTwoByteMapX86_PF66[pCpu->bOpCode];
+                pOpcode = &g_aTwoByteMapX86_PF66[pDis->bOpCode];
 
                 /* Cancel prefix changes. */
-                pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
-                pCpu->uOpMode  = pCpu->uCpuMode;
+                pDis->fPrefix &= ~DISPREFIX_OPSIZE;
+                pDis->uOpMode  = pDis->uCpuMode;
             }
             break;
 
         case OP_REPNE:   /* 0xF2 */
-            if (g_aTwoByteMapX86_PFF2[pCpu->bOpCode].uOpcode != OP_INVALID)
+            if (g_aTwoByteMapX86_PFF2[pDis->bOpCode].uOpcode != OP_INVALID)
             {
                 /* Table entry is valid, so use the extension table. */
-                pOpcode = &g_aTwoByteMapX86_PFF2[pCpu->bOpCode];
+                pOpcode = &g_aTwoByteMapX86_PFF2[pDis->bOpCode];
 
                 /* Cancel prefix changes. */
-                pCpu->fPrefix &= ~DISPREFIX_REPNE;
+                pDis->fPrefix &= ~DISPREFIX_REPNE;
             }
             break;
 
         case OP_REPE:  /* 0xF3 */
-            if (g_aTwoByteMapX86_PFF3[pCpu->bOpCode].uOpcode != OP_INVALID)
+            if (g_aTwoByteMapX86_PFF3[pDis->bOpCode].uOpcode != OP_INVALID)
             {
                 /* Table entry is valid, so use the extension table. */
-                pOpcode = &g_aTwoByteMapX86_PFF3[pCpu->bOpCode];
+                pOpcode = &g_aTwoByteMapX86_PFF3[pDis->bOpCode];
 
                 /* Cancel prefix changes. */
-                pCpu->fPrefix &= ~DISPREFIX_REP;
+                pDis->fPrefix &= ~DISPREFIX_REP;
             }
             break;
@@ -1844 +1844 @@
     }
 
-    size += disParseInstruction(offInstr+size, pOpcode, pCpu);
+    size += disParseInstruction(offInstr+size, pOpcode, pDis);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseThreeByteEsc4(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseThreeByteEsc4(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     PCDISOPCODE   pOpcode;
@@ -1856 +1856 @@
 
     /* 3rd byte */
-    pCpu->bOpCode = disReadByte(pCpu, offInstr);
+    pDis->bOpCode = disReadByte(pDis, offInstr);
 
     /* default to the non-prefixed table. */
-    if (g_apThreeByteMapX86_0F38[pCpu->bOpCode >> 4])
-    {
-        pOpcode = g_apThreeByteMapX86_0F38[pCpu->bOpCode >> 4];
-        pOpcode = &pOpcode[pCpu->bOpCode & 0xf];
+    if (g_apThreeByteMapX86_0F38[pDis->bOpCode >> 4])
+    {
+        pOpcode = g_apThreeByteMapX86_0F38[pDis->bOpCode >> 4];
+        pOpcode = &pOpcode[pDis->bOpCode & 0xf];
     }
     else
@@ -1869 +1869 @@
     /* Handle opcode table extensions that rely on the address, repne prefix byte.  */
     /** @todo Should we take the first or last prefix byte in case of multiple prefix bytes??? */
-    switch (pCpu->bLastPrefix)
+    switch (pDis->bLastPrefix)
     {
     case OP_OPSIZE: /* 0x66 */
-        if (g_apThreeByteMapX86_660F38[pCpu->bOpCode >> 4])
+        if (g_apThreeByteMapX86_660F38[pDis->bOpCode >> 4])
         {
-            pOpcode = g_apThreeByteMapX86_660F38[pCpu->bOpCode >> 4];
-            pOpcode = &pOpcode[pCpu->bOpCode & 0xf];
+            pOpcode = g_apThreeByteMapX86_660F38[pDis->bOpCode >> 4];
+            pOpcode = &pOpcode[pDis->bOpCode & 0xf];
 
             if (pOpcode->uOpcode != OP_INVALID)
@@ -1882 +1882 @@
 
                 /* Cancel prefix changes. */
-                pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
-                pCpu->uOpMode  = pCpu->uCpuMode;
+                pDis->fPrefix &= ~DISPREFIX_OPSIZE;
+                pDis->uOpMode  = pDis->uCpuMode;
             }
         }
@@ -1889 +1889 @@
 
     case OP_REPNE:   /* 0xF2 */
-        if (g_apThreeByteMapX86_F20F38[pCpu->bOpCode >> 4])
+        if (g_apThreeByteMapX86_F20F38[pDis->bOpCode >> 4])
         {
-            pOpcode = g_apThreeByteMapX86_F20F38[pCpu->bOpCode >> 4];
-            pOpcode = &pOpcode[pCpu->bOpCode & 0xf];
+            pOpcode = g_apThreeByteMapX86_F20F38[pDis->bOpCode >> 4];
+            pOpcode = &pOpcode[pDis->bOpCode & 0xf];
 
             if (pOpcode->uOpcode != OP_INVALID)
@@ -1899 +1899 @@
 
                 /* Cancel prefix changes. */
-                pCpu->fPrefix &= ~DISPREFIX_REPNE;
+                pDis->fPrefix &= ~DISPREFIX_REPNE;
             }
         }
@@ -1905 +1905 @@
     }
 
-    size += disParseInstruction(offInstr+size, pOpcode, pCpu);
+    size += disParseInstruction(offInstr+size, pOpcode, pDis);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseThreeByteEsc5(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseThreeByteEsc5(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     PCDISOPCODE   pOpcode;
@@ -1917 +1917 @@
 
     /* 3rd byte */
-    pCpu->bOpCode = disReadByte(pCpu, offInstr);
+    pDis->bOpCode = disReadByte(pDis, offInstr);
 
     /** @todo Should we take the first or last prefix byte in case of multiple prefix bytes??? */
-    Assert(pCpu->bLastPrefix == OP_OPSIZE);
+    Assert(pDis->bLastPrefix == OP_OPSIZE);
 
     /* default to the non-prefixed table. */
-    if (g_apThreeByteMapX86_660F3A[pCpu->bOpCode >> 4])
-    {
-        pOpcode = g_apThreeByteMapX86_660F3A[pCpu->bOpCode >> 4];
-        pOpcode = &pOpcode[pCpu->bOpCode & 0xf];
+    if (g_apThreeByteMapX86_660F3A[pDis->bOpCode >> 4])
+    {
+        pOpcode = g_apThreeByteMapX86_660F3A[pDis->bOpCode >> 4];
+        pOpcode = &pOpcode[pDis->bOpCode & 0xf];
 
         if (pOpcode->uOpcode != OP_INVALID)
@@ -1933 +1933 @@
 
             /* Cancel prefix changes. */
-            pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
-            pCpu->uOpMode  = pCpu->uCpuMode;
+            pDis->fPrefix &= ~DISPREFIX_OPSIZE;
+            pDis->uOpMode  = pDis->uCpuMode;
         }
     }
@@ -1940 +1940 @@
         pOpcode = &g_InvalidOpcode[0];
 
-    size += disParseInstruction(offInstr+size, pOpcode, pCpu);
+    size += disParseInstruction(offInstr+size, pOpcode, pDis);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseNopPause(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseNopPause(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    if (pCpu->fPrefix & DISPREFIX_REP)
+    if (pDis->fPrefix & DISPREFIX_REP)
     {
         pOp = &g_aMapX86_NopPause[1]; /* PAUSE */
-        pCpu->fPrefix &= ~DISPREFIX_REP;
+        pDis->fPrefix &= ~DISPREFIX_REP;
     }
     else
         pOp = &g_aMapX86_NopPause[0]; /* NOP */
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseImmGrpl(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    int idx = (pCpu->bOpCode - 0x80) * 8;
+static size_t ParseImmGrpl(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
+{
+    int idx = (pDis->bOpCode - 0x80) * 8;
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
@@ -1977 +1977 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -1983 +1983 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseShiftGrp2(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseShiftGrp2(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     int idx;
@@ -1989 +1989 @@
     NOREF(pParam);
 
-    switch (pCpu->bOpCode)
+    switch (pDis->bOpCode)
     {
     case 0xC0:
     case 0xC1:
-        idx = (pCpu->bOpCode - 0xC0)*8;
+        idx = (pDis->bOpCode - 0xC0)*8;
         break;
 
@@ -2000 +2000 @@
     case 0xD2:
     case 0xD3:
-        idx = (pCpu->bOpCode - 0xD0 + 2)*8;
+        idx = (pDis->bOpCode - 0xD0 + 2)*8;
         break;
 
@@ -2008 +2008 @@
     }
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
@@ -2017 +2017 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2023 +2023 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp3(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    int idx = (pCpu->bOpCode - 0xF6) * 8;
+static size_t ParseGrp3(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
+{
+    int idx = (pDis->bOpCode - 0xF6) * 8;
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
@@ -2038 +2038 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2044 +2044 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp4(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp4(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
@@ -2058 +2058 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2064 +2064 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp5(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp5(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
@@ -2078 +2078 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2088 +2088 @@
 //
 //*****************************************************************************
-static size_t Parse3DNow(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t Parse3DNow(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
@@ -2097 +2097 @@
 #endif
 
-    unsigned ModRM = disReadByte(pCpu, offInstr);
-    pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM);
-    pCpu->ModRM.Bits.Mod = MODRM_MOD(ModRM);
-    pCpu->ModRM.Bits.Reg = MODRM_REG(ModRM);
-
-    size_t modrmsize = QueryModRM(offInstr+sizeof(uint8_t), pOp, pParam, pCpu, NULL);
-
-    uint8_t opcode = disReadByte(pCpu, offInstr+sizeof(uint8_t)+modrmsize);
+    unsigned ModRM = disReadByte(pDis, offInstr);
+    pDis->ModRM.Bits.Rm  = MODRM_RM(ModRM);
+    pDis->ModRM.Bits.Mod = MODRM_MOD(ModRM);
+    pDis->ModRM.Bits.Reg = MODRM_REG(ModRM);
+
+    size_t modrmsize = QueryModRM(offInstr+sizeof(uint8_t), pOp, pParam, pDis, NULL);
+
+    uint8_t opcode = disReadByte(pDis, offInstr+sizeof(uint8_t)+modrmsize);
 
     pOp = (PCDISOPCODE)&g_aTwoByteMapX86_3DNow[opcode];
@@ -2117 +2117 @@
     }
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
     size += sizeof(uint8_t);   //imm8_opcode uint8_t
 
@@ -2124 +2124 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp6(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp6(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
@@ -2138 +2138 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2144 +2144 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp7(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp7(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned mod   = MODRM_MOD(modrm);
     unsigned reg   = MODRM_REG(modrm);
@@ -2166 +2166 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2172 +2172 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp8(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp8(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
@@ -2186 +2186 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2192 +2192 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp9(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp9(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
@@ -2206 +2206 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2212 +2212 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp10(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp10(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
@@ -2226 +2226 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2232 +2232 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp12(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp12(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
-    if (pCpu->fPrefix & DISPREFIX_OPSIZE)
+    if (pDis->fPrefix & DISPREFIX_OPSIZE)
         reg += 8;   //2nd table
 
@@ -2249 +2249 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp13(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp13(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
-    if (pCpu->fPrefix & DISPREFIX_OPSIZE)
+    if (pDis->fPrefix & DISPREFIX_OPSIZE)
         reg += 8;   //2nd table
 
@@ -2270 +2270 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2276 +2276 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp14(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp14(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
-    if (pCpu->fPrefix & DISPREFIX_OPSIZE)
+    if (pDis->fPrefix & DISPREFIX_OPSIZE)
         reg += 8;   //2nd table
 
@@ -2292 +2292 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
 
     return size;
@@ -2298 +2298 @@
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp15(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp15(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned mod   = MODRM_MOD(modrm);
     unsigned reg   = MODRM_REG(modrm);
@@ -2317 +2317 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static size_t ParseGrp16(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp16(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pDis)
 {
     size_t size = 0;
     NOREF(pParam);
 
-    unsigned modrm = disReadByte(pCpu, offInstr);
+    unsigned modrm = disReadByte(pDis, offInstr);
     unsigned reg   = MODRM_REG(modrm);
 
@@ -2336 +2336 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(offInstr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pDis);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static void disasmModRMReg(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam, int fRegAddr)
-{
-    NOREF(pOp); NOREF(pCpu);
-
-    unsigned mod     = pCpu->ModRM.Bits.Mod;
+static void disasmModRMReg(PDISCPUSTATE pDis, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam, int fRegAddr)
+{
+    NOREF(pOp); NOREF(pDis);
+
+    unsigned mod     = pDis->ModRM.Bits.Mod;
 
     unsigned type    = OP_PARM_VTYPE(pParam->fParam);
     unsigned subtype = OP_PARM_VSUBTYPE(pParam->fParam);
     if (fRegAddr)
-        subtype = (pCpu->uAddrMode == DISCPUMODE_64BIT) ? OP_PARM_q : OP_PARM_d;
+        subtype = (pDis->uAddrMode == DISCPUMODE_64BIT) ? OP_PARM_q : OP_PARM_d;
     else
     if (subtype == OP_PARM_v || subtype == OP_PARM_NONE)
     {
-        switch (pCpu->uOpMode)
+        switch (pDis->uOpMode)
         {
         case DISCPUMODE_32BIT:
@@ -2374 +2374 @@
     {
     case OP_PARM_b:
-        Assert(idx < (pCpu->fPrefix & DISPREFIX_REX ? 16U : 8U));
+        Assert(idx < (pDis->fPrefix & DISPREFIX_REX ? 16U : 8U));
 
         /* AH, BH, CH & DH map to DIL, SIL, EBL & SPL when a rex prefix is present. */
         /* Intel® 64 and IA-32 Architectures Software Developer’s Manual: 3.4.1.1 */
-        if (    (pCpu->fPrefix & DISPREFIX_REX)
+        if (    (pDis->fPrefix & DISPREFIX_REX)
             &&  idx >= DISGREG_AH
             &&  idx <= DISGREG_BH)
@@ -2390 +2390 @@
 
     case OP_PARM_w:
-        Assert(idx < (pCpu->fPrefix & DISPREFIX_REX ? 16U : 8U));
+        Assert(idx < (pDis->fPrefix & DISPREFIX_REX ? 16U : 8U));
 
         pParam->fUse |= DISUSE_REG_GEN16;
@@ -2397 +2397 @@
 
     case OP_PARM_d:
-        Assert(idx < (pCpu->fPrefix & DISPREFIX_REX ? 16U : 8U));
+        Assert(idx < (pDis->fPrefix & DISPREFIX_REX ? 16U : 8U));
 
         pParam->fUse |= DISUSE_REG_GEN32;
@@ -2410 +2410 @@
     default:
         Log(("disasmModRMReg %x:%x failed!!\n", type, subtype));
-        pCpu->rc = VERR_DIS_INVALID_MODRM;
+        pDis->rc = VERR_DIS_INVALID_MODRM;
         break;
     }
@@ -2419 +2419 @@
 static const uint8_t g_auIndexModRMReg16[4] = { DISGREG_SI, DISGREG_DI, DISGREG_SI, DISGREG_DI };
 //*****************************************************************************
-static void disasmModRMReg16(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam)
-{
-    NOREF(pCpu); NOREF(pOp);
+static void disasmModRMReg16(PDISCPUSTATE pDis, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam)
+{
+    NOREF(pDis); NOREF(pOp);
     pParam->fUse |= DISUSE_REG_GEN16;
     pParam->Base.idxGenReg = g_auBaseModRMReg16[idx];
@@ -2432 +2432 @@
 //*****************************************************************************
 //*****************************************************************************
-static void disasmModRMSReg(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam)
+static void disasmModRMSReg(PDISCPUSTATE pDis, PCDISOPCODE pOp, unsigned idx, PDISOPPARAM pParam)
 {
     NOREF(pOp);
@@ -2438 +2438 @@
     {
         Log(("disasmModRMSReg %d failed!!\n", idx));
-        pCpu->rc = VERR_DIS_INVALID_PARAMETER;
+        pDis->rc = VERR_DIS_INVALID_PARAMETER;
         return;
     }
@@ -2472 +2472 @@
  *      XOR
  *
- * @param   pCpu    Fully disassembled instruction.
+ * @param   pDis    Fully disassembled instruction.
  */
-static void disValidateLockSequence(PDISCPUSTATE pCpu)
-{
-    Assert(pCpu->fPrefix & DISPREFIX_LOCK);
+static void disValidateLockSequence(PDISCPUSTATE pDis)
+{
+    Assert(pDis->fPrefix & DISPREFIX_LOCK);
 
     /*
      * Filter out the valid lock sequences.
      */
-    switch (pCpu->pCurInstr->uOpcode)
+    switch (pDis->pCurInstr->uOpcode)
     {
         /* simple: no variations */
@@ -2493 +2493 @@
         case OP_CMPXCHG:
         case OP_XADD:
-            if (pCpu->ModRM.Bits.Mod == 3)
+            if (pDis->ModRM.Bits.Mod == 3)
                 break;
             return;
@@ -2513 +2513 @@
         case OP_XCHG:
         case OP_XOR:
-            if (pCpu->Param1.fUse & (DISUSE_BASE | DISUSE_INDEX | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32
+            if (pDis->Param1.fUse & (DISUSE_BASE | DISUSE_INDEX | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32
                                      | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT8 | DISUSE_RIPDISPLACEMENT32))
                 return;
@@ -2525 +2525 @@
      * Invalid lock sequence, make it a OP_ILLUD2.
      */
-    pCpu->pCurInstr = &g_aTwoByteMapX86[11];
-    Assert(pCpu->pCurInstr->uOpcode == OP_ILLUD2);
+    pDis->pCurInstr = &g_aTwoByteMapX86[11];
+    Assert(pDis->pCurInstr->uOpcode == OP_ILLUD2);
 }
 
@@ -2534 +2534 @@
  *
  * @returns VBox status code.
- * @param   pCpu            Initialized cpu state.
+ * @param   pDis            Initialized disassembler state.
  * @param   paOneByteMap    The one byte opcode map to use.
  * @param   pcbInstr        Where to store the instruction size. Can be NULL.
  */
-static int disInstrWorker(PDISCPUSTATE pCpu, PCDISOPCODE paOneByteMap, uint32_t *pcbInstr)
+static int disInstrWorker(PDISCPUSTATE pDis, PCDISOPCODE paOneByteMap, uint32_t *pcbInstr)
 {
     /*
@@ -2546 +2546 @@
     for (;;)
     {
-        uint8_t codebyte = disReadByte(pCpu, offInstr++);
+        uint8_t codebyte = disReadByte(pDis, offInstr++);
         uint8_t opcode   = paOneByteMap[codebyte].uOpcode;
 
@@ -2556 +2556 @@
             {
                 /** Last prefix byte (for SSE2 extension tables); don't include the REX prefix */
-                pCpu->bLastPrefix = opcode;
-                pCpu->fPrefix &= ~DISPREFIX_REX;
+                pDis->bLastPrefix = opcode;
+                pDis->fPrefix &= ~DISPREFIX_REX;
             }
 
@@ -2565 +2565 @@
                 if (pcbInstr)
                     *pcbInstr = (uint32_t)offInstr;
-                return pCpu->rc = VERR_DIS_INVALID_OPCODE;
+                return pDis->rc = VERR_DIS_INVALID_OPCODE;
 
             // segment override prefix byte
             case OP_SEG:
-                pCpu->idxSegPrefix = (DISSELREG)(paOneByteMap[codebyte].fParam1 - OP_PARM_REG_SEG_START);
+                pDis->idxSegPrefix = (DISSELREG)(paOneByteMap[codebyte].fParam1 - OP_PARM_REG_SEG_START);
                 /* Segment prefixes for CS, DS, ES and SS are ignored in long mode. */
-                if (   pCpu->uCpuMode != DISCPUMODE_64BIT
-                    || pCpu->idxSegPrefix >= DISSELREG_FS)
+                if (   pDis->uCpuMode != DISCPUMODE_64BIT
+                    || pDis->idxSegPrefix >= DISSELREG_FS)
                 {
-                    pCpu->fPrefix   |= DISPREFIX_SEG;
+                    pDis->fPrefix   |= DISPREFIX_SEG;
                 }
                 continue;   //fetch the next byte
@@ -2580 +2580 @@
             // lock prefix byte
             case OP_LOCK:
-                pCpu->fPrefix |= DISPREFIX_LOCK;
+                pDis->fPrefix |= DISPREFIX_LOCK;
                 continue;   //fetch the next byte
 
             // address size override prefix byte
             case OP_ADDRSIZE:
-                pCpu->fPrefix |= DISPREFIX_ADDRSIZE;
-                if (pCpu->uCpuMode == DISCPUMODE_16BIT)
-                    pCpu->uAddrMode = DISCPUMODE_32BIT;
+                pDis->fPrefix |= DISPREFIX_ADDRSIZE;
+                if (pDis->uCpuMode == DISCPUMODE_16BIT)
+                    pDis->uAddrMode = DISCPUMODE_32BIT;
                 else
-                if (pCpu->uCpuMode == DISCPUMODE_32BIT)
-                    pCpu->uAddrMode = DISCPUMODE_16BIT;
+                if (pDis->uCpuMode == DISCPUMODE_32BIT)
+                    pDis->uAddrMode = DISCPUMODE_16BIT;
                 else
-                    pCpu->uAddrMode = DISCPUMODE_32BIT;     /* 64 bits */
+                    pDis->uAddrMode = DISCPUMODE_32BIT;     /* 64 bits */
                 continue;   //fetch the next byte
 
             // operand size override prefix byte
             case OP_OPSIZE:
-                pCpu->fPrefix |= DISPREFIX_OPSIZE;
-                if (pCpu->uCpuMode == DISCPUMODE_16BIT)
-                    pCpu->uOpMode = DISCPUMODE_32BIT;
+                pDis->fPrefix |= DISPREFIX_OPSIZE;
+                if (pDis->uCpuMode == DISCPUMODE_16BIT)
+                    pDis->uOpMode = DISCPUMODE_32BIT;
                 else
-                    pCpu->uOpMode = DISCPUMODE_16BIT;  /* for 32 and 64 bits mode (there is no 32 bits operand size override prefix) */
+                    pDis->uOpMode = DISCPUMODE_16BIT;  /* for 32 and 64 bits mode (there is no 32 bits operand size override prefix) */
                 continue;   //fetch the next byte
 
             // rep and repne are not really prefixes, but we'll treat them as such
             case OP_REPE:
-                pCpu->fPrefix |= DISPREFIX_REP;
+                pDis->fPrefix |= DISPREFIX_REP;
                 continue;   //fetch the next byte
 
             case OP_REPNE:
-                pCpu->fPrefix |= DISPREFIX_REPNE;
+                pDis->fPrefix |= DISPREFIX_REPNE;
                 continue;   //fetch the next byte
 
             case OP_REX:
-                Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
+                Assert(pDis->uCpuMode == DISCPUMODE_64BIT);
                 /* REX prefix byte */
-                pCpu->fPrefix   |= DISPREFIX_REX;
-                pCpu->fRexPrefix = DISPREFIX_REX_OP_2_FLAGS(paOneByteMap[codebyte].fParam1);
-                if (pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_W)
-                    pCpu->uOpMode = DISCPUMODE_64BIT;  /* overrides size prefix byte */
+                pDis->fPrefix   |= DISPREFIX_REX;
+                pDis->fRexPrefix = DISPREFIX_REX_OP_2_FLAGS(paOneByteMap[codebyte].fParam1);
+                if (pDis->fRexPrefix & DISPREFIX_REX_FLAGS_W)
+                    pDis->uOpMode = DISCPUMODE_64BIT;  /* overrides size prefix byte */
                 continue;   //fetch the next byte
             }
@@ -2625 +2625 @@
 
         /* first opcode byte. */
-        pCpu->bOpCode  = codebyte;
-        pCpu->cbPrefix = (uint8_t)offInstr - 1;
-        offInstr += disParseInstruction(offInstr, &paOneByteMap[pCpu->bOpCode], pCpu);
+        pDis->bOpCode  = codebyte;
+        pDis->cbPrefix = (uint8_t)offInstr - 1;
+        offInstr += disParseInstruction(offInstr, &paOneByteMap[pDis->bOpCode], pDis);
         break;
     }
 
-    pCpu->cbInstr = (uint8_t)offInstr;
+    pDis->cbInstr = (uint8_t)offInstr;
     if (pcbInstr)
         *pcbInstr = (uint32_t)offInstr;
 
-    if (pCpu->fPrefix & DISPREFIX_LOCK)
-        disValidateLockSequence(pCpu);
-
-    return pCpu->rc;
+    if (pDis->fPrefix & DISPREFIX_LOCK)
+        disValidateLockSequence(pDis);
+
+    return pDis->rc;
 }
 
@@ -2646 +2646 @@
  *
  * @returns The primary opcode map to use.
- * @param   pCpu            The disassembler state.
+ * @param   pDis            The disassembler state.
  * @param   uInstrAddr      The instruction address.
  * @param   enmCpuMode      The CPU mode.
@@ -2654 +2654 @@
  */
 DECL_FORCE_INLINE(PCDISOPCODE)
-disInitializeState(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
+disInitializeState(PDISCPUSTATE pDis, RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
                    PFNDISREADBYTES pfnReadBytes, void *pvUser)
 {
-
     /*
-     * Initialize the CPU state.
      * Note! The RT_BZERO make ASSUMPTIONS about the placement of pvUser2.
      */
-    RT_BZERO(pCpu, RT_OFFSETOF(DISCPUSTATE, pvUser2));
+    RT_BZERO(pDis, RT_OFFSETOF(DISCPUSTATE, pvUser2));
 
 #ifdef VBOX_STRICT /* poison */
-    pCpu->Param1.Base.idxGenReg  = 0xc1;
-    pCpu->Param2.Base.idxGenReg  = 0xc2;
-    pCpu->Param3.Base.idxGenReg  = 0xc3;
-    pCpu->Param1.Index.idxGenReg = 0xc4;
-    pCpu->Param2.Index.idxGenReg = 0xc5;
-    pCpu->Param3.Index.idxGenReg = 0xc6;
-    pCpu->Param1.uDisp.u64 = UINT64_C(0xd1d1d1d1d1d1d1d1);
-    pCpu->Param2.uDisp.u64 = UINT64_C(0xd2d2d2d2d2d2d2d2);
-    pCpu->Param3.uDisp.u64 = UINT64_C(0xd3d3d3d3d3d3d3d3);
-    pCpu->Param1.uValue    = UINT64_C(0xb1b1b1b1b1b1b1b1);
-    pCpu->Param2.uValue    = UINT64_C(0xb2b2b2b2b2b2b2b2);
-    pCpu->Param3.uValue    = UINT64_C(0xb3b3b3b3b3b3b3b3);
-    pCpu->Param1.uScale    = 28;
-    pCpu->Param2.uScale    = 29;
-    pCpu->Param3.uScale    = 30;
+    pDis->Param1.Base.idxGenReg  = 0xc1;
+    pDis->Param2.Base.idxGenReg  = 0xc2;
+    pDis->Param3.Base.idxGenReg  = 0xc3;
+    pDis->Param1.Index.idxGenReg = 0xc4;
+    pDis->Param2.Index.idxGenReg = 0xc5;
+    pDis->Param3.Index.idxGenReg = 0xc6;
+    pDis->Param1.uDisp.u64 = UINT64_C(0xd1d1d1d1d1d1d1d1);
+    pDis->Param2.uDisp.u64 = UINT64_C(0xd2d2d2d2d2d2d2d2);
+    pDis->Param3.uDisp.u64 = UINT64_C(0xd3d3d3d3d3d3d3d3);
+    pDis->Param1.uValue    = UINT64_C(0xb1b1b1b1b1b1b1b1);
+    pDis->Param2.uValue    = UINT64_C(0xb2b2b2b2b2b2b2b2);
+    pDis->Param3.uValue    = UINT64_C(0xb3b3b3b3b3b3b3b3);
+    pDis->Param1.uScale    = 28;
+    pDis->Param2.uScale    = 29;
+    pDis->Param3.uScale    = 30;
 #endif
 
-    pCpu->fPrefix           = DISPREFIX_NONE;
-    pCpu->idxSegPrefix      = DISSELREG_DS;
-    pCpu->rc                = VINF_SUCCESS;
-    pCpu->pfnDisasmFnTable  = g_apfnFullDisasm;
-
-    pCpu->uInstrAddr        = uInstrAddr;
-    pCpu->fFilter           = fFilter;
-    pCpu->pfnReadBytes      = pfnReadBytes ? pfnReadBytes : disReadBytesDefault;
-    pCpu->pvUser            = pvUser;
-    pCpu->uCpuMode          = enmCpuMode;
+    pDis->fPrefix           = DISPREFIX_NONE;
+    pDis->idxSegPrefix      = DISSELREG_DS;
+    pDis->rc                = VINF_SUCCESS;
+    pDis->pfnDisasmFnTable  = g_apfnFullDisasm;
+
+    pDis->uInstrAddr        = uInstrAddr;
+    pDis->fFilter           = fFilter;
+    pDis->pfnReadBytes      = pfnReadBytes ? pfnReadBytes : disReadBytesDefault;
+    pDis->pvUser            = pvUser;
+    pDis->uCpuMode          = enmCpuMode;
     PCDISOPCODE paOneByteMap;
     if (enmCpuMode == DISCPUMODE_64BIT)
     {
-        pCpu->uAddrMode     = DISCPUMODE_64BIT;
-        pCpu->uOpMode       = DISCPUMODE_32BIT;
+        pDis->uAddrMode     = DISCPUMODE_64BIT;
+        pDis->uOpMode       = DISCPUMODE_32BIT;
         paOneByteMap        = g_aOneByteMapX64;
     }
     else
     {
-        pCpu->uAddrMode     = enmCpuMode;
-        pCpu->uOpMode       = enmCpuMode;
+        pDis->uAddrMode     = enmCpuMode;
+        pDis->uOpMode       = enmCpuMode;
         paOneByteMap        = g_aOneByteMapX86;
     }
@@ -2716 +2714 @@
  * instruction parsing.
  *
- * @param   pCpu                The disassembler state.
+ * @param   pDis                The disassembler state.
  */
-DECL_FORCE_INLINE(void) disPrefetchBytes(PDISCPUSTATE pCpu)
+DECL_FORCE_INLINE(void) disPrefetchBytes(PDISCPUSTATE pDis)
 {
     /*
@@ -2725 +2723 @@
      * the cache here.)
      */
-    int rc = pCpu->pfnReadBytes(pCpu, 0, 1, sizeof(pCpu->abInstr));
+    int rc = pDis->pfnReadBytes(pDis, 0, 1, sizeof(pDis->abInstr));
     if (RT_SUCCESS(rc))
     {
-        Assert(pCpu->cbCachedInstr >= 1);
-        Assert(pCpu->cbCachedInstr <= sizeof(pCpu->abInstr));
+        Assert(pDis->cbCachedInstr >= 1);
+        Assert(pDis->cbCachedInstr <= sizeof(pDis->abInstr));
     }
     else
     {
         Log(("Initial read failed with rc=%Rrc!!\n", rc));
-        pCpu->rc = VERR_DIS_MEM_READ;
+        pDis->rc = VERR_DIS_MEM_READ;
     }
 }
@@ -2740 +2738 @@
 
 /**
- * Disassembles on instruction, details in @a pCpu and length in @a pcbInstr.
+ * Disassembles on instruction, details in @a pDis and length in @a pcbInstr.
  *
  * @returns VBox status code.
@@ -2749 +2747 @@
  * @param   fFilter         Instruction type filter.
  * @param   pvUser          User argument for the instruction reader. (Ends up in pvUser.)
- * @param   pCpu            Pointer to CPU structure. With the exception of
+ * @param   pDis            Pointer to CPU structure. With the exception of
  *                          DISCPUSTATE::pvUser2, the structure will be
  *                          completely initialized by this API, i.e. no input is
@@ -2758 +2756 @@
 DISDECL(int) DISInstEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
                        PFNDISREADBYTES pfnReadBytes, void *pvUser,
-                       PDISCPUSTATE pCpu, uint32_t *pcbInstr)
-{
-
-    PCDISOPCODE paOneByteMap = disInitializeState(pCpu, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
-    disPrefetchBytes(pCpu);
-    return disInstrWorker(pCpu, paOneByteMap, pcbInstr);
+                       PDISCPUSTATE pDis, uint32_t *pcbInstr)
+{
+
+    PCDISOPCODE paOneByteMap = disInitializeState(pDis, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
+    disPrefetchBytes(pDis);
+    return disInstrWorker(pDis, paOneByteMap, pcbInstr);
 }
 
@@ -2769 +2767 @@
 /**
  * Disassembles on instruction partially or fully from prefetched bytes, details
- * in @a pCpu and length in @a pcbInstr.
+ * in @a pDis and length in @a pcbInstr.
  *
  * @returns VBox status code.
@@ -2781 +2779 @@
  * @param   fFilter         Instruction type filter.
  * @param   pvUser          User argument for the instruction reader. (Ends up in pvUser.)
- * @param   pCpu            Pointer to CPU structure. With the exception of
+ * @param   pDis            Pointer to CPU structure. With the exception of
  *                          DISCPUSTATE::pvUser2, the structure will be
  *                          completely initialized by this API, i.e. no input is
@@ -2791 +2789 @@
                                         void const *pvPrefetched, size_t cbPretched,
                                         PFNDISREADBYTES pfnReadBytes, void *pvUser,
-                                        PDISCPUSTATE pCpu, uint32_t *pcbInstr)
-{
-    PCDISOPCODE paOneByteMap = disInitializeState(pCpu, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
+                                        PDISCPUSTATE pDis, uint32_t *pcbInstr)
+{
+    PCDISOPCODE paOneByteMap = disInitializeState(pDis, uInstrAddr, enmCpuMode, fFilter, pfnReadBytes, pvUser);
 
     if (!cbPretched)
-        disPrefetchBytes(pCpu);
-    else
-    {
-        if (cbPretched >= sizeof(pCpu->abInstr))
+        disPrefetchBytes(pDis);
+    else
+    {
+        if (cbPretched >= sizeof(pDis->abInstr))
         {
-            memcpy(pCpu->abInstr, pvPrefetched, sizeof(pCpu->abInstr));
-            pCpu->cbCachedInstr = (uint8_t)sizeof(pCpu->abInstr);
+            memcpy(pDis->abInstr, pvPrefetched, sizeof(pDis->abInstr));
+            pDis->cbCachedInstr = (uint8_t)sizeof(pDis->abInstr);
         }
         else
         {
-            memcpy(pCpu->abInstr, pvPrefetched, cbPretched);
-            pCpu->cbCachedInstr = (uint8_t)cbPretched;
-        }
-    }
-
-    return disInstrWorker(pCpu, paOneByteMap, pcbInstr);
+            memcpy(pDis->abInstr, pvPrefetched, cbPretched);
+            pDis->cbCachedInstr = (uint8_t)cbPretched;
+        }
+    }
+
+    return disInstrWorker(pDis, paOneByteMap, pcbInstr);
 }
 
@@ -2819 +2817 @@
  * Parses one guest instruction.
  *
- * The result is found in pCpu and pcbInstr.
+ * The result is found in pDis and pcbInstr.
  *
  * @returns VBox status code.
@@ -2827 +2825 @@
  * @param   pfnReadBytes    Callback for reading instruction bytes.
  * @param   pvUser          User argument for the instruction reader. (Ends up in pvUser.)
- * @param   pCpu            Pointer to cpu structure. Will be initialized.
+ * @param   pDis            Pointer to cpu structure. Will be initialized.
  * @param   pcbInstr        Where to store the size of the instruction.
  *                          NULL is allowed.  This is also stored in
@@ -2833 +2831 @@
  */
 DISDECL(int) DISInstrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
-                                PDISCPUSTATE pCpu, uint32_t *pcbInstr)
-{
-    return DISInstEx(uInstrAddr, enmCpuMode, DISOPTYPE_ALL, pfnReadBytes, pvUser, pCpu, pcbInstr);
+                                PDISCPUSTATE pDis, uint32_t *pcbInstr)
+{
+    return DISInstEx(uInstrAddr, enmCpuMode, DISOPTYPE_ALL, pfnReadBytes, pvUser, pDis, pcbInstr);
 }
 
@@ -2842 +2840 @@
  * Parses one guest instruction.
  *
- * The result is found in pCpu and pcbInstr.
+ * The result is found in pDis and pcbInstr.
  *
  * @returns VBox status code.
@@ -2852 +2850 @@
  * @param   pfnReadBytes    Callback for reading instruction bytes.
  * @param   pvUser          User argument for the instruction reader. (Ends up in pvUser.)
- * @param   pCpu            Pointer to cpu structure. Will be initialized.
+ * @param   pDis            Pointer to cpu structure. Will be initialized.
  * @param   pcbInstr        Where to store the size of the instruction.
  *                          NULL is allowed.  This is also stored in
  *                          PDISCPUSTATE::cbInstr.
  */
-DISDECL(int) DISInstr(const void *pvInstr, DISCPUMODE enmCpuMode, PDISCPUSTATE pCpu, uint32_t *pcbInstr)
-{
-    return DISInstEx((uintptr_t)pvInstr, enmCpuMode, DISOPTYPE_ALL, NULL /*pfnReadBytes*/, NULL /*pvUser*/, pCpu, pcbInstr);
-}
-
+DISDECL(int) DISInstr(const void *pvInstr, DISCPUMODE enmCpuMode, PDISCPUSTATE pDis, uint32_t *pcbInstr)
+{
+    return DISInstEx((uintptr_t)pvInstr, enmCpuMode, DISOPTYPE_ALL, NULL /*pfnReadBytes*/, NULL /*pvUser*/, pDis, pcbInstr);
+}
+

trunk/src/VBox/Disassembler/DisasmFormatBytes.cpp

@@ -31 +31 @@
  * @returns The number of output bytes.
  *
- * @param   pCpu    Pointer to the disassembler cpu state.
+ * @param   pDis    Pointer to the disassembler state.
  * @param   pszDst  The output buffer.
  * @param   cchDst  The size of the output buffer.
  * @param   fFlags  The flags passed to the formatter.
  */
-size_t disFormatBytes(PCDISCPUSTATE pCpu, char *pszDst, size_t cchDst, uint32_t fFlags)
+size_t disFormatBytes(PCDISCPUSTATE pDis, char *pszDst, size_t cchDst, uint32_t fFlags)
 {
     size_t      cchOutput = 0;
-    uint32_t    cb        = pCpu->cbInstr;
+    uint32_t    cb        = pDis->cbInstr;
     AssertStmt(cb <= 16, cb = 16);
 
@@ -69 +69 @@
     {
         if (i != 0 && (fFlags & DIS_FMT_FLAGS_BYTES_SPACED))
-            PUT_NUM(3, " %02x", pCpu->abInstr[i]);
+            PUT_NUM(3, " %02x", pDis->abInstr[i]);
         else
-            PUT_NUM(2, "%02x", pCpu->abInstr[i]);
+            PUT_NUM(2, "%02x", pDis->abInstr[i]);
     }
 

trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp

@@ -87 +87 @@
  *
  * @returns Pointer to the register name.
- * @param   pCpu        The disassembler cpu state.
+ * @param   pDis        The disassembler state.
  * @param   pParam      The parameter.
  * @param   pcchReg     Where to store the length of the name.
  */
-static const char *disasmFormatYasmBaseReg(PCDISCPUSTATE pCpu, PCDISOPPARAM pParam, size_t *pcchReg)
+static const char *disasmFormatYasmBaseReg(PCDISCPUSTATE pDis, PCDISOPPARAM pParam, size_t *pcchReg)
 {
     switch (pParam->fUse & (  DISUSE_REG_GEN8 | DISUSE_REG_GEN16 | DISUSE_REG_GEN32 | DISUSE_REG_GEN64
@@ -198 +198 @@
  *
  * @returns The index register name.
- * @param   pCpu        The disassembler cpu state.
+ * @param   pDis        The disassembler state.
  * @param   pParam      The parameter.
  * @param   pcchReg     Where to store the length of the name.
  */
-static const char *disasmFormatYasmIndexReg(PCDISCPUSTATE pCpu, PCDISOPPARAM pParam, size_t *pcchReg)
-{
-    switch (pCpu->uAddrMode)
+static const char *disasmFormatYasmIndexReg(PCDISCPUSTATE pDis, PCDISOPPARAM pParam, size_t *pcchReg)
+{
+    switch (pDis->uAddrMode)
     {
         case DISCPUMODE_16BIT:
@@ -231 +231 @@
 
         default:
-            AssertMsgFailed(("%#x %#x\n", pParam->fUse, pCpu->uAddrMode));
+            AssertMsgFailed(("%#x %#x\n", pParam->fUse, pDis->uAddrMode));
             *pcchReg = 3;
             return "r??";
@@ -244 +244 @@
  * @returns The number of output characters. If this is >= cchBuf, then the content
  *          of pszBuf will be truncated.
- * @param   pCpu            Pointer to the disassembler CPU state.
+ * @param   pDis            Pointer to the disassembler state.
  * @param   pszBuf          The output buffer.
  * @param   cchBuf          The size of the output buffer.
@@ -251 +251 @@
  * @param   pvUser          User argument for pfnGetSymbol.
  */
-DISDECL(size_t) DISFormatYasmEx(PCDISCPUSTATE pCpu, char *pszBuf, size_t cchBuf, uint32_t fFlags,
+DISDECL(size_t) DISFormatYasmEx(PCDISCPUSTATE pDis, char *pszBuf, size_t cchBuf, uint32_t fFlags,
                                 PFNDISGETSYMBOL pfnGetSymbol, void *pvUser)
 {
@@ -257 +257 @@
      * Input validation and massaging.
      */
-    AssertPtr(pCpu);
+    AssertPtr(pDis);
     AssertPtrNull(pszBuf);
     Assert(pszBuf || !cchBuf);
@@ -267 +267 @@
         fFlags = (fFlags & ~DIS_FMT_FLAGS_BYTES_LEFT) | DIS_FMT_FLAGS_BYTES_RIGHT;
 
-    PCDISOPCODE const pOp = pCpu->pCurInstr;
+    PCDISOPCODE const pOp = pDis->pCurInstr;
 
     /*
@@ -348 +348 @@
     {
 #if HC_ARCH_BITS == 64 || GC_ARCH_BITS == 64
-        if (pCpu->uInstrAddr >= _4G)
-            PUT_NUM(9, "%08x`", (uint32_t)(pCpu->uInstrAddr >> 32));
+        if (pDis->uInstrAddr >= _4G)
+            PUT_NUM(9, "%08x`", (uint32_t)(pDis->uInstrAddr >> 32));
 #endif
-        PUT_NUM(8, "%08x", (uint32_t)pCpu->uInstrAddr);
+        PUT_NUM(8, "%08x", (uint32_t)pDis->uInstrAddr);
         PUT_C(' ');
     }
@@ -360 +360 @@
     if (fFlags & DIS_FMT_FLAGS_BYTES_LEFT)
     {
-        size_t cchTmp = disFormatBytes(pCpu, pszDst, cchDst, fFlags);
+        size_t cchTmp = disFormatBytes(pDis, pszDst, cchDst, fFlags);
         cchOutput += cchTmp;
         if (cchDst > 1)
@@ -392 +392 @@
     if (    pOp->uOpcode == OP_INVALID
         ||  (   pOp->uOpcode == OP_ILLUD2
-             && (pCpu->fPrefix & DISPREFIX_LOCK)))
+             && (pDis->fPrefix & DISPREFIX_LOCK)))
         PUT_SZ("Illegal opcode");
     else
@@ -399 +399 @@
          * Prefixes
          */
-        if (pCpu->fPrefix & DISPREFIX_LOCK)
+        if (pDis->fPrefix & DISPREFIX_LOCK)
             PUT_SZ("lock ");
-        if(pCpu->fPrefix & DISPREFIX_REP)
+        if(pDis->fPrefix & DISPREFIX_REP)
             PUT_SZ("rep ");
-        else if(pCpu->fPrefix & DISPREFIX_REPNE)
+        else if(pDis->fPrefix & DISPREFIX_REPNE)
             PUT_SZ("repne ");
 
@@ -415 +415 @@
         {
             case OP_JECXZ:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "jcxz %Jb" : pCpu->uOpMode == DISCPUMODE_32BIT ? "jecxz %Jb"   : "jrcxz %Jb";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "jcxz %Jb" : pDis->uOpMode == DISCPUMODE_32BIT ? "jecxz %Jb"   : "jrcxz %Jb";
                 break;
             case OP_PUSHF:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "pushfw"   : pCpu->uOpMode == DISCPUMODE_32BIT ? "pushfd"      : "pushfq";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "pushfw"   : pDis->uOpMode == DISCPUMODE_32BIT ? "pushfd"      : "pushfq";
                 break;
             case OP_POPF:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "popfw"    : pCpu->uOpMode == DISCPUMODE_32BIT ? "popfd"       : "popfq";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "popfw"    : pDis->uOpMode == DISCPUMODE_32BIT ? "popfd"       : "popfq";
                 break;
             case OP_PUSHA:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "pushaw"   : "pushad";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "pushaw"   : "pushad";
                 break;
             case OP_POPA:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "popaw"    : "popad";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "popaw"    : "popad";
                 break;
             case OP_INSB:
@@ -433 +433 @@
                 break;
             case OP_INSWD:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "insw"     : pCpu->uOpMode == DISCPUMODE_32BIT ? "insd"  : "insq";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "insw"     : pDis->uOpMode == DISCPUMODE_32BIT ? "insd"  : "insq";
                 break;
             case OP_OUTSB:
@@ -439 +439 @@
                 break;
             case OP_OUTSWD:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "outsw"    : pCpu->uOpMode == DISCPUMODE_32BIT ? "outsd" : "outsq";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "outsw"    : pDis->uOpMode == DISCPUMODE_32BIT ? "outsd" : "outsq";
                 break;
             case OP_MOVSB:
@@ -445 +445 @@
                 break;
             case OP_MOVSWD:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "movsw"    : pCpu->uOpMode == DISCPUMODE_32BIT ? "movsd" : "movsq";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "movsw"    : pDis->uOpMode == DISCPUMODE_32BIT ? "movsd" : "movsq";
                 break;
             case OP_CMPSB:
@@ -451 +451 @@
                 break;
             case OP_CMPWD:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "cmpsw"    : pCpu->uOpMode == DISCPUMODE_32BIT ? "cmpsd" : "cmpsq";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "cmpsw"    : pDis->uOpMode == DISCPUMODE_32BIT ? "cmpsd" : "cmpsq";
                 break;
             case OP_SCASB:
@@ -457 +457 @@
                 break;
             case OP_SCASWD:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "scasw"    : pCpu->uOpMode == DISCPUMODE_32BIT ? "scasd" : "scasq";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "scasw"    : pDis->uOpMode == DISCPUMODE_32BIT ? "scasd" : "scasq";
                 break;
             case OP_LODSB:
@@ -463 +463 @@
                 break;
             case OP_LODSWD:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "lodsw"    : pCpu->uOpMode == DISCPUMODE_32BIT ? "lodsd" : "lodsq";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "lodsw"    : pDis->uOpMode == DISCPUMODE_32BIT ? "lodsd" : "lodsq";
                 break;
             case OP_STOSB:
@@ -469 +469 @@
                 break;
             case OP_STOSWD:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "stosw"    : pCpu->uOpMode == DISCPUMODE_32BIT ? "stosd" : "stosq";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "stosw"    : pDis->uOpMode == DISCPUMODE_32BIT ? "stosd" : "stosq";
                 break;
             case OP_CBW:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "cbw"      : pCpu->uOpMode == DISCPUMODE_32BIT ? "cwde"  : "cdqe";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "cbw"      : pDis->uOpMode == DISCPUMODE_32BIT ? "cwde"  : "cdqe";
                 break;
             case OP_CWD:
-                pszFmt = pCpu->uOpMode == DISCPUMODE_16BIT ? "cwd"      : pCpu->uOpMode == DISCPUMODE_32BIT ? "cdq"   : "cqo";
+                pszFmt = pDis->uOpMode == DISCPUMODE_16BIT ? "cwd"      : pDis->uOpMode == DISCPUMODE_32BIT ? "cdq"   : "cqo";
                 break;
             case OP_SHL:
@@ -492 +492 @@
              */
             case OP_NOP:
-                if (pCpu->bOpCode == 0x90)
+                if (pDis->bOpCode == 0x90)
                     /* fine, fine */;
                 else if (pszFmt[sizeof("nop %Ev") - 1] == '/' && pszFmt[sizeof("nop %Ev")] == 'p')
                     pszFmt = "prefetch %Eb";
-                else if (pCpu->bOpCode == 0x1f)
+                else if (pDis->bOpCode == 0x1f)
                 {
-                    Assert(pCpu->cbInstr >= 3);
+                    Assert(pDis->cbInstr >= 3);
                     PUT_SZ("db 00fh, 01fh,");
-                    PUT_NUM_8(pCpu->ModRM.u);
-                    for (unsigned i = 3; i < pCpu->cbInstr; i++)
+                    PUT_NUM_8(pDis->ModRM.u);
+                    for (unsigned i = 3; i < pDis->cbInstr; i++)
                     {
                         PUT_C(',');
@@ -540 +540 @@
              */
             case OP_FLD:
-                if (pCpu->bOpCode == 0xdb) /* m80fp workaround. */
-                    *(int *)&pCpu->Param1.fParam &= ~0x1f; /* make it pure OP_PARM_M */
+                if (pDis->bOpCode == 0xdb) /* m80fp workaround. */
+                    *(int *)&pDis->Param1.fParam &= ~0x1f; /* make it pure OP_PARM_M */
                 break;
             case OP_LAR: /* hack w -> v, probably not correct. */
-                *(int *)&pCpu->Param2.fParam &= ~0x1f;
-                *(int *)&pCpu->Param2.fParam |= OP_PARM_v;
+                *(int *)&pDis->Param2.fParam &= ~0x1f;
+                *(int *)&pDis->Param2.fParam |= OP_PARM_v;
                 break;
         }
@@ -552 +552 @@
          * Formatting context and associated macros.
          */
-        PCDISOPPARAM pParam = &pCpu->Param1;
+        PCDISOPPARAM pParam = &pDis->Param1;
         int iParam = 1;
 
@@ -572 +572 @@
                 { \
                     case OP_PARM_v: \
-                        switch (pCpu->uOpMode) \
+                        switch (pDis->uOpMode) \
                         { \
                             case DISCPUMODE_16BIT: PUT_SZ("word "); break; \
@@ -602 +602 @@
 #define PUT_SEGMENT_OVERRIDE() \
         do { \
-            if (pCpu->fPrefix & DISPREFIX_SEG) \
-                PUT_STR(s_szSegPrefix[pCpu->idxSegPrefix], 3); \
+            if (pDis->fPrefix & DISPREFIX_SEG) \
+                PUT_STR(s_szSegPrefix[pDis->idxSegPrefix], 3); \
         } while (0)
 
@@ -610 +610 @@
          * Segment prefixing for instructions that doesn't do memory access.
          */
-        if (    (pCpu->fPrefix & DISPREFIX_SEG)
-            &&  !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->idxSegPrefix], 2);
+        if (    (pDis->fPrefix & DISPREFIX_SEG)
+            &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param1.fUse)
+            &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param2.fUse)
+            &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param3.fUse))
+        {
+            PUT_STR(s_szSegPrefix[pDis->idxSegPrefix], 2);
             PUT_C(' ');
         }
@@ -649 +649 @@
 
                         size_t cchReg;
-                        const char *pszReg = disasmFormatYasmBaseReg(pCpu, pParam, &cchReg);
+                        const char *pszReg = disasmFormatYasmBaseReg(pDis, pParam, &cchReg);
                         PUT_STR(pszReg, cchReg);
                         break;
@@ -691 +691 @@
                                 PUT_SZ("dword ");
                             else if (   (fUse & DISUSE_DISPLACEMENT64)
-                                     && (pCpu->SIB.Bits.Base != 5 || pCpu->ModRM.Bits.Mod != 0)
+                                     && (pDis->SIB.Bits.Base != 5 || pDis->ModRM.Bits.Mod != 0)
                                      && (int32_t)pParam->uDisp.i64 == (int64_t)pParam->uDisp.i64) //??
                                 PUT_SZ("qword ");
@@ -714 +714 @@
                         {
                             size_t cchReg;
-                            const char *pszReg = disasmFormatYasmBaseReg(pCpu, pParam, &cchReg);
+                            const char *pszReg = disasmFormatYasmBaseReg(pDis, pParam, &cchReg);
                             PUT_STR(pszReg, cchReg);
                         }
@@ -724 +724 @@
 
                             size_t cchReg;
-                            const char *pszReg = disasmFormatYasmIndexReg(pCpu, pParam, &cchReg);
+                            const char *pszReg = disasmFormatYasmIndexReg(pDis, pParam, &cchReg);
                             PUT_STR(pszReg, cchReg);
 
@@ -798 +798 @@
 
                             case DISUSE_IMMEDIATE16:
-                                if (    pCpu->uCpuMode != pCpu->uOpMode
+                                if (    pDis->uCpuMode != pDis->uOpMode
                                     ||  (   (fFlags & DIS_FMT_FLAGS_STRICT)
                                          && (   (int8_t)pParam->uValue == (int16_t)pParam->uValue
@@ -821 +821 @@
 
                             case DISUSE_IMMEDIATE32:
-                                if (    pCpu->uOpMode != (pCpu->uCpuMode == DISCPUMODE_16BIT ? DISCPUMODE_16BIT : DISCPUMODE_32BIT) /* not perfect */
+                                if (    pDis->uOpMode != (pDis->uCpuMode == DISCPUMODE_16BIT ? DISCPUMODE_16BIT : DISCPUMODE_32BIT) /* not perfect */
                                     ||  (   (fFlags & DIS_FMT_FLAGS_STRICT)
                                          && (   (int8_t)pParam->uValue == (int32_t)pParam->uValue
@@ -905 +905 @@
                             PUT_SZ(" (");
 
-                        RTUINTPTR uTrgAddr = pCpu->uInstrAddr + pCpu->cbInstr + offDisplacement;
-                        if (pCpu->uCpuMode == DISCPUMODE_16BIT)
+                        RTUINTPTR uTrgAddr = pDis->uInstrAddr + pDis->cbInstr + offDisplacement;
+                        if (pDis->uCpuMode == DISCPUMODE_16BIT)
                             PUT_NUM_16(uTrgAddr);
-                        else if (pCpu->uCpuMode == DISCPUMODE_32BIT)
+                        else if (pDis->uCpuMode == DISCPUMODE_32BIT)
                             PUT_NUM_32(uTrgAddr);
                         else
@@ -915 +915 @@
                         if (pfnGetSymbol)
                         {
-                            int rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), uTrgAddr, szSymbol, sizeof(szSymbol), &off, pvUser);
+                            int rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), uTrgAddr, szSymbol, sizeof(szSymbol), &off, pvUser);
                             if (RT_SUCCESS(rc))
                             {
@@ -954 +954 @@
                                 PUT_NUM_16(pParam->uValue);
                                 if (pfnGetSymbol)
-                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint16_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
+                                    rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint16_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
                                 break;
                             case DISUSE_IMMEDIATE_ADDR_16_32:
@@ -961 +961 @@
                                 PUT_NUM_32(pParam->uValue);
                                 if (pfnGetSymbol)
-                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint32_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
+                                    rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint32_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
                                 break;
                             case DISUSE_DISPLACEMENT16:
                                 PUT_NUM_16(pParam->uValue);
                                 if (pfnGetSymbol)
-                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint16_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
+                                    rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint16_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
                                 break;
                             case DISUSE_DISPLACEMENT32:
                                 PUT_NUM_32(pParam->uValue);
                                 if (pfnGetSymbol)
-                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint32_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
+                                    rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint32_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
                                 break;
                             case DISUSE_DISPLACEMENT64:
                                 PUT_NUM_64(pParam->uValue);
                                 if (pfnGetSymbol)
-                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint64_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
+                                    rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint64_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
                                 break;
                             default:
@@ -1018 +1018 @@
                                 PUT_NUM_16(pParam->uValue);
                                 if (pfnGetSymbol)
-                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint16_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
+                                    rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint16_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
                                 break;
                             case DISUSE_IMMEDIATE_ADDR_16_32:
@@ -1025 +1025 @@
                                 PUT_NUM_32(pParam->uValue);
                                 if (pfnGetSymbol)
-                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint32_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
+                                    rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint32_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
                                 break;
                             case DISUSE_DISPLACEMENT16:
                                 PUT_NUM_16(pParam->uDisp.i16);
                                 if (pfnGetSymbol)
-                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), pParam->uDisp.u16, szSymbol, sizeof(szSymbol), &off, pvUser);
+                                    rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), pParam->uDisp.u16, szSymbol, sizeof(szSymbol), &off, pvUser);
                                 break;
                             case DISUSE_DISPLACEMENT32:
                                 PUT_NUM_32(pParam->uDisp.i32);
                                 if (pfnGetSymbol)
-                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), pParam->uDisp.u32, szSymbol, sizeof(szSymbol), &off, pvUser);
+                                    rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), pParam->uDisp.u32, szSymbol, sizeof(szSymbol), &off, pvUser);
                                 break;
                             case DISUSE_DISPLACEMENT64:
                                 PUT_NUM_64(pParam->uDisp.i64);
                                 if (pfnGetSymbol)
-                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), pParam->uDisp.u64, szSymbol, sizeof(szSymbol), &off, pvUser);
+                                    rc = pfnGetSymbol(pDis, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), pParam->uDisp.u64, szSymbol, sizeof(szSymbol), &off, pvUser);
                                 break;
                             default:
@@ -1081 +1081 @@
 
                         size_t cchReg;
-                        const char *pszReg = disasmFormatYasmBaseReg(pCpu, pParam, &cchReg);
+                        const char *pszReg = disasmFormatYasmBaseReg(pDis, pParam, &cchReg);
                         PUT_STR(pszReg, cchReg);
                         PUT_C(']');
@@ -1091 +1091 @@
                         Assert(RT_C_IS_ALPHA(pszFmt[0]) && RT_C_IS_ALPHA(pszFmt[1]) && !RT_C_IS_ALPHA(pszFmt[2])); pszFmt += 2;
                         size_t cchReg;
-                        const char *pszReg = disasmFormatYasmBaseReg(pCpu, pParam, &cchReg);
+                        const char *pszReg = disasmFormatYasmBaseReg(pDis, pParam, &cchReg);
                         PUT_STR(pszReg, cchReg);
                         break;
@@ -1111 +1111 @@
                     switch (++iParam)
                     {
-                        case 2: pParam = &pCpu->Param2; break;
-                        case 3: pParam = &pCpu->Param3; break;
+                        case 2: pParam = &pDis->Param2; break;
+                        case 3: pParam = &pDis->Param3; break;
                         default: pParam = NULL; break;
                     }
@@ -1141 +1141 @@
             PUT_C(' ');
 #if HC_ARCH_BITS == 64 || GC_ARCH_BITS == 64
-            if (pCpu->uInstrAddr >= _4G)
-                PUT_NUM(9, "%08x`", (uint32_t)(pCpu->uInstrAddr >> 32));
+            if (pDis->uInstrAddr >= _4G)
+                PUT_NUM(9, "%08x`", (uint32_t)(pDis->uInstrAddr >> 32));
 #endif
-            PUT_NUM(8, "%08x", (uint32_t)pCpu->uInstrAddr);
+            PUT_NUM(8, "%08x", (uint32_t)pDis->uInstrAddr);
         }
 
@@ -1153 +1153 @@
         {
             PUT_C(' ');
-            size_t cchTmp = disFormatBytes(pCpu, pszDst, cchDst, fFlags);
+            size_t cchTmp = disFormatBytes(pDis, pszDst, cchDst, fFlags);
             cchOutput += cchTmp;
             if (cchTmp >= cchDst)
@@ -1187 +1187 @@
  * @returns The number of output characters. If this is >= cchBuf, then the content
  *          of pszBuf will be truncated.
- * @param   pCpu    Pointer to the disassembler CPU state.
+ * @param   pDis    Pointer to the disassembler state.
  * @param   pszBuf  The output buffer.
  * @param   cchBuf  The size of the output buffer.
  */
-DISDECL(size_t) DISFormatYasm(PCDISCPUSTATE pCpu, char *pszBuf, size_t cchBuf)
-{
-    return DISFormatYasmEx(pCpu, pszBuf, cchBuf, 0 /* fFlags */, NULL /* pfnGetSymbol */, NULL /* pvUser */);
+DISDECL(size_t) DISFormatYasm(PCDISCPUSTATE pDis, char *pszBuf, size_t cchBuf)
+{
+    return DISFormatYasmEx(pDis, pszBuf, cchBuf, 0 /* fFlags */, NULL /* pfnGetSymbol */, NULL /* pvUser */);
 }
 
@@ -1202 +1202 @@
  *
  * @returns true if it's odd, false if it isn't.
- * @param   pCpu        The disassembler output.  The byte fetcher callback will
+ * @param   pDis        The disassembler output.  The byte fetcher callback will
  *                      be used if present as we might need to fetch opcode
  *                      bytes.
  */
-DISDECL(bool) DISFormatYasmIsOddEncoding(PDISCPUSTATE pCpu)
+DISDECL(bool) DISFormatYasmIsOddEncoding(PDISCPUSTATE pDis)
 {
     /*
      * Mod rm + SIB: Check for duplicate EBP encodings that yasm won't use for very good reasons.
      */
-    if (    pCpu->uAddrMode != DISCPUMODE_16BIT ///@todo correct?
-        &&  pCpu->ModRM.Bits.Rm == 4
-        &&  pCpu->ModRM.Bits.Mod != 3)
+    if (    pDis->uAddrMode != DISCPUMODE_16BIT ///@todo correct?
+        &&  pDis->ModRM.Bits.Rm == 4
+        &&  pDis->ModRM.Bits.Mod != 3)
     {
         /* No scaled index SIB (index=4), except for ESP. */
-        if (    pCpu->SIB.Bits.Index == 4
-            &&  pCpu->SIB.Bits.Base != 4)
+        if (    pDis->SIB.Bits.Index == 4
+            &&  pDis->SIB.Bits.Base != 4)
             return true;
 
         /* EBP + displacement */
-        if (    pCpu->ModRM.Bits.Mod != 0
-             && pCpu->SIB.Bits.Base == 5
-             && pCpu->SIB.Bits.Scale == 0)
+        if (    pDis->ModRM.Bits.Mod != 0
+             && pDis->SIB.Bits.Base == 5
+             && pDis->SIB.Bits.Scale == 0)
             return true;
     }
@@ -1230 +1230 @@
      * Seems to be an instruction alias here, but I cannot find any docs on it... hrmpf!
      */
-    if (    pCpu->pCurInstr->uOpcode == OP_SHL
-        &&  pCpu->ModRM.Bits.Reg == 6)
+    if (    pDis->pCurInstr->uOpcode == OP_SHL
+        &&  pDis->ModRM.Bits.Reg == 6)
         return true;
 
@@ -1238 +1238 @@
      */
     uint32_t fPrefixes = 0;
-    for (uint32_t offOpcode = 0; offOpcode < RT_ELEMENTS(pCpu->abInstr); offOpcode++)
+    for (uint32_t offOpcode = 0; offOpcode < RT_ELEMENTS(pDis->abInstr); offOpcode++)
     {
         uint32_t f;
-        switch (pCpu->abInstr[offOpcode])
+        switch (pDis->abInstr[offOpcode])
         {
             case 0xf0:
@@ -1271 +1271 @@
             case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
             case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
-                f = pCpu->uCpuMode == DISCPUMODE_64BIT ? DISPREFIX_REX : 0;
+                f = pDis->uCpuMode == DISCPUMODE_64BIT ? DISPREFIX_REX : 0;
                 break;
 
@@ -1289 +1289 @@
     {
         /* no effective address which it may apply to. */
-        Assert((pCpu->fPrefix & DISPREFIX_SEG) || pCpu->uCpuMode == DISCPUMODE_64BIT);
-        if (    !DISUSE_IS_EFFECTIVE_ADDR(pCpu->Param1.fUse)
-            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->Param2.fUse)
-            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->Param3.fUse))
+        Assert((pDis->fPrefix & DISPREFIX_SEG) || pDis->uCpuMode == DISCPUMODE_64BIT);
+        if (    !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param1.fUse)
+            &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param2.fUse)
+            &&  !DISUSE_IS_EFFECTIVE_ADDR(pDis->Param3.fUse))
             return true;
     }
@@ -1299 +1299 @@
     if (fPrefixes & DISPREFIX_ADDRSIZE)
     {
-        Assert(pCpu->fPrefix & DISPREFIX_ADDRSIZE);
-        if (    pCpu->pCurInstr->fParam3 == OP_PARM_NONE
-            &&  pCpu->pCurInstr->fParam2 == OP_PARM_NONE
-            &&  (   pCpu->pCurInstr->fParam1 >= OP_PARM_REG_GEN32_START
-                 && pCpu->pCurInstr->fParam1 <= OP_PARM_REG_GEN32_END))
+        Assert(pDis->fPrefix & DISPREFIX_ADDRSIZE);
+        if (    pDis->pCurInstr->fParam3 == OP_PARM_NONE
+            &&  pDis->pCurInstr->fParam2 == OP_PARM_NONE
+            &&  (   pDis->pCurInstr->fParam1 >= OP_PARM_REG_GEN32_START
+                 && pDis->pCurInstr->fParam1 <= OP_PARM_REG_GEN32_END))
             return true;
     }
@@ -1310 +1310 @@
     if (fPrefixes)
     {
-        switch (pCpu->pCurInstr->uOpcode)
+        switch (pDis->pCurInstr->uOpcode)
         {
             /* nop w/ prefix(es). */
@@ -1317 +1317 @@
 
             case OP_JMP:
-                if (    pCpu->pCurInstr->fParam1 != OP_PARM_Jb
-                    &&  pCpu->pCurInstr->fParam1 != OP_PARM_Jv)
+                if (    pDis->pCurInstr->fParam1 != OP_PARM_Jb
+                    &&  pDis->pCurInstr->fParam1 != OP_PARM_Jv)
                     break;
                 /* fall thru */
@@ -1346 +1346 @@
     if (fPrefixes & ~DISPREFIX_SEG)
     {
-        switch (pCpu->pCurInstr->uOpcode)
+        switch (pDis->pCurInstr->uOpcode)
         {
             case OP_POP:
             case OP_PUSH:
-                if (    pCpu->pCurInstr->fParam1 >= OP_PARM_REG_SEG_START
-                    &&  pCpu->pCurInstr->fParam1 <= OP_PARM_REG_SEG_END)
+                if (    pDis->pCurInstr->fParam1 >= OP_PARM_REG_SEG_START
+                    &&  pDis->pCurInstr->fParam1 <= OP_PARM_REG_SEG_END)
                     return true;
                 if (    (fPrefixes & ~DISPREFIX_OPSIZE)
-                    &&  pCpu->pCurInstr->fParam1 >= OP_PARM_REG_GEN32_START
-                    &&  pCpu->pCurInstr->fParam1 <= OP_PARM_REG_GEN32_END)
+                    &&  pDis->pCurInstr->fParam1 >= OP_PARM_REG_GEN32_START
+                    &&  pDis->pCurInstr->fParam1 <= OP_PARM_REG_GEN32_END)
                     return true;
                 break;
@@ -1371 +1371 @@
     /* Implicit 8-bit register instructions doesn't mix with operand size. */
     if (    (fPrefixes & DISPREFIX_OPSIZE)
-        &&  (   (   pCpu->pCurInstr->fParam1 == OP_PARM_Gb /* r8 */
-                 && pCpu->pCurInstr->fParam2 == OP_PARM_Eb /* r8/mem8 */)
-             || (   pCpu->pCurInstr->fParam2 == OP_PARM_Gb /* r8 */
-                 && pCpu->pCurInstr->fParam1 == OP_PARM_Eb /* r8/mem8 */))
+        &&  (   (   pDis->pCurInstr->fParam1 == OP_PARM_Gb /* r8 */
+                 && pDis->pCurInstr->fParam2 == OP_PARM_Eb /* r8/mem8 */)
+             || (   pDis->pCurInstr->fParam2 == OP_PARM_Gb /* r8 */
+                 && pDis->pCurInstr->fParam1 == OP_PARM_Eb /* r8/mem8 */))
        )
     {
-        switch (pCpu->pCurInstr->uOpcode)
+        switch (pDis->pCurInstr->uOpcode)
         {
             case OP_ADD:
@@ -1401 +1401 @@
      *        yasm: 18F5   sbb ch, dh     ; SBB r/m8, r8
      */
-    if (pCpu->ModRM.Bits.Mod == 3 /* reg,reg */)
-    {
-        switch (pCpu->pCurInstr->uOpcode)
+    if (pDis->ModRM.Bits.Mod == 3 /* reg,reg */)
+    {
+        switch (pDis->pCurInstr->uOpcode)
         {
             case OP_ADD:
@@ -1413 +1413 @@
             case OP_XOR:
             case OP_CMP:
-                if (    (    pCpu->pCurInstr->fParam1 == OP_PARM_Gb /* r8 */
-                         && pCpu->pCurInstr->fParam2 == OP_PARM_Eb /* r8/mem8 */)
-                    ||  (    pCpu->pCurInstr->fParam1 == OP_PARM_Gv /* rX */
-                         && pCpu->pCurInstr->fParam2 == OP_PARM_Ev /* rX/memX */))
+                if (    (    pDis->pCurInstr->fParam1 == OP_PARM_Gb /* r8 */
+                         && pDis->pCurInstr->fParam2 == OP_PARM_Eb /* r8/mem8 */)
+                    ||  (    pDis->pCurInstr->fParam1 == OP_PARM_Gv /* rX */
+                         && pDis->pCurInstr->fParam2 == OP_PARM_Ev /* rX/memX */))
                     return true;
 
                 /* 82 (see table A-6). */
-                if (pCpu->bOpCode == 0x82)
+                if (pDis->bOpCode == 0x82)
                     return true;
                 break;
@@ -1431 +1431 @@
             case OP_POP:
             case OP_PUSH:
-                Assert(pCpu->bOpCode == 0x8f);
+                Assert(pDis->bOpCode == 0x8f);
                 return true;
 
             case OP_MOV:
-                if (   pCpu->bOpCode == 0x8a
-                    || pCpu->bOpCode == 0x8b)
+                if (   pDis->bOpCode == 0x8a
+                    || pDis->bOpCode == 0x8b)
                     return true;
                 break;
@@ -1446 +1446 @@
 
     /* shl eax,1 will be assembled to the form without the immediate byte. */
-    if (    pCpu->pCurInstr->fParam2 == OP_PARM_Ib
-        &&  (uint8_t)pCpu->Param2.uValue == 1)
-    {
-        switch (pCpu->pCurInstr->uOpcode)
+    if (    pDis->pCurInstr->fParam2 == OP_PARM_Ib
+        &&  (uint8_t)pDis->Param2.uValue == 1)
+    {
+        switch (pDis->pCurInstr->uOpcode)
         {
             case OP_SHL:
@@ -1463 +1463 @@
 
     /* And some more - see table A-6. */
-    if (pCpu->bOpCode == 0x82)
-    {
-        switch (pCpu->pCurInstr->uOpcode)
+    if (pDis->bOpCode == 0x82)
+    {
+        switch (pDis->pCurInstr->uOpcode)
         {
             case OP_ADD:
@@ -1485 +1485 @@
     /* Yasm encodes setnbe al with /2 instead of /0 like the AMD manual
        says (intel doesn't appear to care). */
-    switch (pCpu->pCurInstr->uOpcode)
+    switch (pDis->pCurInstr->uOpcode)
     {
         case OP_SETO:
@@ -1503 +1503 @@
         case OP_SETLE:
         case OP_SETNLE:
-            AssertMsg(pCpu->bOpCode >= 0x90 && pCpu->bOpCode <= 0x9f, ("%#x\n", pCpu->bOpCode));
-            if (pCpu->ModRM.Bits.Reg != 2)
+            AssertMsg(pDis->bOpCode >= 0x90 && pDis->bOpCode <= 0x9f, ("%#x\n", pDis->bOpCode));
+            if (pDis->ModRM.Bits.Reg != 2)
                 return true;
             break;
@@ -1513 +1513 @@
      * doesn't quite make sense...
      */
-    if (    pCpu->pCurInstr->uOpcode == OP_MOVZX
-        &&  pCpu->bOpCode == 0xB7
-        &&  (pCpu->uCpuMode == DISCPUMODE_16BIT) != !!(fPrefixes & DISPREFIX_OPSIZE))
+    if (    pDis->pCurInstr->uOpcode == OP_MOVZX
+        &&  pDis->bOpCode == 0xB7
+        &&  (pDis->uCpuMode == DISCPUMODE_16BIT) != !!(fPrefixes & DISPREFIX_OPSIZE))
         return true;
 

trunk/src/VBox/Disassembler/DisasmInternal.h

@@ -171 +171 @@
 
 
-size_t disFormatBytes(PCDISCPUSTATE pCpu, char *pszDst, size_t cchDst, uint32_t fFlags);
+size_t disFormatBytes(PCDISCPUSTATE pDis, char *pszDst, size_t cchDst, uint32_t fFlags);
 
 /** @} */

trunk/src/VBox/Disassembler/DisasmReg.cpp

@@ -201 +201 @@
 //*****************************************************************************
 //*****************************************************************************
-DISDECL(int) DISGetParamSize(PDISCPUSTATE pCpu, PDISOPPARAM pParam)
+DISDECL(int) DISGetParamSize(PCDISCPUSTATE pDis, PCDISOPPARAM pParam)
 {
     unsigned subtype = OP_PARM_VSUBTYPE(pParam->fParam);
@@ -207 +207 @@
     if (subtype == OP_PARM_v)
     {
-        switch (pCpu->uOpMode)
+        switch (pDis->uOpMode)
         {
         case DISCPUMODE_32BIT:
@@ -240 +240 @@
 
     case OP_PARM_p: /* far pointer */
-        if (pCpu->uAddrMode == DISCPUMODE_32BIT)
+        if (pDis->uAddrMode == DISCPUMODE_32BIT)
             return 6;   /* 16:32 */
         else
-        if (pCpu->uAddrMode == DISCPUMODE_64BIT)
+        if (pDis->uAddrMode == DISCPUMODE_64BIT)
             return 12;  /* 16:64 */
         else
@@ -257 +257 @@
 //*****************************************************************************
 //*****************************************************************************
-DISDECL(DISSELREG) DISDetectSegReg(PDISCPUSTATE pCpu, PDISOPPARAM pParam)
-{
-    if (pCpu->fPrefix & DISPREFIX_SEG)
+DISDECL(DISSELREG) DISDetectSegReg(PCDISCPUSTATE pDis, PCDISOPPARAM pParam)
+{
+    if (pDis->fPrefix & DISPREFIX_SEG)
         /* Use specified SEG: prefix. */
-        return (DISSELREG)pCpu->idxSegPrefix;
+        return (DISSELREG)pDis->idxSegPrefix;
 
     /* Guess segment register by parameter type. */
@@ -278 +278 @@
 //*****************************************************************************
 //*****************************************************************************
-DISDECL(uint8_t) DISQuerySegPrefixByte(PDISCPUSTATE pCpu)
-{
-    Assert(pCpu->fPrefix & DISPREFIX_SEG);
-    switch (pCpu->idxSegPrefix)
+DISDECL(uint8_t) DISQuerySegPrefixByte(PCDISCPUSTATE pDis)
+{
+    Assert(pDis->fPrefix & DISPREFIX_SEG);
+    switch (pDis->idxSegPrefix)
     {
     case DISSELREG_ES:
@@ -491 +491 @@
  * @returns VBox error code
  * @param   pCtx            CPU context structure pointer
- * @param   pCpu            Pointer to cpu structure which have DISCPUSTATE::mode
- *                          set correctly.
+ * @param   pDis            Pointer to the disassembler state.
  * @param   pParam          Pointer to the parameter to parse
  * @param   pParamVal       Pointer to parameter value (OUT)
@@ -500 +499 @@
  *
  */
-DISDECL(int) DISQueryParamVal(PCPUMCTXCORE pCtx, PDISCPUSTATE pCpu, PDISOPPARAM pParam, PDISQPVPARAMVAL pParamVal, DISQPVWHICH parmtype)
+DISDECL(int) DISQueryParamVal(PCPUMCTXCORE pCtx, PCDISCPUSTATE pDis, PCDISOPPARAM pParam, PDISQPVPARAMVAL pParamVal, DISQPVWHICH parmtype)
 {
     memset(pParamVal, 0, sizeof(*pParamVal));
@@ -587 +586 @@
         if (pParam->fUse & DISUSE_DISPLACEMENT8)
         {
-            if (pCpu->uCpuMode == DISCPUMODE_32BIT)
+            if (pDis->uCpuMode == DISCPUMODE_32BIT)
                 pParamVal->val.val32 += (int32_t)pParam->uDisp.i8;
             else
-            if (pCpu->uCpuMode == DISCPUMODE_64BIT)
+            if (pDis->uCpuMode == DISCPUMODE_64BIT)
                 pParamVal->val.val64 += (int64_t)pParam->uDisp.i8;
             else
@@ -598 +597 @@
         if (pParam->fUse & DISUSE_DISPLACEMENT16)
         {
-            if (pCpu->uCpuMode == DISCPUMODE_32BIT)
+            if (pDis->uCpuMode == DISCPUMODE_32BIT)
                 pParamVal->val.val32 += (int32_t)pParam->uDisp.i16;
             else
-            if (pCpu->uCpuMode == DISCPUMODE_64BIT)
+            if (pDis->uCpuMode == DISCPUMODE_64BIT)
                 pParamVal->val.val64 += (int64_t)pParam->uDisp.i16;
             else
@@ -609 +608 @@
         if (pParam->fUse & DISUSE_DISPLACEMENT32)
         {
-            if (pCpu->uCpuMode == DISCPUMODE_32BIT)
+            if (pDis->uCpuMode == DISCPUMODE_32BIT)
                 pParamVal->val.val32 += pParam->uDisp.i32;
             else
@@ -617 +616 @@
         if (pParam->fUse & DISUSE_DISPLACEMENT64)
         {
-            Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
+            Assert(pDis->uCpuMode == DISCPUMODE_64BIT);
             pParamVal->val.val64 += pParam->uDisp.i64;
         }
@@ -623 +622 @@
         if (pParam->fUse & DISUSE_RIPDISPLACEMENT32)
         {
-            Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
+            Assert(pDis->uCpuMode == DISCPUMODE_64BIT);
             /* Relative to the RIP of the next instruction. */
-            pParamVal->val.val64 += pParam->uDisp.i32 + pCtx->rip + pCpu->cbInstr;
+            pParamVal->val.val64 += pParam->uDisp.i32 + pCtx->rip + pDis->cbInstr;
         }
         return VINF_SUCCESS;
@@ -750 +749 @@
  * @returns VBox error code
  * @param   pCtx            CPU context structure pointer
- * @param   pCpu            Pointer to cpu structure which have DISCPUSTATE::mode
- *                          set correctly.
+ * @param   pDis            Pointer to the disassembler state.
  * @param   pParam          Pointer to the parameter to parse
  * @param   pReg            Pointer to parameter value (OUT)
@@ -759 +757 @@
  *
  */
-DISDECL(int) DISQueryParamRegPtr(PCPUMCTXCORE pCtx, PDISCPUSTATE pCpu, PDISOPPARAM pParam, void **ppReg, size_t *pcbSize)
-{
-    NOREF(pCpu);
+DISDECL(int) DISQueryParamRegPtr(PCPUMCTXCORE pCtx, PCDISCPUSTATE pDis, PCDISOPPARAM pParam, void **ppReg, size_t *pcbSize)
+{
+    NOREF(pDis);
     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))
     {

trunk/src/VBox/Disassembler/testcase/tstDisasm-2.cpp

@@ -128 +128 @@
  * @returns true if it's valid. false if it isn't.
  *
- * @param   pCpu        The disassembler output.
- */
-static bool MyDisasIsValidInstruction(DISCPUSTATE const *pCpu)
-{
-    switch (pCpu->pCurInstr->uOpcode)
+ * @param   pDis        The disassembler output.
+ */
+static bool MyDisasIsValidInstruction(DISCPUSTATE const *pDis)
+{
+    switch (pDis->pCurInstr->uOpcode)
     {
         /* These doesn't take memory operands. */
@@ -138 +138 @@
         case OP_MOV_DR:
         case OP_MOV_TR:
-            if (pCpu->ModRM.Bits.Mod != 3)
+            if (pDis->ModRM.Bits.Mod != 3)
                 return false;
             break;
@@ -144 +144 @@
          /* The 0x8f /0 variant of this instruction doesn't get its /r value verified. */
         case OP_POP:
-            if (    pCpu->bOpCode == 0x8f
-                &&  pCpu->ModRM.Bits.Reg != 0)
+            if (    pDis->bOpCode == 0x8f
+                &&  pDis->ModRM.Bits.Reg != 0)
                 return false;
             break;
@@ -151 +151 @@
         /* The 0xc6 /0 and 0xc7 /0 variants of this instruction don't get their /r values verified. */
         case OP_MOV:
-            if (    (   pCpu->bOpCode == 0xc6
-                     || pCpu->bOpCode == 0xc7)
-                &&  pCpu->ModRM.Bits.Reg != 0)
+            if (    (   pDis->bOpCode == 0xc6
+                     || pDis->bOpCode == 0xc7)
+                &&  pDis->ModRM.Bits.Reg != 0)
                 return false;
             break;