Index: /trunk/src/VBox/Disassembler/DisasmCore.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41783)
+++ /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41784)
@@ -253,11 +253,11 @@
  *
  * @param   pCpu                The disassembler state.
- * @param   off                 The offset of the read request.
+ * @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 off, uint8_t cbMin)
-{
-    Assert(cbMin + off <= sizeof(pCpu->abInstr));
+DECL_NO_INLINE(static, void) disReadMore(PDISCPUSTATE pCpu, uint8_t offInstr, uint8_t cbMin)
+{
+    Assert(cbMin + offInstr <= sizeof(pCpu->abInstr));
 
     /*
@@ -265,14 +265,14 @@
      * been read and to make sure we don't leave unread gaps.
      */
-    if (off < pCpu->cbCachedInstr)
-    {
-        Assert(off + cbMin > pCpu->cbCachedInstr);
-        cbMin -= pCpu->cbCachedInstr - off;
-        off = pCpu->cbCachedInstr;
-    }
-    else if (off > pCpu->cbCachedInstr)
-    {
-        cbMin += off - pCpu->cbCachedInstr;
-        off = pCpu->cbCachedInstr;
+    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;
     }
 
@@ -282,8 +282,8 @@
      * DISInstrEx API.)
      */
-    int rc = pCpu->pfnReadBytes(pCpu, off, cbMin, sizeof(pCpu->abInstr) - off);
+    int rc = pCpu->pfnReadBytes(pCpu, offInstr, cbMin, sizeof(pCpu->abInstr) - offInstr);
     if (RT_SUCCESS(rc))
     {
-        Assert(pCpu->cbCachedInstr >= off + cbMin);
+        Assert(pCpu->cbCachedInstr >= offInstr + cbMin);
         Assert(pCpu->cbCachedInstr <= sizeof(pCpu->abInstr));
     }
@@ -301,10 +301,10 @@
  * @returns The requested byte.
  * @param   pCpu                The disassembler state.
- * @param   off                 The offset of the byte relative to the
+ * @param   offInstr            The offset of the byte relative to the
  *                              instruction.
  */
-DECL_NO_INLINE(static, uint8_t) disReadByteSlow(PDISCPUSTATE pCpu, RTUINTPTR off)
-{
-    if (RT_UNLIKELY(off >= DIS_MAX_INSTR_LENGTH))
+DECL_NO_INLINE(static, uint8_t) disReadByteSlow(PDISCPUSTATE pCpu, size_t offInstr)
+{
+    if (RT_UNLIKELY(offInstr >= DIS_MAX_INSTR_LENGTH))
     {
         Log(("disReadByte: too long instruction...\n"));
@@ -313,11 +313,11 @@
     }
 
-    disReadMore(pCpu, off, 1);
-    return pCpu->abInstr[off];
+    disReadMore(pCpu, offInstr, 1);
+    return pCpu->abInstr[offInstr];
 }
 
 
 /**
- * Read a byte (8-bit) instruction byte by offset.
+ * Read a byte (8-bit) instruction.
  *
  * @returns The requested byte.
@@ -325,23 +325,10 @@
  * @param   uAddress            The address.
  */
-DECLINLINE(uint8_t) disReadByteByOff(PDISCPUSTATE pCpu, RTUINTPTR off)
-{
-    if (RT_UNLIKELY(off >= pCpu->cbCachedInstr))
-        return disReadByteSlow(pCpu, off);
-
-    return pCpu->abInstr[off];
-}
-
-
-/**
- * Read a byte (8-bit) instruction byte.
- *
- * @returns The requested byte.
- * @param   pCpu                The disassembler state.
- * @param   uAddress            The address.
- */
-DECL_FORCE_INLINE(uint8_t) disReadByte(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
-{
-    return disReadByteByOff(pCpu, uAddress - pCpu->uInstrAddr);
+DECLINLINE(uint8_t) disReadByte(PDISCPUSTATE pCpu, size_t offInstr)
+{
+    if (RT_UNLIKELY(offInstr >= pCpu->cbCachedInstr))
+        return disReadByteSlow(pCpu, offInstr);
+
+    return pCpu->abInstr[offInstr];
 }
 
@@ -352,23 +339,23 @@
  * @returns The requested word.
  * @param   pCpu                The disassembler state.
- * @param   off                 The offset of the word relative to the
+ * @param   offInstr            The offset of the word relative to the
  *                              instruction.
  */
-DECL_NO_INLINE(static, uint16_t) disReadWordSlow(PDISCPUSTATE pCpu, RTUINTPTR off)
-{
-    if (RT_UNLIKELY(off + 2 > DIS_MAX_INSTR_LENGTH))
+DECL_NO_INLINE(static, uint16_t) disReadWordSlow(PDISCPUSTATE pCpu, 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;
-        if (off < DIS_MAX_INSTR_LENGTH)
-            return pCpu->abInstr[off];
+        if (offInstr < DIS_MAX_INSTR_LENGTH)
+            return pCpu->abInstr[offInstr];
         return 0;
     }
 
-    disReadMore(pCpu, off, 2);
+    disReadMore(pCpu, offInstr, 2);
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint16_t const *)&pCpu->abInstr[off];
+    return *(uint16_t const *)&pCpu->abInstr[offInstr];
 #else
-    return RT_MAKE_U16(pCpu->abInstr[off], pCpu->abInstr[off + 1]);
+    return RT_MAKE_U16(pCpu->abInstr[offInstr], pCpu->abInstr[offInstr + 1]);
 #endif
 }
@@ -376,33 +363,21 @@
 
 /**
- * Read a word (16-bit) instruction byte by offset.
+ * Read a word (16-bit) instruction.
  *
  * @returns The requested word.
  * @param   pCpu                The disassembler state.
- * @param   uAddress            The address.
+ * @param   offInstr            The offset of the qword relative to the
+ *                              instruction.
  */
-DECLINLINE(uint16_t) disReadWordByOff(PDISCPUSTATE pCpu, RTUINTPTR off)
-{
-    if (RT_UNLIKELY(off + 2 > pCpu->cbCachedInstr))
-        return disReadWordSlow(pCpu, off);
+DECLINLINE(uint16_t) disReadWord(PDISCPUSTATE pCpu, size_t offInstr)
+{
+    if (RT_UNLIKELY(offInstr + 2 > pCpu->cbCachedInstr))
+        return disReadWordSlow(pCpu, offInstr);
 
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint16_t const *)&pCpu->abInstr[off];
+    return *(uint16_t const *)&pCpu->abInstr[offInstr];
 #else
-    return RT_MAKE_U16(pCpu->abInstr[off], pCpu->abInstr[off + 1]);
+    return RT_MAKE_U16(pCpu->abInstr[offInstr], pCpu->abInstr[offInstr + 1]);
 #endif
-}
-
-
-/**
- * Read a word (16-bit) instruction byte.
- *
- * @returns The requested word.
- * @param   pCpu                The disassembler state.
- * @param   uAddress            The address.
- */
-DECL_FORCE_INLINE(uint16_t) disReadWord(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
-{
-    return disReadWordByOff(pCpu, uAddress - pCpu->uInstrAddr);
 }
 
@@ -413,30 +388,31 @@
  * @returns The requested dword.
  * @param   pCpu                The disassembler state.
- * @param   off                 The offset of the dword relative to the
+ * @param   offInstr            The offset of the dword relative to the
  *                              instruction.
  */
-DECL_NO_INLINE(static, uint32_t) disReadDWordSlow(PDISCPUSTATE pCpu, RTUINTPTR off)
-{
-    if (RT_UNLIKELY(off + 4 > DIS_MAX_INSTR_LENGTH))
+DECL_NO_INLINE(static, uint32_t) disReadDWordSlow(PDISCPUSTATE pCpu, 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;
-        switch ((RTUINTPTR)DIS_MAX_INSTR_LENGTH - off)
+        switch ((RTUINTPTR)DIS_MAX_INSTR_LENGTH - offInstr)
         {
             case 1:
-                return RT_MAKE_U32_FROM_U8(pCpu->abInstr[off], 0, 0, 0);
+                return RT_MAKE_U32_FROM_U8(pCpu->abInstr[offInstr], 0, 0, 0);
             case 2:
-                return RT_MAKE_U32_FROM_U8(pCpu->abInstr[off], pCpu->abInstr[off + 1], 0, 0);
+                return RT_MAKE_U32_FROM_U8(pCpu->abInstr[offInstr], pCpu->abInstr[offInstr + 1], 0, 0);
             case 3:
-                return RT_MAKE_U32_FROM_U8(pCpu->abInstr[off], pCpu->abInstr[off + 1], pCpu->abInstr[off + 2], 0);
+                return RT_MAKE_U32_FROM_U8(pCpu->abInstr[offInstr], pCpu->abInstr[offInstr + 1], pCpu->abInstr[offInstr + 2], 0);
         }
         return 0;
     }
 
-    disReadMore(pCpu, off, 4);
+    disReadMore(pCpu, offInstr, 4);
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint32_t const *)&pCpu->abInstr[off];
+    return *(uint32_t const *)&pCpu->abInstr[offInstr];
 #else
-    return RT_MAKE_U32_FROM_U8(pCpu->abInstr[off], pCpu->abInstr[off + 1], pCpu->abInstr[off + 2], pCpu->abInstr[off + 3]);
+    return RT_MAKE_U32_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
+                               pCpu->abInstr[offInstr + 2], pCpu->abInstr[offInstr + 3]);
 #endif
 }
@@ -444,33 +420,22 @@
 
 /**
- * Read a dword (32-bit) instruction byte by offset.
+ * Read a dword (32-bit) instruction.
  *
  * @returns The requested dword.
  * @param   pCpu                The disassembler state.
- * @param   uAddress            The address.
+ * @param   offInstr            The offset of the qword relative to the
+ *                              instruction.
  */
-DECLINLINE(uint32_t) disReadDWordByOff(PDISCPUSTATE pCpu, RTUINTPTR off)
-{
-    if (RT_UNLIKELY(off + 4 > pCpu->cbCachedInstr))
-        return disReadDWordSlow(pCpu, off);
+DECLINLINE(uint32_t) disReadDWord(PDISCPUSTATE pCpu, size_t offInstr)
+{
+    if (RT_UNLIKELY(offInstr + 4 > pCpu->cbCachedInstr))
+        return disReadDWordSlow(pCpu, offInstr);
 
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint32_t const *)&pCpu->abInstr[off];
+    return *(uint32_t const *)&pCpu->abInstr[offInstr];
 #else
-    return RT_MAKE_U32_FROM_U8(pCpu->abInstr[off], pCpu->abInstr[off + 1], pCpu->abInstr[off + 2], pCpu->abInstr[off + 3]);
+    return RT_MAKE_U32_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
+                               pCpu->abInstr[offInstr + 2], pCpu->abInstr[offInstr + 3]);
 #endif
-}
-
-
-/**
- * Read a dword (32-bit) instruction byte.
- *
- * @returns The requested dword.
- * @param   pCpu                The disassembler state.
- * @param   uAddress            The address.
- */
-DECL_FORCE_INLINE(uint32_t) disReadDWord(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
-{
-    return disReadDWordByOff(pCpu, uAddress - pCpu->uInstrAddr);
 }
 
@@ -481,40 +446,47 @@
  * @returns The requested qword.
  * @param   pCpu                The disassembler state.
- * @param   off                 The offset of the qword relative to the
+ * @param   offInstr            The offset of the qword relative to the
  *                              instruction.
  */
-DECL_NO_INLINE(static, uint64_t) disReadQWordSlow(PDISCPUSTATE pCpu, RTUINTPTR off)
-{
-    if (RT_UNLIKELY(off + 8 > DIS_MAX_INSTR_LENGTH))
+DECL_NO_INLINE(static, uint64_t) disReadQWordSlow(PDISCPUSTATE pCpu, 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;
-        switch ((RTUINTPTR)DIS_MAX_INSTR_LENGTH - off)
+        switch ((RTUINTPTR)DIS_MAX_INSTR_LENGTH - offInstr)
         {
             case 1:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[off], 0, 0, 0,   0, 0, 0, 0);
+                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr], 0, 0, 0,   0, 0, 0, 0);
             case 2:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[off], pCpu->abInstr[off + 1], 0, 0,   0, 0, 0, 0);
+                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr], pCpu->abInstr[offInstr + 1], 0, 0,   0, 0, 0, 0);
             case 3:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[off], pCpu->abInstr[off + 1], pCpu->abInstr[off + 2], 0,   0, 0, 0, 0);
+                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[offInstr    ], pCpu->abInstr[offInstr + 1],
+                                           pCpu->abInstr[offInstr + 2], 0,   0, 0, 0, 0);
             case 4:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[off], pCpu->abInstr[off + 1], pCpu->abInstr[off + 2], pCpu->abInstr[off + 3],
-                                           pCpu->abInstr[off + 4], 0, 0, 0);
+                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);
             case 5:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[off], pCpu->abInstr[off + 1], pCpu->abInstr[off + 2], pCpu->abInstr[off + 3],
-                                           pCpu->abInstr[off + 4], pCpu->abInstr[off + 5], 0, 0);
+                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);
             case 6:
-                return RT_MAKE_U64_FROM_U8(pCpu->abInstr[off], pCpu->abInstr[off + 1], pCpu->abInstr[off + 2], pCpu->abInstr[off + 3],
-                                           pCpu->abInstr[off + 4], pCpu->abInstr[off + 5], pCpu->abInstr[off + 6], 0);
+                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 0;
     }
 
-    disReadMore(pCpu, off, 8);
+    disReadMore(pCpu, offInstr, 8);
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint64_t const *)&pCpu->abInstr[off];
+    return *(uint64_t const *)&pCpu->abInstr[offInstr];
 #else
-    return RT_MAKE_U64_FROM_U8(pCpu->abInstr[off    ], pCpu->abInstr[off + 1], pCpu->abInstr[off + 2], pCpu->abInstr[off + 3],
-                               pCpu->abInstr[off + 4], pCpu->abInstr[off + 5], pCpu->abInstr[off + 6], pCpu->abInstr[off + 7]);
+    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]);
 #endif
 }
@@ -522,5 +494,5 @@
 
 /**
- * Read a qword (64-bit) instruction byte by offset.
+ * Read a qword (64-bit) instruction.
  *
  * @returns The requested qword.
@@ -528,40 +500,29 @@
  * @param   uAddress            The address.
  */
-DECLINLINE(uint64_t) disReadQWordByOff(PDISCPUSTATE pCpu, RTUINTPTR off)
-{
-    if (RT_UNLIKELY(off + 8 > pCpu->cbCachedInstr))
-        return disReadQWordSlow(pCpu, off);
+DECLINLINE(uint64_t) disReadQWord(PDISCPUSTATE pCpu, size_t offInstr)
+{
+    if (RT_UNLIKELY(offInstr + 8 > pCpu->cbCachedInstr))
+        return disReadQWordSlow(pCpu, offInstr);
 
 #ifdef DIS_HOST_UNALIGNED_ACCESS_OK
-    return *(uint64_t const *)&pCpu->abInstr[off];
+    return *(uint64_t const *)&pCpu->abInstr[offInstr];
 #else
-    return RT_MAKE_U64_FROM_U8(pCpu->abInstr[off    ], pCpu->abInstr[off + 1], pCpu->abInstr[off + 2], pCpu->abInstr[off + 3],
-                               pCpu->abInstr[off + 4], pCpu->abInstr[off + 5], pCpu->abInstr[off + 6], pCpu->abInstr[off + 7]);
+    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]);
 #endif
 }
 
 
-/**
- * Read a qword (64-bit) instruction byte.
- *
- * @returns The requested qword.
- * @param   pCpu                The disassembler state.
- * @param   uAddress            The address.
- */
-DECL_FORCE_INLINE(uint64_t) disReadQWord(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
-{
-    return disReadQWordByOff(pCpu, uAddress - pCpu->uInstrAddr);
-}
-
-
-
-//*****************************************************************************
-//*****************************************************************************
-static unsigned disParseInstruction(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISCPUSTATE pCpu)
+
+//*****************************************************************************
+//*****************************************************************************
+static unsigned disParseInstruction(size_t offInstr, PCDISOPCODE pOp, PDISCPUSTATE pCpu)
 {
     int  size = 0;
     bool fFiltered = false;
 
-    Assert(uCodePtr && pOp && pCpu);
+    Assert(pOp); Assert(pCpu);
 
     // Store the opcode format string for disasmPrintf
@@ -608,5 +569,5 @@
     if (pOp->idxParse1 != IDX_ParseNop)
     {
-        size += pCpu->pfnDisasmFnTable[pOp->idxParse1](uCodePtr, pOp, &pCpu->Param1, pCpu);
+        size += pCpu->pfnDisasmFnTable[pOp->idxParse1](offInstr, pOp, &pCpu->Param1, pCpu);
         if (fFiltered == false) pCpu->Param1.cb = DISGetParamSize(pCpu, &pCpu->Param1);
     }
@@ -614,5 +575,5 @@
     if (pOp->idxParse2 != IDX_ParseNop)
     {
-        size += pCpu->pfnDisasmFnTable[pOp->idxParse2](uCodePtr+size, pOp, &pCpu->Param2, pCpu);
+        size += pCpu->pfnDisasmFnTable[pOp->idxParse2](offInstr+size, pOp, &pCpu->Param2, pCpu);
         if (fFiltered == false) pCpu->Param2.cb = DISGetParamSize(pCpu, &pCpu->Param2);
     }
@@ -620,5 +581,5 @@
     if (pOp->idxParse3 != IDX_ParseNop)
     {
-        size += pCpu->pfnDisasmFnTable[pOp->idxParse3](uCodePtr+size, pOp, &pCpu->Param3, pCpu);
+        size += pCpu->pfnDisasmFnTable[pOp->idxParse3](offInstr+size, pOp, &pCpu->Param3, pCpu);
         if (fFiltered == false) pCpu->Param3.cb = DISGetParamSize(pCpu, &pCpu->Param3);
     }
@@ -630,5 +591,5 @@
 /* Floating point opcode parsing */
 //*****************************************************************************
-static unsigned ParseEscFP(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseEscFP(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     int index;
@@ -638,5 +599,5 @@
     NOREF(pOp);
 
-    ModRM = disReadByte(pCpu, uCodePtr);
+    ModRM = disReadByte(pCpu, offInstr);
 
     index = pCpu->bOpCode - 0xD8;
@@ -683,8 +644,8 @@
 
     if (fpop->idxParse1 != IDX_ParseNop)
-        size += pCpu->pfnDisasmFnTable[fpop->idxParse1](uCodePtr+size, (PCDISOPCODE)fpop, pParam, pCpu);
+        size += pCpu->pfnDisasmFnTable[fpop->idxParse1](offInstr+size, (PCDISOPCODE)fpop, pParam, pCpu);
 
     if (fpop->idxParse2 != IDX_ParseNop)
-        size += pCpu->pfnDisasmFnTable[fpop->idxParse2](uCodePtr+size, (PCDISOPCODE)fpop, pParam, pCpu);
+        size += pCpu->pfnDisasmFnTable[fpop->idxParse2](offInstr+size, (PCDISOPCODE)fpop, pParam, pCpu);
 
     return size;
@@ -695,8 +656,7 @@
 // Scale  Index  Base
 //*****************************************************************************
-static void UseSIB(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    unsigned regtype;
-    NOREF(uCodePtr); NOREF(pOp);
+static void UseSIB(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp);
 
     unsigned scale = pCpu->SIB.Bits.Scale;
@@ -704,4 +664,5 @@
     unsigned index = pCpu->SIB.Bits.Index;
 
+    unsigned regtype;
     if (pCpu->uAddrMode == DISCPUMODE_32BIT)
         regtype    = DISUSE_REG_GEN32;
@@ -744,5 +705,5 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseSIB(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseSIB(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);
@@ -750,6 +711,6 @@
     NOREF(pOp); NOREF(pParam);
 
-    SIB = disReadByte(pCpu, uCodePtr);
-    uCodePtr += size;
+    SIB = disReadByte(pCpu, offInstr);
+    offInstr += size;
 
     pCpu->SIB.Bits.Base  = SIB_BASE(SIB);
@@ -770,5 +731,5 @@
     {
         /* Additional 32 bits displacement. No change in long mode. */
-        pCpu->i32SibDisp = disReadDWord(pCpu, uCodePtr);
+        pCpu->i32SibDisp = disReadDWord(pCpu, offInstr);
         size += sizeof(int32_t);
     }
@@ -777,5 +738,5 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseSIB_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseSIB_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);
@@ -783,6 +744,5 @@
     NOREF(pOp); NOREF(pParam);
 
-    SIB = disReadByte(pCpu, uCodePtr);
-    uCodePtr += size;
+    SIB = disReadByte(pCpu, offInstr);
 
     pCpu->SIB.Bits.Base  = SIB_BASE(SIB);
@@ -811,5 +771,5 @@
 // Mod    Reg/Opcode  R/M
 //*****************************************************************************
-static unsigned UseModRM(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t UseModRM(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned vtype = OP_PARM_VTYPE(pParam->fParam);
@@ -894,5 +854,5 @@
             if (rm == 4)
             {   /* SIB byte follows ModRM */
-                UseSIB(uCodePtr, pOp, pParam, pCpu);
+                UseSIB(offInstr, pOp, pParam, pCpu);
             }
             else
@@ -920,5 +880,5 @@
         case 1: //effective address + 8 bits displacement
             if (rm == 4) {//SIB byte follows ModRM
-                UseSIB(uCodePtr, pOp, pParam, pCpu);
+                UseSIB(offInstr, pOp, pParam, pCpu);
             }
             else
@@ -933,5 +893,5 @@
         case 2: //effective address + 32 bits displacement
             if (rm == 4) {//SIB byte follows ModRM
-                UseSIB(uCodePtr, pOp, pParam, pCpu);
+                UseSIB(offInstr, pOp, pParam, pCpu);
             }
             else
@@ -988,5 +948,5 @@
 // Query the size of the ModRM parameters and fetch the immediate data (if any)
 //*****************************************************************************
-static unsigned QueryModRM(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
+static unsigned QueryModRM(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
 {
     unsigned sibinc;
@@ -1010,6 +970,6 @@
         if (mod != 3 && rm == 4)
         {   /* SIB byte follows ModRM */
-            *pSibInc = ParseSIB(uCodePtr, pOp, pParam, pCpu);
-            uCodePtr += *pSibInc;
+            *pSibInc = ParseSIB(offInstr, pOp, pParam, pCpu);
+            offInstr += *pSibInc;
             size += *pSibInc;
         }
@@ -1019,5 +979,5 @@
         case 0: /* Effective address */
             if (rm == 5) {  /* 32 bits displacement */
-                pCpu->i32SibDisp = disReadDWord(pCpu, uCodePtr);
+                pCpu->i32SibDisp = disReadDWord(pCpu, offInstr);
                 size += sizeof(int32_t);
             }
@@ -1026,10 +986,10 @@
 
         case 1: /* Effective address + 8 bits displacement */
-            pCpu->i32SibDisp = (int8_t)disReadByte(pCpu, uCodePtr);
+            pCpu->i32SibDisp = (int8_t)disReadByte(pCpu, offInstr);
             size += sizeof(char);
             break;
 
         case 2: /* Effective address + 32 bits displacement */
-            pCpu->i32SibDisp = disReadDWord(pCpu, uCodePtr);
+            pCpu->i32SibDisp = disReadDWord(pCpu, offInstr);
             size += sizeof(int32_t);
             break;
@@ -1046,5 +1006,5 @@
         case 0: /* Effective address */
             if (rm == 6) {
-                pCpu->i32SibDisp = disReadWord(pCpu, uCodePtr);
+                pCpu->i32SibDisp = disReadWord(pCpu, offInstr);
                 size += sizeof(uint16_t);
             }
@@ -1053,10 +1013,10 @@
 
         case 1: /* Effective address + 8 bits displacement */
-            pCpu->i32SibDisp = (int8_t)disReadByte(pCpu, uCodePtr);
+            pCpu->i32SibDisp = (int8_t)disReadByte(pCpu, offInstr);
             size += sizeof(char);
             break;
 
         case 2: /* Effective address + 32 bits displacement */
-            pCpu->i32SibDisp = (int16_t)disReadWord(pCpu, uCodePtr);
+            pCpu->i32SibDisp = (int16_t)disReadWord(pCpu, offInstr);
             size += sizeof(uint16_t);
             break;
@@ -1071,5 +1031,5 @@
 // Query the size of the ModRM parameters and fetch the immediate data (if any)
 //*****************************************************************************
-static unsigned QueryModRM_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
+static unsigned QueryModRM_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
 {
     unsigned sibinc;
@@ -1092,6 +1052,6 @@
         if (mod != 3 && rm == 4)
         {   /* SIB byte follows ModRM */
-            *pSibInc = ParseSIB_SizeOnly(uCodePtr, pOp, pParam, pCpu);
-            uCodePtr += *pSibInc;
+            *pSibInc = ParseSIB_SizeOnly(offInstr, pOp, pParam, pCpu);
+            offInstr += *pSibInc;
             size += *pSibInc;
         }
@@ -1146,7 +1106,7 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseIllegal(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseIllegal(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     AssertFailed();
     return 0;
@@ -1154,11 +1114,11 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseModRM(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseModRM(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);   //ModRM byte
     unsigned sibinc, ModRM;
 
-    ModRM = disReadByte(pCpu, uCodePtr);
-    uCodePtr += sizeof(uint8_t);
+    ModRM = disReadByte(pCpu, offInstr);
+    offInstr += sizeof(uint8_t);
 
     pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM);
@@ -1192,19 +1152,19 @@
         }
     }
-    size += QueryModRM(uCodePtr, pOp, pParam, pCpu, &sibinc);
-    uCodePtr += sibinc;
-
-    UseModRM(uCodePtr, pOp, pParam, pCpu);
+    size += QueryModRM(offInstr, pOp, pParam, pCpu, &sibinc);
+    offInstr += sibinc;
+
+    UseModRM(offInstr, pOp, pParam, pCpu);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseModRM_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseModRM_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);   //ModRM byte
     unsigned sibinc, ModRM;
 
-    ModRM = disReadByte(pCpu, uCodePtr);
-    uCodePtr += sizeof(uint8_t);
+    ModRM = disReadByte(pCpu, offInstr);
+    offInstr += sizeof(uint8_t);
 
     pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM);
@@ -1239,6 +1199,6 @@
     }
 
-    size += QueryModRM_SizeOnly(uCodePtr, pOp, pParam, pCpu, &sibinc);
-    uCodePtr += sibinc;
+    size += QueryModRM_SizeOnly(offInstr, pOp, pParam, pCpu, &sibinc);
+    offInstr += sibinc;
 
     /* UseModRM is not necessary here; we're only interested in the opcode size */
@@ -1247,17 +1207,17 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseModFence(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseModFence(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     ////AssertMsgFailed(("??\n"));
     //nothing to do apparently
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return 0;
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmByte(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmByte(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->uValue = disReadByte(pCpu, uCodePtr);
+    pParam->uValue = disReadByte(pCpu, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE8;
     pParam->cb     = sizeof(uint8_t);
@@ -1266,17 +1226,17 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmByte_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmByte_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(uint8_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmByteSX(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmByteSX(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
     if (pCpu->uOpMode == DISCPUMODE_32BIT)
     {
-        pParam->uValue = (uint32_t)(int8_t)disReadByte(pCpu, uCodePtr);
+        pParam->uValue = (uint32_t)(int8_t)disReadByte(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE32_SX8;
         pParam->cb     = sizeof(uint32_t);
@@ -1285,5 +1245,5 @@
     if (pCpu->uOpMode == DISCPUMODE_64BIT)
     {
-        pParam->uValue = (uint64_t)(int8_t)disReadByte(pCpu, uCodePtr);
+        pParam->uValue = (uint64_t)(int8_t)disReadByte(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE64_SX8;
         pParam->cb     = sizeof(uint64_t);
@@ -1291,5 +1251,5 @@
     else
     {
-        pParam->uValue = (uint16_t)(int8_t)disReadByte(pCpu, uCodePtr);
+        pParam->uValue = (uint16_t)(int8_t)disReadByte(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE16_SX8;
         pParam->cb     = sizeof(uint16_t);
@@ -1299,15 +1259,15 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmByteSX_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmByteSX_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(uint8_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmUshort(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmUshort(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->uValue = disReadWord(pCpu, uCodePtr);
+    pParam->uValue = disReadWord(pCpu, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
@@ -1316,15 +1276,15 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmUshort_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmUshort_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(uint16_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmUlong(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmUlong(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->uValue = disReadDWord(pCpu, uCodePtr);
+    pParam->uValue = disReadDWord(pCpu, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE32;
     pParam->cb     = sizeof(uint32_t);
@@ -1333,15 +1293,15 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmUlong_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmUlong_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(uint32_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmQword(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmQword(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->uValue = disReadQWord(pCpu, uCodePtr);
+    pParam->uValue = disReadQWord(pCpu, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE64;
     pParam->cb     = sizeof(uint64_t);
@@ -1350,17 +1310,17 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmQword_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmQword_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(uint64_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmV(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmV(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
     if (pCpu->uOpMode == DISCPUMODE_32BIT)
     {
-        pParam->uValue = disReadDWord(pCpu, uCodePtr);
+        pParam->uValue = disReadDWord(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
@@ -1370,5 +1330,5 @@
     if (pCpu->uOpMode == DISCPUMODE_64BIT)
     {
-        pParam->uValue = disReadQWord(pCpu, uCodePtr);
+        pParam->uValue = disReadQWord(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
@@ -1376,5 +1336,5 @@
     }
 
-    pParam->uValue = disReadWord(pCpu, uCodePtr);
+    pParam->uValue = disReadWord(pCpu, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
@@ -1383,7 +1343,7 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmV_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
+static size_t ParseImmV_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam);
     if (pCpu->uOpMode == DISCPUMODE_32BIT)
         return sizeof(uint32_t);
@@ -1394,5 +1354,5 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmZ(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmZ(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
@@ -1400,5 +1360,5 @@
     if (pCpu->uOpMode == DISCPUMODE_16BIT)
     {
-        pParam->uValue = disReadWord(pCpu, uCodePtr);
+        pParam->uValue = disReadWord(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE16;
         pParam->cb     = sizeof(uint16_t);
@@ -1409,5 +1369,5 @@
     if (pCpu->uOpMode == DISCPUMODE_64BIT)
     {
-        pParam->uValue = (uint64_t)(int32_t)disReadDWord(pCpu, uCodePtr);
+        pParam->uValue = (uint64_t)(int32_t)disReadDWord(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
@@ -1415,5 +1375,5 @@
     else
     {
-        pParam->uValue = disReadDWord(pCpu, uCodePtr);
+        pParam->uValue = disReadDWord(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
@@ -1423,7 +1383,7 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmZ_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
+static size_t ParseImmZ_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    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)
@@ -1435,8 +1395,8 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-static unsigned ParseImmBRel(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmBRel(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->uValue = disReadByte(pCpu, uCodePtr);
+    pParam->uValue = disReadByte(pCpu, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE8_REL;
     pParam->cb     = sizeof(uint8_t);
@@ -1446,7 +1406,7 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-static unsigned ParseImmBRel_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+static size_t ParseImmBRel_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(char);
 }
@@ -1454,10 +1414,10 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-static unsigned ParseImmVRel(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmVRel(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
     if (pCpu->uOpMode == DISCPUMODE_32BIT)
     {
-        pParam->uValue = disReadDWord(pCpu, uCodePtr);
+        pParam->uValue = disReadDWord(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE32_REL;
         pParam->cb     = sizeof(int32_t);
@@ -1468,5 +1428,5 @@
     {
         /* 32 bits relative immediate sign extended to 64 bits. */
-        pParam->uValue = (uint64_t)(int32_t)disReadDWord(pCpu, uCodePtr);
+        pParam->uValue = (uint64_t)(int32_t)disReadDWord(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE64_REL;
         pParam->cb     = sizeof(int64_t);
@@ -1474,5 +1434,5 @@
     }
 
-    pParam->uValue = disReadWord(pCpu, uCodePtr);
+    pParam->uValue = disReadWord(pCpu, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE16_REL;
     pParam->cb     = sizeof(int16_t);
@@ -1482,7 +1442,7 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-static unsigned ParseImmVRel_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
+static size_t ParseImmVRel_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp); NOREF(pParam);
     if (pCpu->uOpMode == DISCPUMODE_16BIT)
         return sizeof(int16_t);
@@ -1492,5 +1452,5 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmAddr(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmAddr(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     if (pCpu->uAddrMode == DISCPUMODE_32BIT)
@@ -1499,6 +1459,6 @@
         {
             /* far 16:32 pointer */
-            pParam->uValue = disReadDWord(pCpu, uCodePtr);
-            *((uint32_t*)&pParam->uValue+1) = disReadWord(pCpu, uCodePtr+sizeof(uint32_t));
+            pParam->uValue = disReadDWord(pCpu, offInstr);
+            *((uint32_t*)&pParam->uValue+1) = disReadWord(pCpu, offInstr+sizeof(uint32_t));
             pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
             pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
@@ -1512,5 +1472,5 @@
          * so we treat it like displacement.
          */
-        pParam->uDisp.i32 = disReadDWord(pCpu, uCodePtr);
+        pParam->uDisp.i32 = disReadDWord(pCpu, offInstr);
         pParam->fUse  |= DISUSE_DISPLACEMENT32;
         pParam->cb     = sizeof(uint32_t);
@@ -1527,5 +1487,5 @@
          * so we treat it like displacement.
          */
-        pParam->uDisp.i64 = disReadQWord(pCpu, uCodePtr);
+        pParam->uDisp.i64 = disReadQWord(pCpu, offInstr);
         pParam->fUse  |= DISUSE_DISPLACEMENT64;
         pParam->cb     = sizeof(uint64_t);
@@ -1535,5 +1495,5 @@
     {
         /* far 16:16 pointer */
-        pParam->uValue = disReadDWord(pCpu, uCodePtr);
+        pParam->uValue = disReadDWord(pCpu, offInstr);
         pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
         pParam->cb     = 2*sizeof(uint16_t);
@@ -1547,5 +1507,5 @@
      * so we treat it like displacement.
      */
-    pParam->uDisp.i16 = disReadWord(pCpu, uCodePtr);
+    pParam->uDisp.i16 = disReadWord(pCpu, offInstr);
     pParam->fUse  |= DISUSE_DISPLACEMENT16;
     pParam->cb     = sizeof(uint16_t);
@@ -1554,7 +1514,7 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmAddr_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp);
+static size_t ParseImmAddr_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp);
     if (pCpu->uAddrMode == DISCPUMODE_32BIT)
     {
@@ -1587,5 +1547,5 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmAddrF(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmAddrF(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     // immediate far pointers - only 16:16 or 16:32; determined by operand, *not* address size!
@@ -1595,6 +1555,6 @@
     {
         // far 16:32 pointer
-        pParam->uValue = disReadDWord(pCpu, uCodePtr);
-        *((uint32_t*)&pParam->uValue+1) = disReadWord(pCpu, uCodePtr+sizeof(uint32_t));
+        pParam->uValue = disReadDWord(pCpu, offInstr);
+        *((uint32_t*)&pParam->uValue+1) = disReadWord(pCpu, offInstr+sizeof(uint32_t));
         pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
         pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
@@ -1603,5 +1563,5 @@
 
     // far 16:16 pointer
-    pParam->uValue = disReadDWord(pCpu, uCodePtr);
+    pParam->uValue = disReadDWord(pCpu, offInstr);
     pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
     pParam->cb     = 2*sizeof(uint16_t);
@@ -1610,7 +1570,7 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmAddrF_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp);
+static size_t ParseImmAddrF_SizeOnly(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp);
     // immediate far pointers - only 16:16 or 16:32
     Assert(pCpu->uOpMode == DISCPUMODE_16BIT || pCpu->uOpMode == DISCPUMODE_32BIT);
@@ -1629,7 +1589,7 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseFixedReg(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr);
+static size_t ParseFixedReg(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr);
 
     /*
@@ -1730,7 +1690,7 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseXv(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr);
+static size_t ParseXv(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr);
 
     pParam->fUse |= DISUSE_POINTER_DS_BASED;
@@ -1755,7 +1715,7 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseXb(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp);
+static size_t ParseXb(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp);
 
     pParam->fUse |= DISUSE_POINTER_DS_BASED;
@@ -1780,7 +1740,7 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseYv(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr);
+static size_t ParseYv(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr);
 
     pParam->fUse |= DISUSE_POINTER_ES_BASED;
@@ -1805,7 +1765,7 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseYb(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(uCodePtr); NOREF(pOp);
+static size_t ParseYb(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(offInstr); NOREF(pOp);
 
     pParam->fUse |= DISUSE_POINTER_ES_BASED;
@@ -1830,5 +1790,5 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseTwoByteEsc(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseTwoByteEsc(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     PCDISOPCODE   pOpcode;
@@ -1837,5 +1797,5 @@
 
     /* 2nd byte */
-    pCpu->bOpCode = disReadByte(pCpu, uCodePtr);
+    pCpu->bOpCode = disReadByte(pCpu, offInstr);
 
     /* default to the non-prefixed table. */
@@ -1884,10 +1844,10 @@
     }
 
-    size += disParseInstruction(uCodePtr+size, pOpcode, pCpu);
+    size += disParseInstruction(offInstr+size, pOpcode, pCpu);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseThreeByteEsc4(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseThreeByteEsc4(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     PCDISOPCODE   pOpcode;
@@ -1896,5 +1856,5 @@
 
     /* 3rd byte */
-    pCpu->bOpCode = disReadByte(pCpu, uCodePtr);
+    pCpu->bOpCode = disReadByte(pCpu, offInstr);
 
     /* default to the non-prefixed table. */
@@ -1945,10 +1905,10 @@
     }
 
-    size += disParseInstruction(uCodePtr+size, pOpcode, pCpu);
+    size += disParseInstruction(offInstr+size, pOpcode, pCpu);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseThreeByteEsc5(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseThreeByteEsc5(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     PCDISOPCODE   pOpcode;
@@ -1957,5 +1917,5 @@
 
     /* 3rd byte */
-    pCpu->bOpCode = disReadByte(pCpu, uCodePtr);
+    pCpu->bOpCode = disReadByte(pCpu, offInstr);
 
     /** @todo Should we take the first or last prefix byte in case of multiple prefix bytes??? */
@@ -1980,10 +1940,10 @@
         pOpcode = &g_InvalidOpcode[0];
 
-    size += disParseInstruction(uCodePtr+size, pOpcode, pCpu);
+    size += disParseInstruction(offInstr+size, pOpcode, pCpu);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseNopPause(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseNopPause(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0;
@@ -1998,10 +1958,10 @@
         pOp = &g_aMapX86_NopPause[0]; /* NOP */
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseImmGrpl(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseImmGrpl(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     int idx = (pCpu->bOpCode - 0x80) * 8;
@@ -2009,5 +1969,5 @@
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2017,5 +1977,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2023,5 +1983,5 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseShiftGrp2(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseShiftGrp2(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     int idx;
@@ -2048,5 +2008,5 @@
     }
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2057,5 +2017,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2063,5 +2023,5 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp3(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp3(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     int idx = (pCpu->bOpCode - 0xF6) * 8;
@@ -2069,5 +2029,5 @@
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2078,5 +2038,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2084,10 +2044,10 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp4(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp4(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2098,5 +2058,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2104,10 +2064,10 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp5(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp5(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2118,5 +2078,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2128,5 +2088,5 @@
 //
 //*****************************************************************************
-static unsigned Parse3DNow(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t Parse3DNow(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrmsize;
@@ -2137,12 +2097,12 @@
 #endif
 
-    unsigned ModRM = disReadByte(pCpu, uCodePtr);
+    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);
 
-    modrmsize = QueryModRM(uCodePtr+sizeof(uint8_t), pOp, pParam, pCpu, NULL);
-
-    uint8_t opcode = disReadByte(pCpu, uCodePtr+sizeof(uint8_t)+modrmsize);
+    modrmsize = QueryModRM(offInstr+sizeof(uint8_t), pOp, pParam, pCpu, NULL);
+
+    uint8_t opcode = disReadByte(pCpu, offInstr+sizeof(uint8_t)+modrmsize);
 
     pOp = (PCDISOPCODE)&g_aTwoByteMapX86_3DNow[opcode];
@@ -2157,5 +2117,5 @@
     }
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
     size += sizeof(uint8_t);   //imm8_opcode uint8_t
 
@@ -2164,10 +2124,10 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp6(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp6(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2178,5 +2138,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2184,10 +2144,10 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp7(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp7(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg, rm, mod;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     mod   = MODRM_MOD(modrm);
     reg   = MODRM_REG(modrm);
@@ -2206,5 +2166,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2212,10 +2172,10 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp8(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp8(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2226,5 +2186,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2232,10 +2192,10 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp9(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp9(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2246,5 +2206,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2252,10 +2212,10 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp10(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp10(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2266,5 +2226,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2272,10 +2232,10 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp12(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp12(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2289,15 +2249,15 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp13(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp13(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
     if (pCpu->fPrefix & DISPREFIX_OPSIZE)
@@ -2310,5 +2270,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2316,10 +2276,10 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp14(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp14(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
     if (pCpu->fPrefix & DISPREFIX_OPSIZE)
@@ -2332,5 +2292,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
 
     return size;
@@ -2338,10 +2298,10 @@
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp15(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp15(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg, mod, rm;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     mod   = MODRM_MOD(modrm);
     reg   = MODRM_REG(modrm);
@@ -2357,15 +2317,15 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
     return size;
 }
 //*****************************************************************************
 //*****************************************************************************
-static unsigned ParseGrp16(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
+static size_t ParseGrp16(size_t offInstr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = disReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, offInstr);
     reg   = MODRM_REG(modrm);
 
@@ -2376,5 +2336,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(offInstr, pOp, pCpu);
     return size;
 }
@@ -2576,16 +2536,15 @@
  * @param   pCpu            Initialized cpu state.
  * @param   paOneByteMap    The one byte opcode map to use.
- * @param   uInstrAddr      Instruction address.
  * @param   pcbInstr        Where to store the instruction size. Can be NULL.
  */
-static int disInstrWorker(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, PCDISOPCODE paOneByteMap, uint32_t *pcbInstr)
+static int disInstrWorker(PDISCPUSTATE pCpu, PCDISOPCODE paOneByteMap, uint32_t *pcbInstr)
 {
     /*
      * Parse byte by byte.
      */
-    size_t offByte = 0;
+    size_t offInstr = 0;
     for (;;)
     {
-        uint8_t codebyte = disReadByteByOff(pCpu, offByte++);
+        uint8_t codebyte = disReadByte(pCpu, offInstr++);
         uint8_t opcode   = paOneByteMap[codebyte].uOpcode;
 
@@ -2605,5 +2564,5 @@
             case OP_INVALID:
                 if (pcbInstr)
-                    *pcbInstr = (uint32_t)offByte;
+                    *pcbInstr = (uint32_t)offInstr;
                 return pCpu->rc = VERR_DIS_INVALID_OPCODE;
 
@@ -2667,11 +2626,11 @@
         /* first opcode byte. */
         pCpu->bOpCode = codebyte;
-        offByte += disParseInstruction(uInstrAddr + offByte, &paOneByteMap[pCpu->bOpCode], pCpu);
+        offInstr += disParseInstruction(offInstr, &paOneByteMap[pCpu->bOpCode], pCpu);
         break;
     }
 
-    pCpu->cbInstr = offByte;
+    pCpu->cbInstr = offInstr;
     if (pcbInstr)
-        *pcbInstr = offByte;
+        *pcbInstr = offInstr;
 
     if (pCpu->fPrefix & DISPREFIX_LOCK)
@@ -2768,5 +2727,5 @@
     }
 
-    return disInstrWorker(pCpu, uInstrAddr, paOneByteMap, pcbInstr);
+    return disInstrWorker(pCpu, paOneByteMap, pcbInstr);
 }