Index: /trunk/include/VBox/dis.h
===================================================================
--- /trunk/include/VBox/dis.h	(revision 41667)
+++ /trunk/include/VBox/dis.h	(revision 41668)
@@ -31,7 +31,4 @@
 #include <VBox/disopcode.h>
 
-#if defined(__L4ENV__)
-# include <setjmp.h>
-#endif
 
 RT_C_DECLS_BEGIN
@@ -412,8 +409,4 @@
     /** Parameter size. */
     uint8_t         cb;
-
-#ifndef DIS_SEPARATE_FORMATTER
-    char            szParam[32];
-#endif
 } OP_PARAMETER;
 /** Pointer to opcode parameter. */
@@ -454,9 +447,9 @@
 
     /** Per instruction prefix settings. */
-    uint32_t        prefix;
+    uint32_t        prefix;  /**< @todo change to uint8_t */
     /** segment prefix value. */
     DIS_SELREG      enmPrefixSeg;
     /** rex prefix value (64 bits only */
-    uint32_t        prefix_rex;
+    uint32_t        prefix_rex; /**< @todo change to uint8_t */
     /** addressing mode (16 or 32 bits). (CPUMODE_*) */
     DISCPUMODE      addrmode;
@@ -501,6 +494,4 @@
     /** The address of the instruction. */
     RTUINTPTR       uInstrAddr;
-    /** The offsetted address of the instruction. */
-    RTUINTPTR       opaddr;
     /** The size of the prefix bytes. */
     uint8_t         cbPrefix;
@@ -559,15 +550,18 @@
 
 
-DISDECL(int) DISInstr(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PDISCPUSTATE pCpu, uint32_t *pcbSize, char *pszOutput);
-DISDECL(int) DISInstrWithOff(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, RTUINTPTR offRealAddr, uint32_t *pcbSize, char *pszOutput);
+DISDECL(int) DISInstr(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PDISCPUSTATE pCpu, uint32_t *pcbInstr, char *pszOutput);
+DISDECL(int) DISInstrWithOff(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, RTUINTPTR offRealAddr, uint32_t *pcbInstr, char *pszOutput);
 DISDECL(int) DISInstrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
-                                PDISCPUSTATE pCpu, uint32_t *pcbSize, char *pszOutput);
+                                PDISCPUSTATE pCpu, uint32_t *pcbInstr, char *pszOutput);
 DISDECL(int) DISInstrEx(RTUINTPTR uInstrAddr, RTUINTPTR offRealAddr, DISCPUMODE enmCpuMode,
                         PFNDISREADBYTES pfnReadBytes, void *pvUser, uint32_t uFilter,
-                        PDISCPUSTATE pCpu, uint32_t *pcbSize, char *pszOutput);
-
-DISDECL(int) DISCoreOne(PDISCPUSTATE pCpu, RTUINTPTR InstructionAddr, uint32_t *pcbInstruction);
-DISDECL(int) DISCoreOneEx(RTUINTPTR InstructionAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
-                          PDISCPUSTATE pCpu, uint32_t *pcbInstruction);
+                        PDISCPUSTATE pCpu, uint32_t *pcbInstr, char *pszOutput);
+
+DISDECL(int) DISCoreOne(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PDISCPUSTATE pCpu, uint32_t *pcbInstr);
+DISDECL(int) DISCoreOneWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
+                                  PDISCPUSTATE pCpu, uint32_t *pcbInstr);
+DISDECL(int) DISCoreOneExEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t uFilter,
+                            PFNDISREADBYTES pfnReadBytes, void *pvUser,
+                            PDISCPUSTATE pCpu, uint32_t *pcbInstr);
 
 DISDECL(int)        DISGetParamSize(PDISCPUSTATE pCpu, POP_PARAMETER pParam);
Index: /trunk/src/VBox/Devices/PC/BIOS-new/MakeDebianBiosAssembly.cpp
===================================================================
--- /trunk/src/VBox/Devices/PC/BIOS-new/MakeDebianBiosAssembly.cpp	(revision 41667)
+++ /trunk/src/VBox/Devices/PC/BIOS-new/MakeDebianBiosAssembly.cpp	(revision 41668)
@@ -968,6 +968,6 @@
             unsigned    cbInstr;
             DISCPUSTATE CpuState;
-            int rc = DISCoreOneEx(uFlatAddr, fIs16Bit ? CPUMODE_16BIT : CPUMODE_32BIT,
-                                  disReadOpcodeBytes, NULL, &CpuState, &cbInstr);
+            int rc = DISCoreOneWithReader(uFlatAddr, fIs16Bit ? CPUMODE_16BIT : CPUMODE_32BIT,
+                                          disReadOpcodeBytes, NULL, &CpuState, &cbInstr);
             if (   RT_SUCCESS(rc)
                 && cbInstr <= cb)
Index: /trunk/src/VBox/Disassembler/Disasm.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/Disasm.cpp	(revision 41667)
+++ /trunk/src/VBox/Disassembler/Disasm.cpp	(revision 41668)
@@ -1,10 +1,9 @@
+/* $Id$ */
 /** @file
- *
- * VBox disassembler:
- * Main
+ * VBox disassembler - Disassemble and optionally format.
  */
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -21,7 +20,5 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#ifdef USING_VISUAL_STUDIO
-# include <stdafx.h>
-#endif
+#define LOG_GROUP LOG_GROUP_DIS
 #include <VBox/dis.h>
 #include <VBox/disopcode.h>
@@ -40,14 +37,14 @@
  *                          set correctly.
  * @param   uInstrAddr      Pointer to the structure to disassemble.
- * @param   pcbSize         Where to store the size of the instruction.
- *                          NULL is allowed.
+ * @param   pcbInstr        Where to store the size of the instruction. NULL is
+ *                          allowed.
  * @param   pszOutput       Storage for disassembled instruction
  *
  * @todo    Define output callback.
  */
-DISDECL(int) DISInstr(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PDISCPUSTATE pCpu, uint32_t *pcbSize, char *pszOutput)
+DISDECL(int) DISInstr(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PDISCPUSTATE pCpu, uint32_t *pcbInstr, char *pszOutput)
 {
     return DISInstrEx(uInstrAddr, 0, enmCpuMode, NULL, NULL, OPTYPE_ALL,
-                      pCpu, pcbSize, pszOutput);
+                      pCpu, pcbInstr, pszOutput);
 }
 
@@ -61,6 +58,6 @@
  * @param   offRealAddr     Offset to add to instruction address to get the real
  *                          virtual address.
- * @param   pcbSize         Where to store the size of the instruction.
- *                          NULL is allowed.
+ * @param   pcbInstr        Where to store the size of the instruction. NULL is
+ *                          allowed.
  * @param   pszOutput       Storage for disassembled instruction
  *
@@ -68,8 +65,8 @@
  */
 DISDECL(int) DISInstrWithOff(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, RTUINTPTR offRealAddr,
-                             unsigned *pcbSize, char *pszOutput)
+                             uint32_t *pcbInstr, char *pszOutput)
 {
     return DISInstrEx(uInstrAddr, offRealAddr, pCpu->mode, pCpu->pfnReadBytes, pCpu->apvUserData[0], OPTYPE_ALL,
-                      pCpu, pcbSize, pszOutput);
+                      pCpu, pcbInstr, pszOutput);
 }
 
@@ -84,6 +81,6 @@
  *                          DISCPUSTATE::apvUserData[0]).
  * @param   pCpu            Where to return the disassembled instruction.
- * @param   pcbSize         Where to store the size of the instruction.
- *                          NULL is allowed.
+ * @param   pcbInstr        Where to store the size of the instruction. NULL is
+ *                          allowed.
  * @param   pszOutput       Storage for disassembled instruction
  *
@@ -91,9 +88,9 @@
  */
 DISDECL(int) DISInstrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
-                                PDISCPUSTATE pCpu, uint32_t *pcbSize, char *pszOutput)
+                                PDISCPUSTATE pCpu, uint32_t *pcbInstr, char *pszOutput)
 
 {
     return DISInstrEx(uInstrAddr, 0, enmCpuMode, pfnReadBytes, pvUser, OPTYPE_ALL,
-                      pCpu, pcbSize, pszOutput);
+                      pCpu, pcbInstr, pszOutput);
 }
 
@@ -106,8 +103,8 @@
  * @param   uInstrAddr      Pointer to the structure to disassemble.
  * @param   u32EipOffset    Offset to add to instruction address to get the real virtual address
- * @param   pcbSize         Where to store the size of the instruction.
- *                          NULL is allowed.
+ * @param   pcbInstr        Where to store the size of the instruction. NULL is
+ *                          allowed.
  * @param   pszOutput       Storage for disassembled instruction
- * @param   uFilter         Instruction type filter
+ * @param   uFilter         Instruction type filter.
  *
  * @todo    Define output callback.
@@ -115,308 +112,37 @@
 DISDECL(int) DISInstrEx(RTUINTPTR uInstrAddr, RTUINTPTR offRealAddr, DISCPUMODE enmCpuMode,
                         PFNDISREADBYTES pfnReadBytes, void *pvUser, uint32_t uFilter,
-                        PDISCPUSTATE pCpu, uint32_t *pcbSize, char *pszOutput)
+                        PDISCPUSTATE pCpu, uint32_t *pcbInstr, char *pszOutput)
 {
-    const OPCODE   *paOneByteMap;
+    int rc = DISCoreOneExEx(uInstrAddr, enmCpuMode, uFilter, pfnReadBytes, pvUser, pCpu, pcbInstr);
+    if (RT_SUCCESS(rc) && pszOutput)
+    {
+        size_t      cbOutput = 128;
+        size_t      cch;
+#if 0
+        RTUINTPTR   uRealAddr = uInstrAddr + offRealAddr;
+        if (pCpu->mode == CPUMODE_64BIT || uRealAddr > UINT32_MAX)
+            cch = RTStrPrintf(pszOutput, cbOutput, "%016RTptr:  ", uRealAddr);
+        else
+            cch = RTStrPrintf(pszOutput, cbOutput, "%08RX32:  ", (uint32_t)uRealAddr);
+        rc = DISFormatYasmEx(pCpu, pszOutput + cch, cbOutput - cch,
+                             DIS_FMT_FLAGS_BYTES_LEFT | DIS_FMT_FLAGS_BYTES_BRACKETS | DIS_FMT_FLAGS_BYTES_SPACED
+                             | DIS_FMT_FLAGS_RELATIVE_BRANCH,
+                             NULL /*pfnGetSymbol*/, NULL /*pvUser*/);
+#else
+        pCpu->uInstrAddr += offRealAddr;
+        rc = DISFormatYasmEx(pCpu, 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,
+                             NULL /*pfnGetSymbol*/, NULL /*pvUser*/);
+        pCpu->uInstrAddr = uInstrAddr;
+#endif
+        cch = strlen(pszOutput);
+        if (cch < cbOutput)
+        {
+            pszOutput[cch++] = '\n';
+            pszOutput[cch] = '\0';
+        }
+    }
+    return rc;
+}
 
-    /*
-     * Initialize the CPU state.
-     * Note! The RT_BZERO make ASSUMPTIONS about the placement of apvUserData.
-     */
-    RT_BZERO(pCpu, RT_OFFSETOF(DISCPUSTATE, apvUserData));
-
-    pCpu->mode              = enmCpuMode;
-    if (enmCpuMode == CPUMODE_64BIT)
-    {
-        paOneByteMap        = g_aOneByteMapX64;
-        pCpu->addrmode      = CPUMODE_64BIT;
-        pCpu->opmode        = CPUMODE_32BIT;
-    }
-    else
-    {
-        paOneByteMap        = g_aOneByteMapX86;
-        pCpu->addrmode      = enmCpuMode;
-        pCpu->opmode        = enmCpuMode;
-    }
-    pCpu->prefix            = PREFIX_NONE;
-    pCpu->enmPrefixSeg      = DIS_SELREG_DS;
-    pCpu->uInstrAddr        = uInstrAddr;
-    pCpu->opaddr            = uInstrAddr + offRealAddr;
-    pCpu->pfnDisasmFnTable  = pfnFullDisasm;
-    pCpu->uFilter           = uFilter;
-    pCpu->rc                = VINF_SUCCESS;
-    pCpu->pfnReadBytes      = pfnReadBytes ? pfnReadBytes : disReadBytesDefault;
-    pCpu->apvUserData[0]    = pvUser;
-
-    /*
-     * Parse the instruction byte by byte.
-     */
-    unsigned i        = 0;
-    unsigned cbPrefix = 0; /** @todo this isn't really needed, is it? Seems to be a bit too many variables tracking the same stuff here. cbInc, i, cbPrefix, idx... */
-    for (;;)
-    {
-        uint8_t codebyte = DISReadByte(pCpu, uInstrAddr+i);
-        uint8_t opcode   = paOneByteMap[codebyte].opcode;
-
-        /* Hardcoded assumption about OP_* values!! */
-        if (opcode <= OP_LAST_PREFIX)
-        {
-            /* The REX prefix must precede the opcode byte(s). Any other placement is ignored. */
-            if (opcode != OP_REX)
-            {
-                pCpu->lastprefix = opcode;
-                pCpu->prefix &= ~PREFIX_REX;
-            }
-
-            switch (opcode)
-            {
-            case OP_INVALID:
-                if (pcbSize)
-                    *pcbSize = pCpu->opsize;
-                return pCpu->rc = VERR_DIS_INVALID_OPCODE;
-
-            // segment override prefix byte
-            case OP_SEG:
-                pCpu->enmPrefixSeg = (DIS_SELREG)(paOneByteMap[codebyte].param1 - OP_PARM_REG_SEG_START);
-                /* Segment prefixes for CS, DS, ES and SS are ignored in long mode. */
-                if (   pCpu->mode != CPUMODE_64BIT
-                    || pCpu->enmPrefixSeg >= DIS_SELREG_FS)
-                    pCpu->prefix |= PREFIX_SEG;
-                i += sizeof(uint8_t);
-                cbPrefix++;
-                continue;   //fetch the next byte
-
-            // lock prefix byte
-            case OP_LOCK:
-                pCpu->prefix |= PREFIX_LOCK;
-                i += sizeof(uint8_t);
-                cbPrefix++;
-                continue;   //fetch the next byte
-
-            // address size override prefix byte
-            case OP_ADDRSIZE:
-                pCpu->prefix |= PREFIX_ADDRSIZE;
-                if (pCpu->mode == CPUMODE_16BIT)
-                    pCpu->addrmode = CPUMODE_32BIT;
-                else
-                if (pCpu->mode == CPUMODE_32BIT)
-                    pCpu->addrmode = CPUMODE_16BIT;
-                else
-                    pCpu->addrmode = CPUMODE_32BIT;     /* 64 bits */
-
-                i += sizeof(uint8_t);
-                cbPrefix++;
-                continue;   //fetch the next byte
-
-            // operand size override prefix byte
-            case OP_OPSIZE:
-                pCpu->prefix |= PREFIX_OPSIZE;
-                if (pCpu->mode == CPUMODE_16BIT)
-                    pCpu->opmode = CPUMODE_32BIT;
-                else
-                    pCpu->opmode = CPUMODE_16BIT;  /* for 32 and 64 bits mode (there is no 32 bits operand size override prefix) */
-
-                i += sizeof(uint8_t);
-                cbPrefix++;
-                continue;   //fetch the next byte
-
-            // rep and repne are not really prefixes, but we'll treat them as such
-            case OP_REPE:
-                pCpu->prefix |= PREFIX_REP;
-                i += sizeof(uint8_t);
-                cbPrefix += sizeof(uint8_t);
-                continue;   //fetch the next byte
-
-            case OP_REPNE:
-                pCpu->prefix |= PREFIX_REPNE;
-                i += sizeof(uint8_t);
-                cbPrefix += sizeof(uint8_t);
-                continue;   //fetch the next byte
-
-            case OP_REX:
-                Assert(pCpu->mode == CPUMODE_64BIT);
-                /* REX prefix byte */
-                pCpu->prefix    |= PREFIX_REX;
-                pCpu->prefix_rex = PREFIX_REX_OP_2_FLAGS(paOneByteMap[codebyte].param1);
-                i += sizeof(uint8_t);
-                cbPrefix += sizeof(uint8_t);
-
-                if (pCpu->prefix_rex & PREFIX_REX_FLAGS_W)
-                    pCpu->opmode = CPUMODE_64BIT;  /* overrides size prefix byte */
-                continue;   //fetch the next byte
-            }
-        }
-
-        pCpu->cbPrefix = i; Assert(cbPrefix == i);
-        pCpu->opcode   = codebyte;
-
-        unsigned idx = i;
-        i += sizeof(uint8_t); //first opcode byte
-
-        unsigned cbInc = ParseInstruction(uInstrAddr + i, &paOneByteMap[pCpu->opcode], pCpu);
-
-        AssertMsg(pCpu->opsize == cbPrefix + cbInc + sizeof(uint8_t),
-                  ("%u %u\n", pCpu->opsize, cbPrefix + cbInc + sizeof(uint8_t)));
-        pCpu->opsize = cbPrefix + cbInc + sizeof(uint8_t);
-
-        if (pszOutput)
-            disasmSprintf(pszOutput, uInstrAddr+i-1-cbPrefix, pCpu, &pCpu->param1, &pCpu->param2, &pCpu->param3);
-
-        i += cbInc;
-        cbPrefix = 0;
-        break;
-    }
-
-    if (pcbSize)
-        *pcbSize = i;
-
-    if (pCpu->prefix & PREFIX_LOCK)
-        disValidateLockSequence(pCpu);
-
-    return pCpu->rc;
-}
-//*****************************************************************************
-//*****************************************************************************
-static size_t DbgBytesToString(PDISCPUSTATE pCpu, char *pszOutput, size_t offStart)
-{
-    unsigned off = offStart;
-
-    while (off < 40)
-        pszOutput[off++] = ' ';
-    pszOutput[off++] = ' ';
-    pszOutput[off++] = '[';
-
-    for (unsigned i = 0; i < pCpu->opsize; i++)
-        off += RTStrPrintf(&pszOutput[off], 64, "%02X ", pCpu->abInstr[i]);
-
-    pszOutput[off - 1] = ']';  // replaces space
-    return off - offStart;
-}
-//*****************************************************************************
-//*****************************************************************************
-void disasmSprintf(char *pszOutput, RTUINTPTR uInstrAddr, PDISCPUSTATE pCpu,
-                   OP_PARAMETER *pParam1, OP_PARAMETER *pParam2, OP_PARAMETER *pParam3)
-{
-    const char *pszFormat = pCpu->pszOpcode;
-    int   param = 1;
-
-
-    size_t off = RTStrPrintf(pszOutput, 64, "%08RTptr:  ", pCpu->opaddr);
-    if (pCpu->prefix & PREFIX_LOCK)
-        off += RTStrPrintf(&pszOutput[off], 64, "lock ");
-    if (pCpu->prefix & PREFIX_REP)
-        off += RTStrPrintf(&pszOutput[off], 64, "rep(e) ");
-    else if(pCpu->prefix & PREFIX_REPNE)
-        off += RTStrPrintf(&pszOutput[off], 64, "repne ");
-
-    if (!strcmp("Invalid Opcode", pszFormat))
-    {
-        if (pCpu->opsize >= 2)
-            off += RTStrPrintf(&pszOutput[off], 64, "Invalid Opcode [%02X][%02X]", pCpu->abInstr[0], pCpu->abInstr[1]);
-        else
-            off += RTStrPrintf(&pszOutput[off], 64, "Invalid Opcode [%02X]", pCpu->abInstr[0]);
-    }
-    else
-        while (*pszFormat)
-        {
-            switch (*pszFormat)
-            {
-            case '%':
-                switch (pszFormat[1])
-                {
-                case 'J': //Relative jump offset
-                {
-                    int32_t disp;
-
-                    AssertMsg(param == 1, ("Invalid branch parameter nr"));
-                    if (pParam1->flags & USE_IMMEDIATE8_REL)
-                        disp = (int32_t)(char)pParam1->parval;
-                    else if (pParam1->flags & USE_IMMEDIATE16_REL)
-                        disp = (int32_t)(uint16_t)pParam1->parval;
-                    else if (pParam1->flags & USE_IMMEDIATE32_REL)
-                        disp = (int32_t)pParam1->parval;
-                    else if(pParam1->flags & USE_IMMEDIATE64_REL)
-                        /** @todo: is this correct? */
-                        disp = (int32_t)pParam1->parval;
-                    else
-                    {
-                        AssertMsgFailed(("Oops!\n"));
-                        return;
-                    }
-                    uint32_t addr = (uint32_t)(pCpu->opaddr + pCpu->opsize) + disp;
-                    off += RTStrPrintf(&pszOutput[off], 64, "[%08X]", addr);
-                }
-
-                    //no break;
-
-                case 'A': //direct address
-                case 'C': //control register
-                case 'D': //debug register
-                case 'E': //ModRM specifies parameter
-                case 'F': //Eflags register
-                case 'G': //ModRM selects general register
-                case 'I': //Immediate data
-                case 'M': //ModRM may only refer to memory
-                case 'O': //No ModRM byte
-                case 'P': //ModRM byte selects MMX register
-                case 'Q': //ModRM byte selects MMX register or memory address
-                case 'R': //ModRM byte may only refer to a general register
-                case 'S': //ModRM byte selects a segment register
-                case 'T': //ModRM byte selects a test register
-                case 'V': //ModRM byte selects an XMM/SSE register
-                case 'W': //ModRM byte selects an XMM/SSE register or a memory address
-                case 'X': //DS:SI
-                case 'Y': //ES:DI
-                    switch(param)
-                    {
-                    case 1:
-                        off += RTStrPrintf(&pszOutput[off], 64, pParam1->szParam);
-                        break;
-                    case 2:
-                        off += RTStrPrintf(&pszOutput[off], 64, pParam2->szParam);
-                        break;
-                    case 3:
-                        off += RTStrPrintf(&pszOutput[off], 64, pParam3->szParam);
-                        break;
-                    }
-                    break;
-
-                case 'e': //register based on operand size (e.g. %eAX)
-                    if(pCpu->opmode == CPUMODE_32BIT)
-                        off += RTStrPrintf(&pszOutput[off], 64, "E");
-                    if(pCpu->opmode == CPUMODE_64BIT)
-                        off += RTStrPrintf(&pszOutput[off], 64, "R");
-
-                    off += RTStrPrintf(&pszOutput[off], 64, "%c%c", pszFormat[2], pszFormat[3]);
-                    break;
-
-                default:
-                    AssertMsgFailed(("Oops!\n"));
-                    break;
-                }
-
-                //Go to the next parameter in the format string
-                while (*pszFormat && *pszFormat != ',')
-                    pszFormat++;
-                if (*pszFormat == ',')
-                    pszFormat--;
-
-                break;
-
-            case ',':
-                param++;
-                //no break
-
-            default:
-                off += RTStrPrintf(&pszOutput[off], 64, "%c", *pszFormat);
-                break;
-            }
-
-            if (*pszFormat)
-                pszFormat++;
-        }
-
-    off += DbgBytesToString(pCpu, pszOutput, off);
-    off += RTStrPrintf(&pszOutput[off], 64, "\n");
-}
-//*****************************************************************************
-//*****************************************************************************
Index: /trunk/src/VBox/Disassembler/DisasmCore.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41667)
+++ /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41668)
@@ -21,8 +21,4 @@
 *******************************************************************************/
 #define LOG_GROUP LOG_GROUP_DIS
-#ifdef USING_VISUAL_STUDIO
-# include <stdafx.h>
-#endif
-
 #include <VBox/dis.h>
 #include <VBox/disopcode.h>
@@ -35,40 +31,88 @@
 #include "DisasmTables.h"
 
-#if !defined(DIS_CORE_ONLY) && defined(LOG_ENABLED)
-# include <stdlib.h>
-# include <stdio.h>
-#endif
-
 
 /*******************************************************************************
 *   Internal Functions                                                         *
 *******************************************************************************/
-static int disCoreParseInstr(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, const OPCODE *paOneByteMap,
-                             unsigned *pcbInstruction);
-#if !defined(DIS_CORE_ONLY) && defined(LOG_ENABLED)
-static void disasmAddString(char *psz, const char *pszString);
-static void disasmAddStringF(char *psz, const char *pszFormat, ...);
-static void disasmAddChar(char *psz, char ch);
-# define disasmAddStringF1(psz, pszFmt, a1)         disasmAddStringF(psz, pszFmt, a1)
-# define disasmAddStringF2(psz, pszFmt, a1, a2)     disasmAddStringF(psz, pszFmt, a1, a2)
-# define disasmAddStringF3(psz, pszFmt, a1, a2, a3) disasmAddStringF(psz, pszFmt, a1, a2, a3)
-#else
-# define disasmAddString(psz, pszString)            do {} while (0)
-# define disasmAddStringF1(psz, pszFmt, a1)         do {} while (0)
-# define disasmAddStringF2(psz, pszFmt, a1, a2)     do {} while (0)
-# define disasmAddStringF3(psz, pszFmt, a1, a2, a3) do {} while (0)
-# define disasmAddChar(psz, ch)                     do {} while (0)
-#endif
-
-static unsigned QueryModRM(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc = NULL);
-static unsigned QueryModRM_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc = NULL);
-static void     UseSIB(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-static unsigned ParseSIB_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
+static int disCoreParseInstr(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, const OPCODE *paOneByteMap, uint32_t *pcbInstr);
+
+static unsigned QueryModRM(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc = NULL);
+static unsigned QueryModRM_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc = NULL);
+static void     UseSIB(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
+static unsigned ParseSIB_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
+
+static void disasmModRMReg(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam, int fRegAddr);
+static void disasmModRMReg16(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam);
+static void disasmModRMSReg(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam);
+
+
+/** @name Parsers
+ * @{ */
+static FNDISPARSE ParseIllegal;
+static FNDISPARSE ParseModRM;
+static FNDISPARSE ParseModRM_SizeOnly;
+static FNDISPARSE UseModRM;
+static FNDISPARSE ParseImmByte;
+static FNDISPARSE ParseImmByte_SizeOnly;
+static FNDISPARSE ParseImmByteSX;
+static FNDISPARSE ParseImmByteSX_SizeOnly;
+static FNDISPARSE ParseImmBRel;
+static FNDISPARSE ParseImmBRel_SizeOnly;
+static FNDISPARSE ParseImmUshort;
+static FNDISPARSE ParseImmUshort_SizeOnly;
+static FNDISPARSE ParseImmV;
+static FNDISPARSE ParseImmV_SizeOnly;
+static FNDISPARSE ParseImmVRel;
+static FNDISPARSE ParseImmVRel_SizeOnly;
+static FNDISPARSE ParseImmZ;
+static FNDISPARSE ParseImmZ_SizeOnly;
+
+static FNDISPARSE ParseImmAddr;
+static FNDISPARSE ParseImmAddr_SizeOnly;
+static FNDISPARSE ParseImmAddrF;
+static FNDISPARSE ParseImmAddrF_SizeOnly;
+static FNDISPARSE ParseFixedReg;
+static FNDISPARSE ParseImmUlong;
+static FNDISPARSE ParseImmUlong_SizeOnly;
+static FNDISPARSE ParseImmQword;
+static FNDISPARSE ParseImmQword_SizeOnly;
+
+static FNDISPARSE ParseTwoByteEsc;
+static FNDISPARSE ParseThreeByteEsc4;
+static FNDISPARSE ParseThreeByteEsc5;
+static FNDISPARSE ParseImmGrpl;
+static FNDISPARSE ParseShiftGrp2;
+static FNDISPARSE ParseGrp3;
+static FNDISPARSE ParseGrp4;
+static FNDISPARSE ParseGrp5;
+static FNDISPARSE Parse3DNow;
+static FNDISPARSE ParseGrp6;
+static FNDISPARSE ParseGrp7;
+static FNDISPARSE ParseGrp8;
+static FNDISPARSE ParseGrp9;
+static FNDISPARSE ParseGrp10;
+static FNDISPARSE ParseGrp12;
+static FNDISPARSE ParseGrp13;
+static FNDISPARSE ParseGrp14;
+static FNDISPARSE ParseGrp15;
+static FNDISPARSE ParseGrp16;
+static FNDISPARSE ParseModFence;
+static FNDISPARSE ParseNopPause;
+
+static FNDISPARSE ParseYv;
+static FNDISPARSE ParseYb;
+static FNDISPARSE ParseXv;
+static FNDISPARSE ParseXb;
+
+/* Floating point parsing */
+static FNDISPARSE ParseEscFP;
+/** @}  */
+
 
 /*******************************************************************************
 *   Global Variables                                                           *
 *******************************************************************************/
-
-PFNDISPARSE  pfnFullDisasm[IDX_ParseMax] =
+/** Parser opcode table for full disassembly. */
+PFNDISPARSE  g_apfnFullDisasm[IDX_ParseMax] =
 {
     ParseIllegal,
@@ -115,5 +159,6 @@
 };
 
-PFNDISPARSE  pfnCalcSize[IDX_ParseMax] =
+/** Parser opcode table for only calculating instruction size. */
+PFNDISPARSE  g_apfnCalcSize[IDX_ParseMax] =
 {
     ParseIllegal,
@@ -163,5 +208,30 @@
 /**
  * Parses one guest instruction.
- * The result is found in pCpu and pcbInstruction.
+ *
+ * The result is found in pCpu and pcbInstr.
+ *
+ * @returns VBox status code.
+ * @param   uInstrAddr      Address of the instruction to decode.  This is a
+ *                          real address in the current context that can be
+ *                          derefferenced.  (Consider DISCoreOneWithReader if
+ *                          this isn't the case.)
+ * @param   enmCpuMode      The CPU mode. CPUMODE_32BIT, CPUMODE_16BIT, or CPUMODE_64BIT.
+ * @param   pfnReadBytes    Callback for reading instruction bytes.
+ * @param   pvUser          User argument for the instruction reader. (Ends up in apvUserData[0].)
+ * @param   pCpu            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::opsize.
+ */
+DISDECL(int) DISCoreOne(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PDISCPUSTATE pCpu, uint32_t *pcbInstr)
+{
+    return DISCoreOneExEx(uInstrAddr, enmCpuMode, OPTYPE_ALL, NULL /*pfnReadBytes*/, NULL /*pvUser*/, pCpu, pcbInstr);
+}
+
+
+/**
+ * Parses one guest instruction.
+ *
+ * The result is found in pCpu and pcbInstr.
  *
  * @returns VBox status code.
@@ -172,9 +242,35 @@
  * @param   pvUser          User argument for the instruction reader. (Ends up in apvUserData[0].)
  * @param   pCpu            Pointer to cpu structure. Will be initialized.
- * @param   pcbInstruction  Where to store the size of the instruction.
- *                          NULL is allowed.
+ * @param   pcbInstr        Where to store the size of the instruction.
+ *                          NULL is allowed.  This is also stored in
+ *                          PDISCPUSTATE::opsize.
  */
-DISDECL(int) DISCoreOneEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
-                          PDISCPUSTATE pCpu, unsigned *pcbInstruction)
+DISDECL(int) DISCoreOneWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
+                                  PDISCPUSTATE pCpu, uint32_t *pcbInstr)
+{
+    return DISCoreOneExEx(uInstrAddr, enmCpuMode, OPTYPE_ALL, pfnReadBytes, pvUser, pCpu, pcbInstr);
+}
+
+
+/**
+ * Parses one guest instruction.
+ *
+ * The result is found in pCpu and pcbInstr.
+ *
+ * @returns VBox status code.
+ * @param   uInstrAddr      Address of the instruction to decode. What this means
+ *                          is left to the pfnReadBytes function.
+ * @param   enmCpuMode      The CPU mode. CPUMODE_32BIT, CPUMODE_16BIT, or CPUMODE_64BIT.
+ * @param   pfnReadBytes    Callback for reading instruction bytes.
+ * @param   uFilter         Instruction type filter.
+ * @param   pvUser          User argument for the instruction reader. (Ends up in apvUserData[0].)
+ * @param   pCpu            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::opsize.
+ */
+DISDECL(int) DISCoreOneExEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t uFilter,
+                            PFNDISREADBYTES pfnReadBytes, void *pvUser,
+                            PDISCPUSTATE pCpu, uint32_t *pcbInstr)
 {
     const OPCODE *paOneByteMap;
@@ -202,12 +298,13 @@
     pCpu->enmPrefixSeg      = DIS_SELREG_DS;
     pCpu->uInstrAddr        = uInstrAddr;
-    pCpu->pfnDisasmFnTable  = pfnFullDisasm;
-    pCpu->uFilter           = OPTYPE_ALL;
+    pCpu->pfnDisasmFnTable  = g_apfnFullDisasm;
+    pCpu->uFilter           = uFilter;
     pCpu->rc                = VINF_SUCCESS;
     pCpu->pfnReadBytes      = pfnReadBytes ? pfnReadBytes : disReadBytesDefault;
     pCpu->apvUserData[0]    = pvUser;
 
-    return disCoreParseInstr(pCpu, uInstrAddr, paOneByteMap, pcbInstruction);
-}
+    return disCoreParseInstr(pCpu, uInstrAddr, paOneByteMap, pcbInstr);
+}
+
 
 /**
@@ -218,7 +315,7 @@
  * @param   paOneByteMap    The one byte opcode map to use.
  * @param   uInstrAddr      Instruction address.
- * @param   pcbInstruction  Where to store the instruction size. Can be NULL.
+ * @param   pcbInstr        Where to store the instruction size. Can be NULL.
  */
-static int disCoreParseInstr(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, const OPCODE *paOneByteMap, unsigned *pcbInstruction)
+static int disCoreParseInstr(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, const OPCODE *paOneByteMap, uint32_t *pcbInstr)
 {
     /*
@@ -246,6 +343,6 @@
             {
             case OP_INVALID:
-                if (pcbInstruction)
-                    *pcbInstruction = iByte + 1;
+                if (pcbInstr)
+                    *pcbInstr = iByte + 1;
                 return pCpu->rc = VERR_DIS_INVALID_OPCODE;
 
@@ -320,5 +417,4 @@
         iByte += sizeof(uint8_t); //first opcode byte
 
-        pCpu->opaddr = uInstrAddr;
         pCpu->opcode = codebyte;
 
@@ -330,6 +426,6 @@
     AssertMsg(pCpu->opsize == iByte || RT_FAILURE_NP(pCpu->rc), ("%u %u\n", pCpu->opsize, iByte));
     pCpu->opsize = iByte;
-    if (pcbInstruction)
-        *pcbInstruction = iByte;
+    if (pcbInstr)
+        *pcbInstr = iByte;
 
     if (pCpu->prefix & PREFIX_LOCK)
@@ -340,10 +436,10 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseInstruction(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, PDISCPUSTATE pCpu)
+unsigned ParseInstruction(RTUINTPTR uCodePtr, PCOPCODE pOp, PDISCPUSTATE pCpu)
 {
     int  size = 0;
     bool fFiltered = false;
 
-    Assert(lpszCodeBlock && pOp && pCpu);
+    Assert(uCodePtr && pOp && pCpu);
 
     // Store the opcode format string for disasmPrintf
@@ -360,10 +456,10 @@
     {
         fFiltered = true;
-        pCpu->pfnDisasmFnTable = pfnCalcSize;
+        pCpu->pfnDisasmFnTable = g_apfnCalcSize;
     }
     else
     {
         /* Not filtered out -> full disassembly */
-        pCpu->pfnDisasmFnTable = pfnFullDisasm;
+        pCpu->pfnDisasmFnTable = g_apfnFullDisasm;
     }
 
@@ -393,5 +489,5 @@
     if (pOp->idxParse1 != IDX_ParseNop)
     {
-        size += pCpu->pfnDisasmFnTable[pOp->idxParse1](lpszCodeBlock, pOp, &pCpu->param1, pCpu);
+        size += pCpu->pfnDisasmFnTable[pOp->idxParse1](uCodePtr, pOp, &pCpu->param1, pCpu);
         if (fFiltered == false) pCpu->param1.cb = DISGetParamSize(pCpu, &pCpu->param1);
     }
@@ -399,5 +495,5 @@
     if (pOp->idxParse2 != IDX_ParseNop)
     {
-        size += pCpu->pfnDisasmFnTable[pOp->idxParse2](lpszCodeBlock+size, pOp, &pCpu->param2, pCpu);
+        size += pCpu->pfnDisasmFnTable[pOp->idxParse2](uCodePtr+size, pOp, &pCpu->param2, pCpu);
         if (fFiltered == false) pCpu->param2.cb = DISGetParamSize(pCpu, &pCpu->param2);
     }
@@ -405,5 +501,5 @@
     if (pOp->idxParse3 != IDX_ParseNop)
     {
-        size += pCpu->pfnDisasmFnTable[pOp->idxParse3](lpszCodeBlock+size, pOp, &pCpu->param3, pCpu);
+        size += pCpu->pfnDisasmFnTable[pOp->idxParse3](uCodePtr+size, pOp, &pCpu->param3, pCpu);
         if (fFiltered == false) pCpu->param3.cb = DISGetParamSize(pCpu, &pCpu->param3);
     }
@@ -415,5 +511,5 @@
 /* Floating point opcode parsing */
 //*****************************************************************************
-unsigned ParseEscFP(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseEscFP(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     int index;
@@ -423,5 +519,5 @@
     NOREF(pOp);
 
-    ModRM = DISReadByte(pCpu, lpszCodeBlock);
+    ModRM = DISReadByte(pCpu, uCodePtr);
 
     index = pCpu->opcode - 0xD8;
@@ -446,12 +542,8 @@
      */
     if ((fpop->optype & pCpu->uFilter) == 0)
-    {
-        pCpu->pfnDisasmFnTable = pfnCalcSize;
-    }
-    else
-    {
+        pCpu->pfnDisasmFnTable = g_apfnCalcSize;
+    else
         /* Not filtered out -> full disassembly */
-        pCpu->pfnDisasmFnTable = pfnFullDisasm;
-    }
+        pCpu->pfnDisasmFnTable = g_apfnFullDisasm;
 
     /* Correct the operand size if the instruction is marked as forced or default 64 bits */
@@ -472,8 +564,8 @@
 
     if (fpop->idxParse1 != IDX_ParseNop)
-        size += pCpu->pfnDisasmFnTable[fpop->idxParse1](lpszCodeBlock+size, (PCOPCODE)fpop, pParam, pCpu);
+        size += pCpu->pfnDisasmFnTable[fpop->idxParse1](uCodePtr+size, (PCOPCODE)fpop, pParam, pCpu);
 
     if (fpop->idxParse2 != IDX_ParseNop)
-        size += pCpu->pfnDisasmFnTable[fpop->idxParse2](lpszCodeBlock+size, (PCOPCODE)fpop, pParam, pCpu);
+        size += pCpu->pfnDisasmFnTable[fpop->idxParse2](uCodePtr+size, (PCOPCODE)fpop, pParam, pCpu);
 
     // Store the opcode format string for disasmPrintf
@@ -497,10 +589,10 @@
 #endif
 //*****************************************************************************
-void UseSIB(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+void UseSIB(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned scale, base, index, regtype;
     const char **ppszSIBIndexReg;
     const char **ppszSIBBaseReg;
-    NOREF(lpszCodeBlock); NOREF(pOp);
+    NOREF(uCodePtr); NOREF(pOp);
 
     scale = pCpu->SIB.Bits.Scale;
@@ -531,14 +623,4 @@
              pParam->scale  = (1<<scale);
          }
-
-         if (base == 5 && pCpu->ModRM.Bits.Mod == 0)
-             disasmAddStringF2(pParam->szParam, "%s%s", ppszSIBIndexReg[index], szSIBScale[scale]);
-         else
-             disasmAddStringF3(pParam->szParam, "%s+%s%s", ppszSIBBaseReg[base], ppszSIBIndexReg[index], szSIBScale[scale]);
-    }
-    else
-    {
-         if (base != 5 || pCpu->ModRM.Bits.Mod != 0)
-             disasmAddStringF1(pParam->szParam, "%s", ppszSIBBaseReg[base]);
     }
 
@@ -550,6 +632,4 @@
             pParam->flags |= USE_DISPLACEMENT32;
             pParam->uDisp.i32 = pCpu->i32SibDisp;
-            disasmAddChar(pParam->szParam, '+');
-            disasmPrintDisp32(pParam);
         }
         else
@@ -557,6 +637,4 @@
             pParam->flags |= USE_DISPLACEMENT64;
             pParam->uDisp.i64 = pCpu->i32SibDisp;
-            disasmAddChar(pParam->szParam, '+');
-            disasmPrintDisp64(pParam);
         }
     }
@@ -570,5 +648,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseSIB(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseSIB(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);
@@ -576,6 +654,6 @@
     NOREF(pOp); NOREF(pParam);
 
-    SIB = DISReadByte(pCpu, lpszCodeBlock);
-    lpszCodeBlock += size;
+    SIB = DISReadByte(pCpu, uCodePtr);
+    uCodePtr += size;
 
     pCpu->SIB.Bits.Base  = SIB_BASE(SIB);
@@ -596,5 +674,5 @@
     {
         /* Additional 32 bits displacement. No change in long mode. */
-        pCpu->i32SibDisp = DISReadDWord(pCpu, lpszCodeBlock);
+        pCpu->i32SibDisp = DISReadDWord(pCpu, uCodePtr);
         size += sizeof(int32_t);
     }
@@ -603,5 +681,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseSIB_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseSIB_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);
@@ -609,6 +687,6 @@
     NOREF(pOp); NOREF(pParam);
 
-    SIB = DISReadByte(pCpu, lpszCodeBlock);
-    lpszCodeBlock += size;
+    SIB = DISReadByte(pCpu, uCodePtr);
+    uCodePtr += size;
 
     pCpu->SIB.Bits.Base  = SIB_BASE(SIB);
@@ -637,5 +715,5 @@
 // Mod    Reg/Opcode  R/M
 //*****************************************************************************
-unsigned UseModRM(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned UseModRM(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     int      vtype = OP_PARM_VTYPE(pParam->param);
@@ -667,10 +745,7 @@
                 else
                     pParam->base.reg_ctrl = reg;
-
-                disasmAddStringF1(pParam->szParam, "CR%d", pParam->base.reg_ctrl);
                 return 0;
 
             case OP_PARM_D: //debug register
-                disasmAddStringF1(pParam->szParam, "DR%d", reg);
                 pParam->flags |= USE_REG_DBG;
                 pParam->base.reg_dbg = reg;
@@ -679,5 +754,4 @@
             case OP_PARM_P: //MMX register
                 reg &= 7;   /* REX.R has no effect here */
-                disasmAddStringF1(pParam->szParam, "MM%d", reg);
                 pParam->flags |= USE_REG_MMX;
                 pParam->base.reg_mmx = reg;
@@ -692,5 +766,4 @@
             case OP_PARM_T: //test register
                 reg &= 7;   /* REX.R has no effect here */
-                disasmAddStringF1(pParam->szParam, "TR%d", reg);
                 pParam->flags |= USE_REG_TEST;
                 pParam->base.reg_test = reg;
@@ -704,5 +777,4 @@
 
             case OP_PARM_V: //XMM register
-                disasmAddStringF1(pParam->szParam, "XMM%d", reg);
                 pParam->flags |= USE_REG_XMM;
                 pParam->base.reg_xmm = reg;
@@ -724,9 +796,7 @@
         {
         case 0: //effective address
-            disasmGetPtrString(pCpu, pOp, pParam);
-            disasmAddChar(pParam->szParam, '[');
             if (rm == 4)
             {   /* SIB byte follows ModRM */
-                UseSIB(lpszCodeBlock, pOp, pParam, pCpu);
+                UseSIB(uCodePtr, pOp, pParam, pCpu);
             }
             else
@@ -738,5 +808,4 @@
                     pParam->flags |= USE_DISPLACEMENT32;
                     pParam->uDisp.i32 = pCpu->i32SibDisp;
-                    disasmPrintDisp32(pParam);
                 }
                 else
@@ -744,6 +813,4 @@
                     pParam->flags |= USE_RIPDISPLACEMENT32;
                     pParam->uDisp.i32 = pCpu->i32SibDisp;
-                    disasmAddString(pParam->szParam, "RIP+");
-                    disasmPrintDisp32(pParam);
                 }
             }
@@ -753,12 +820,9 @@
                 disasmModRMReg(pCpu, pOp, rm, pParam, 1);
             }
-            disasmAddChar(pParam->szParam, ']');
             break;
 
         case 1: //effective address + 8 bits displacement
-            disasmGetPtrString(pCpu, pOp, pParam);
-            disasmAddChar(pParam->szParam, '[');
             if (rm == 4) {//SIB byte follows ModRM
-                UseSIB(lpszCodeBlock, pOp, pParam, pCpu);
+                UseSIB(uCodePtr, pOp, pParam, pCpu);
             }
             else
@@ -769,19 +833,9 @@
             pParam->uDisp.i8 = pCpu->i32SibDisp;
             pParam->flags |= USE_DISPLACEMENT8;
-
-            if (pParam->uDisp.i8 != 0)
-            {
-                if (pParam->uDisp.i8 > 0)
-                    disasmAddChar(pParam->szParam, '+');
-                disasmPrintDisp8(pParam);
-            }
-            disasmAddChar(pParam->szParam, ']');
             break;
 
         case 2: //effective address + 32 bits displacement
-            disasmGetPtrString(pCpu, pOp, pParam);
-            disasmAddChar(pParam->szParam, '[');
             if (rm == 4) {//SIB byte follows ModRM
-                UseSIB(lpszCodeBlock, pOp, pParam, pCpu);
+                UseSIB(uCodePtr, pOp, pParam, pCpu);
             }
             else
@@ -792,11 +846,4 @@
             pParam->uDisp.i32 = pCpu->i32SibDisp;
             pParam->flags |= USE_DISPLACEMENT32;
-
-            if (pParam->uDisp.i32 != 0)
-            {
-                disasmAddChar(pParam->szParam, '+');
-                disasmPrintDisp32(pParam);
-            }
-            disasmAddChar(pParam->szParam, ']');
             break;
 
@@ -811,11 +858,8 @@
         {
         case 0: //effective address
-            disasmGetPtrString(pCpu, pOp, pParam);
-            disasmAddChar(pParam->szParam, '[');
             if (rm == 6)
             {//16 bits displacement
                 pParam->uDisp.i16 = pCpu->i32SibDisp;
                 pParam->flags |= USE_DISPLACEMENT16;
-                disasmPrintDisp16(pParam);
             }
             else
@@ -824,36 +868,16 @@
                 disasmModRMReg16(pCpu, pOp, rm, pParam);
             }
-            disasmAddChar(pParam->szParam, ']');
             break;
 
         case 1: //effective address + 8 bits displacement
-            disasmGetPtrString(pCpu, pOp, pParam);
-            disasmAddChar(pParam->szParam, '[');
             disasmModRMReg16(pCpu, pOp, rm, pParam);
             pParam->uDisp.i8 = pCpu->i32SibDisp;
             pParam->flags |= USE_BASE | USE_DISPLACEMENT8;
-
-            if (pParam->uDisp.i8 != 0)
-            {
-                if (pParam->uDisp.i8 > 0)
-                    disasmAddChar(pParam->szParam, '+');
-                disasmPrintDisp8(pParam);
-            }
-            disasmAddChar(pParam->szParam, ']');
             break;
 
         case 2: //effective address + 16 bits displacement
-            disasmGetPtrString(pCpu, pOp, pParam);
-            disasmAddChar(pParam->szParam, '[');
             disasmModRMReg16(pCpu, pOp, rm, pParam);
             pParam->uDisp.i16 = pCpu->i32SibDisp;
             pParam->flags |= USE_BASE | USE_DISPLACEMENT16;
-
-            if (pParam->uDisp.i16 != 0)
-            {
-                disasmAddChar(pParam->szParam, '+');
-                disasmPrintDisp16(pParam);
-            }
-            disasmAddChar(pParam->szParam, ']');
             break;
 
@@ -868,5 +892,5 @@
 // Query the size of the ModRM parameters and fetch the immediate data (if any)
 //*****************************************************************************
-unsigned QueryModRM(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
+unsigned QueryModRM(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
 {
     unsigned sibinc;
@@ -890,6 +914,6 @@
         if (mod != 3 && rm == 4)
         {   /* SIB byte follows ModRM */
-            *pSibInc = ParseSIB(lpszCodeBlock, pOp, pParam, pCpu);
-            lpszCodeBlock += *pSibInc;
+            *pSibInc = ParseSIB(uCodePtr, pOp, pParam, pCpu);
+            uCodePtr += *pSibInc;
             size += *pSibInc;
         }
@@ -899,5 +923,5 @@
         case 0: /* Effective address */
             if (rm == 5) {  /* 32 bits displacement */
-                pCpu->i32SibDisp = DISReadDWord(pCpu, lpszCodeBlock);
+                pCpu->i32SibDisp = DISReadDWord(pCpu, uCodePtr);
                 size += sizeof(int32_t);
             }
@@ -906,10 +930,10 @@
 
         case 1: /* Effective address + 8 bits displacement */
-            pCpu->i32SibDisp = (int8_t)DISReadByte(pCpu, lpszCodeBlock);
+            pCpu->i32SibDisp = (int8_t)DISReadByte(pCpu, uCodePtr);
             size += sizeof(char);
             break;
 
         case 2: /* Effective address + 32 bits displacement */
-            pCpu->i32SibDisp = DISReadDWord(pCpu, lpszCodeBlock);
+            pCpu->i32SibDisp = DISReadDWord(pCpu, uCodePtr);
             size += sizeof(int32_t);
             break;
@@ -926,5 +950,5 @@
         case 0: /* Effective address */
             if (rm == 6) {
-                pCpu->i32SibDisp = DISReadWord(pCpu, lpszCodeBlock);
+                pCpu->i32SibDisp = DISReadWord(pCpu, uCodePtr);
                 size += sizeof(uint16_t);
             }
@@ -933,10 +957,10 @@
 
         case 1: /* Effective address + 8 bits displacement */
-            pCpu->i32SibDisp = (int8_t)DISReadByte(pCpu, lpszCodeBlock);
+            pCpu->i32SibDisp = (int8_t)DISReadByte(pCpu, uCodePtr);
             size += sizeof(char);
             break;
 
         case 2: /* Effective address + 32 bits displacement */
-            pCpu->i32SibDisp = (int16_t)DISReadWord(pCpu, lpszCodeBlock);
+            pCpu->i32SibDisp = (int16_t)DISReadWord(pCpu, uCodePtr);
             size += sizeof(uint16_t);
             break;
@@ -951,5 +975,5 @@
 // Query the size of the ModRM parameters and fetch the immediate data (if any)
 //*****************************************************************************
-unsigned QueryModRM_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
+unsigned QueryModRM_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
 {
     unsigned sibinc;
@@ -972,6 +996,6 @@
         if (mod != 3 && rm == 4)
         {   /* SIB byte follows ModRM */
-            *pSibInc = ParseSIB_SizeOnly(lpszCodeBlock, pOp, pParam, pCpu);
-            lpszCodeBlock += *pSibInc;
+            *pSibInc = ParseSIB_SizeOnly(uCodePtr, pOp, pParam, pCpu);
+            uCodePtr += *pSibInc;
             size += *pSibInc;
         }
@@ -1026,7 +1050,7 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseIllegal(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+unsigned ParseIllegal(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     AssertFailed();
     return 0;
@@ -1034,11 +1058,11 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseModRM(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseModRM(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);   //ModRM byte
     unsigned sibinc, ModRM;
 
-    ModRM = DISReadByte(pCpu, lpszCodeBlock);
-    lpszCodeBlock += sizeof(uint8_t);
+    ModRM = DISReadByte(pCpu, uCodePtr);
+    uCodePtr += sizeof(uint8_t);
 
     pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM);
@@ -1072,19 +1096,19 @@
         }
     }
-    size += QueryModRM(lpszCodeBlock, pOp, pParam, pCpu, &sibinc);
-    lpszCodeBlock += sibinc;
-
-    UseModRM(lpszCodeBlock, pOp, pParam, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseModRM_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += QueryModRM(uCodePtr, pOp, pParam, pCpu, &sibinc);
+    uCodePtr += sibinc;
+
+    UseModRM(uCodePtr, pOp, pParam, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseModRM_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);   //ModRM byte
     unsigned sibinc, ModRM;
 
-    ModRM = DISReadByte(pCpu, lpszCodeBlock);
-    lpszCodeBlock += sizeof(uint8_t);
+    ModRM = DISReadByte(pCpu, uCodePtr);
+    uCodePtr += sizeof(uint8_t);
 
     pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM);
@@ -1119,6 +1143,6 @@
     }
 
-    size += QueryModRM_SizeOnly(lpszCodeBlock, pOp, pParam, pCpu, &sibinc);
-    lpszCodeBlock += sibinc;
+    size += QueryModRM_SizeOnly(uCodePtr, pOp, pParam, pCpu, &sibinc);
+    uCodePtr += sibinc;
 
     /* UseModRM is not necessary here; we're only interested in the opcode size */
@@ -1127,56 +1151,51 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseModFence(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseModFence(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     ////AssertMsgFailed(("??\n"));
     //nothing to do apparently
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return 0;
 }
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmByte(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmByte(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->parval = DISReadByte(pCpu, lpszCodeBlock);
+    pParam->parval = DISReadByte(pCpu, uCodePtr);
     pParam->flags |= USE_IMMEDIATE8;
     pParam->cb     = sizeof(uint8_t);
-
-    disasmAddStringF1(pParam->szParam, "0%02Xh", (uint32_t)pParam->parval);
     return sizeof(uint8_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmByte_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+unsigned ParseImmByte_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(uint8_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmByteSX(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmByteSX(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
     if (pCpu->opmode == CPUMODE_32BIT)
     {
-        pParam->parval = (uint32_t)(int8_t)DISReadByte(pCpu, lpszCodeBlock);
+        pParam->parval = (uint32_t)(int8_t)DISReadByte(pCpu, uCodePtr);
         pParam->flags |= USE_IMMEDIATE32_SX8;
         pParam->cb     = sizeof(uint32_t);
-        disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
     }
     else
     if (pCpu->opmode == CPUMODE_64BIT)
     {
-        pParam->parval = (uint64_t)(int8_t)DISReadByte(pCpu, lpszCodeBlock);
+        pParam->parval = (uint64_t)(int8_t)DISReadByte(pCpu, uCodePtr);
         pParam->flags |= USE_IMMEDIATE64_SX8;
         pParam->cb     = sizeof(uint64_t);
-        disasmAddStringF1(pParam->szParam, "0%016RX64h", pParam->parval);
-    }
-    else
-    {
-        pParam->parval = (uint16_t)(int8_t)DISReadByte(pCpu, lpszCodeBlock);
+    }
+    else
+    {
+        pParam->parval = (uint16_t)(int8_t)DISReadByte(pCpu, uCodePtr);
         pParam->flags |= USE_IMMEDIATE16_SX8;
         pParam->cb     = sizeof(uint16_t);
-        disasmAddStringF1(pParam->szParam, "0%04Xh", (uint16_t)pParam->parval);
     }
     return sizeof(uint8_t);
@@ -1184,106 +1203,91 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmByteSX_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+unsigned ParseImmByteSX_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(uint8_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmUshort(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmUshort(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
+    pParam->parval = DISReadWord(pCpu, uCodePtr);
     pParam->flags |= USE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
-
-    disasmAddStringF1(pParam->szParam, "0%04Xh", (uint16_t)pParam->parval);
     return sizeof(uint16_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmUshort_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+unsigned ParseImmUshort_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(uint16_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmUlong(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmUlong(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
+    pParam->parval = DISReadDWord(pCpu, uCodePtr);
     pParam->flags |= USE_IMMEDIATE32;
     pParam->cb     = sizeof(uint32_t);
-
-    disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
     return sizeof(uint32_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmUlong_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+unsigned ParseImmUlong_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(uint32_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmQword(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmQword(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->parval = DISReadQWord(pCpu, lpszCodeBlock);
+    pParam->parval = DISReadQWord(pCpu, uCodePtr);
     pParam->flags |= USE_IMMEDIATE64;
     pParam->cb     = sizeof(uint64_t);
-
-    disasmAddStringF2(pParam->szParam, "0%08X%08Xh",
-                      (uint32_t)pParam->parval, (uint32_t)(pParam->parval >> 32));
     return sizeof(uint64_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmQword_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+unsigned ParseImmQword_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(uint64_t);
 }
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmV(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmV(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
     if (pCpu->opmode == CPUMODE_32BIT)
     {
-        pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
+        pParam->parval = DISReadDWord(pCpu, uCodePtr);
         pParam->flags |= USE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
-
-        disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
         return sizeof(uint32_t);
     }
-    else
+
     if (pCpu->opmode == CPUMODE_64BIT)
     {
-        pParam->parval = DISReadQWord(pCpu, lpszCodeBlock);
+        pParam->parval = DISReadQWord(pCpu, uCodePtr);
         pParam->flags |= USE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
-
-        disasmAddStringF1(pParam->szParam, "0%RX64h", pParam->parval);
         return sizeof(uint64_t);
     }
-    else
-    {
-        pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
-        pParam->flags |= USE_IMMEDIATE16;
-        pParam->cb     = sizeof(uint16_t);
-
-        disasmAddStringF1(pParam->szParam, "0%04Xh", (uint32_t)pParam->parval);
-        return sizeof(uint16_t);
-    }
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseImmV_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam);
+
+    pParam->parval = DISReadWord(pCpu, uCodePtr);
+    pParam->flags |= USE_IMMEDIATE16;
+    pParam->cb     = sizeof(uint16_t);
+    return sizeof(uint16_t);
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseImmV_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
     if (pCpu->opmode == CPUMODE_32BIT)
         return sizeof(uint32_t);
@@ -1294,5 +1298,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmZ(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmZ(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
@@ -1300,36 +1304,30 @@
     if (pCpu->opmode == CPUMODE_16BIT)
     {
-        pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
+        pParam->parval = DISReadWord(pCpu, uCodePtr);
         pParam->flags |= USE_IMMEDIATE16;
         pParam->cb     = sizeof(uint16_t);
-
-        disasmAddStringF1(pParam->szParam, "0%04Xh", (uint32_t)pParam->parval);
         return sizeof(uint16_t);
     }
-    else
-    {
-        /* 64 bits op mode means *sign* extend to 64 bits. */
-        if (pCpu->opmode == CPUMODE_64BIT)
-        {
-            pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, lpszCodeBlock);
-            pParam->flags |= USE_IMMEDIATE64;
-            pParam->cb     = sizeof(uint64_t);
-            disasmAddStringF1(pParam->szParam, "0%RX64h", pParam->parval);
-        }
-        else
-        {
-            pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
-            pParam->flags |= USE_IMMEDIATE32;
-            pParam->cb     = sizeof(uint32_t);
-            disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
-        }
-        return sizeof(uint32_t);
-    }
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseImmZ_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam);
+
+    /* 64 bits op mode means *sign* extend to 64 bits. */
+    if (pCpu->opmode == CPUMODE_64BIT)
+    {
+        pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, uCodePtr);
+        pParam->flags |= USE_IMMEDIATE64;
+        pParam->cb     = sizeof(uint64_t);
+    }
+    else
+    {
+        pParam->parval = DISReadDWord(pCpu, uCodePtr);
+        pParam->flags |= USE_IMMEDIATE32;
+        pParam->cb     = sizeof(uint32_t);
+    }
+    return sizeof(uint32_t);
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseImmZ_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
     /* Word for 16-bit operand-size or doubleword for 32 or 64-bit operand-size. */
     if (pCpu->opmode == CPUMODE_16BIT)
@@ -1341,12 +1339,10 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-unsigned ParseImmBRel(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmBRel(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->parval = DISReadByte(pCpu, lpszCodeBlock);
+    pParam->parval = DISReadByte(pCpu, uCodePtr);
     pParam->flags |= USE_IMMEDIATE8_REL;
     pParam->cb     = sizeof(uint8_t);
-
-    disasmAddStringF1(pParam->szParam, " (0%02Xh)", (uint32_t)pParam->parval);
     return sizeof(char);
 }
@@ -1354,7 +1350,7 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-unsigned ParseImmBRel_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
+unsigned ParseImmBRel_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
     return sizeof(char);
 }
@@ -1362,43 +1358,35 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-unsigned ParseImmVRel(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmVRel(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
     if (pCpu->opmode == CPUMODE_32BIT)
     {
-        pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
+        pParam->parval = DISReadDWord(pCpu, uCodePtr);
         pParam->flags |= USE_IMMEDIATE32_REL;
         pParam->cb     = sizeof(int32_t);
-
-        disasmAddStringF1(pParam->szParam, " (0%08Xh)", (uint32_t)pParam->parval);
         return sizeof(int32_t);
     }
-    else
+
     if (pCpu->opmode == CPUMODE_64BIT)
     {
         /* 32 bits relative immediate sign extended to 64 bits. */
-        pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, lpszCodeBlock);
+        pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, uCodePtr);
         pParam->flags |= USE_IMMEDIATE64_REL;
         pParam->cb     = sizeof(int64_t);
-
-        disasmAddStringF1(pParam->szParam, " (0%RX64h)", pParam->parval);
         return sizeof(int32_t);
     }
-    else
-    {
-        pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
-        pParam->flags |= USE_IMMEDIATE16_REL;
-        pParam->cb     = sizeof(int16_t);
-
-        disasmAddStringF1(pParam->szParam, " (0%04Xh)", (uint32_t)pParam->parval);
-        return sizeof(int16_t);
-    }
+
+    pParam->parval = DISReadWord(pCpu, uCodePtr);
+    pParam->flags |= USE_IMMEDIATE16_REL;
+    pParam->cb     = sizeof(int16_t);
+    return sizeof(int16_t);
 }
 //*****************************************************************************
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-unsigned ParseImmVRel_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp); NOREF(pParam);
+unsigned ParseImmVRel_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
     if (pCpu->opmode == CPUMODE_16BIT)
         return sizeof(int16_t);
@@ -1408,80 +1396,69 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmAddr(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    disasmGetPtrString(pCpu, pOp, pParam);
+unsigned ParseImmAddr(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
     if (pCpu->addrmode == CPUMODE_32BIT)
     {
         if (OP_PARM_VSUBTYPE(pParam->param) == OP_PARM_p)
-        {// far 16:32 pointer
-            pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
-            *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, lpszCodeBlock+sizeof(uint32_t));
+        {
+            /* far 16:32 pointer */
+            pParam->parval = DISReadDWord(pCpu, uCodePtr);
+            *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, uCodePtr+sizeof(uint32_t));
             pParam->flags  |= USE_IMMEDIATE_ADDR_16_32;
             pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
-
-            disasmAddStringF2(pParam->szParam, "0%04X:0%08Xh", (uint32_t)(pParam->parval>>32), (uint32_t)pParam->parval);
             return sizeof(uint32_t) + sizeof(uint16_t);
         }
-        else
-        {// near 32 bits pointer
-            /*
-             * Note: used only in "mov al|ax|eax, [Addr]" and "mov [Addr], al|ax|eax"
-             * so we treat it like displacement.
-             */
-            pParam->uDisp.i32 = DISReadDWord(pCpu, lpszCodeBlock);
-            pParam->flags |= USE_DISPLACEMENT32;
-            pParam->cb     = sizeof(uint32_t);
-
-            disasmAddStringF1(pParam->szParam, "[0%08Xh]", pParam->uDisp.i32);
-            return sizeof(uint32_t);
-        }
-    }
-    else
-    if (pCpu->addrmode == CPUMODE_64BIT)
-    {
-        Assert(OP_PARM_VSUBTYPE(pParam->param) != OP_PARM_p);
-        /* near 64 bits pointer */
+
         /*
+         * near 32 bits pointer
+         *
          * Note: used only in "mov al|ax|eax, [Addr]" and "mov [Addr], al|ax|eax"
          * so we treat it like displacement.
          */
-        pParam->uDisp.i64 = DISReadQWord(pCpu, lpszCodeBlock);
+        pParam->uDisp.i32 = DISReadDWord(pCpu, uCodePtr);
+        pParam->flags |= USE_DISPLACEMENT32;
+        pParam->cb     = sizeof(uint32_t);
+        return sizeof(uint32_t);
+    }
+
+    if (pCpu->addrmode == CPUMODE_64BIT)
+    {
+        Assert(OP_PARM_VSUBTYPE(pParam->param) != OP_PARM_p);
+        /*
+         * near 64 bits pointer
+         *
+         * Note: used only in "mov al|ax|eax, [Addr]" and "mov [Addr], al|ax|eax"
+         * so we treat it like displacement.
+         */
+        pParam->uDisp.i64 = DISReadQWord(pCpu, uCodePtr);
         pParam->flags |= USE_DISPLACEMENT64;
         pParam->cb     = sizeof(uint64_t);
-
-        disasmAddStringF2(pParam->szParam, "[0%08X%08Xh]", (uint32_t)(pParam->uDisp.i64 >> 32), (uint32_t)pParam->uDisp.i64);
         return sizeof(uint64_t);
     }
-    else
-    {
-        if (OP_PARM_VSUBTYPE(pParam->param) == OP_PARM_p)
-        {// far 16:16 pointer
-            pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
-            pParam->flags |= USE_IMMEDIATE_ADDR_16_16;
-            pParam->cb     = 2*sizeof(uint16_t);
-
-            disasmAddStringF2(pParam->szParam, "0%04X:0%04Xh", (uint32_t)(pParam->parval>>16), (uint16_t)pParam->parval );
-            return sizeof(uint32_t);
-        }
-        else
-        {// near 16 bits pointer
-            /*
-             * Note: used only in "mov al|ax|eax, [Addr]" and "mov [Addr], al|ax|eax"
-             * so we treat it like displacement.
-             */
-            pParam->uDisp.i16 = DISReadWord(pCpu, lpszCodeBlock);
-            pParam->flags |= USE_DISPLACEMENT16;
-            pParam->cb     = sizeof(uint16_t);
-
-            disasmAddStringF1(pParam->szParam, "[0%04Xh]", (uint32_t)pParam->uDisp.i16);
-            return sizeof(uint16_t);
-        }
-    }
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseImmAddr_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp);
+    if (OP_PARM_VSUBTYPE(pParam->param) == OP_PARM_p)
+    {
+        /* far 16:16 pointer */
+        pParam->parval = DISReadDWord(pCpu, uCodePtr);
+        pParam->flags |= USE_IMMEDIATE_ADDR_16_16;
+        pParam->cb     = 2*sizeof(uint16_t);
+        return sizeof(uint32_t);
+    }
+
+    /*
+     * near 16 bits pointer
+     *
+     * Note: used only in "mov al|ax|eax, [Addr]" and "mov [Addr], al|ax|eax"
+     * so we treat it like displacement.
+     */
+    pParam->uDisp.i16 = DISReadWord(pCpu, uCodePtr);
+    pParam->flags |= USE_DISPLACEMENT16;
+    pParam->cb     = sizeof(uint16_t);
+    return sizeof(uint16_t);
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseImmAddr_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp);
     if (pCpu->addrmode == CPUMODE_32BIT)
     {
@@ -1514,7 +1491,6 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmAddrF(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    disasmGetPtrString(pCpu, pOp, pParam);
+unsigned ParseImmAddrF(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
     // immediate far pointers - only 16:16 or 16:32; determined by operand, *not* address size!
     Assert(pCpu->opmode == CPUMODE_16BIT || pCpu->opmode == CPUMODE_32BIT);
@@ -1523,28 +1499,22 @@
     {
         // far 16:32 pointer
-        pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
-        *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, lpszCodeBlock+sizeof(uint32_t));
+        pParam->parval = DISReadDWord(pCpu, uCodePtr);
+        *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, uCodePtr+sizeof(uint32_t));
         pParam->flags  |= USE_IMMEDIATE_ADDR_16_32;
         pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
-
-        disasmAddStringF2(pParam->szParam, "0%04X:0%08Xh", (uint32_t)(pParam->parval>>32), (uint32_t)pParam->parval);
         return sizeof(uint32_t) + sizeof(uint16_t);
     }
-    else
-    {
-        // far 16:16 pointer
-        pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
-        pParam->flags |= USE_IMMEDIATE_ADDR_16_16;
-        pParam->cb     = 2*sizeof(uint16_t);
-
-        disasmAddStringF2(pParam->szParam, "0%04X:0%04Xh", (uint32_t)(pParam->parval>>16), (uint16_t)pParam->parval );
-        return sizeof(uint32_t);
-    }
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseImmAddrF_SizeOnly(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock); NOREF(pOp);
+
+    // far 16:16 pointer
+    pParam->parval = DISReadDWord(pCpu, uCodePtr);
+    pParam->flags |= USE_IMMEDIATE_ADDR_16_16;
+    pParam->cb     = 2*sizeof(uint16_t);
+    return sizeof(uint32_t);
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseImmAddrF_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp);
     // immediate far pointers - only 16:16 or 16:32
     Assert(pCpu->opmode == CPUMODE_16BIT || pCpu->opmode == CPUMODE_32BIT);
@@ -1563,7 +1533,7 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseFixedReg(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(lpszCodeBlock);
+unsigned ParseFixedReg(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr);
 
     /*
@@ -1664,9 +1634,7 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseXv(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(pu8CodeBlock);
-    disasmGetPtrString(pCpu, pOp, pParam);
-    disasmAddString(pParam->szParam, (pCpu->addrmode == CPUMODE_32BIT) ? "DS:ESI" : "DS:SI");
+unsigned ParseXv(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr);
 
     pParam->flags |= USE_POINTER_DS_BASED;
@@ -1691,8 +1659,7 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseXb(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(pu8CodeBlock); NOREF(pOp);
-    disasmAddString(pParam->szParam, (pCpu->addrmode == CPUMODE_32BIT) ? "DS:ESI" : "DS:SI");
+unsigned ParseXb(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp);
 
     pParam->flags |= USE_POINTER_DS_BASED;
@@ -1717,9 +1684,7 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseYv(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(pu8CodeBlock);
-    disasmGetPtrString(pCpu, pOp, pParam);
-    disasmAddString(pParam->szParam, (pCpu->addrmode == CPUMODE_32BIT) ? "ES:EDI" : "ES:DI");
+unsigned ParseYv(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr);
 
     pParam->flags |= USE_POINTER_ES_BASED;
@@ -1744,8 +1709,7 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseYb(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    NOREF(pu8CodeBlock); NOREF(pOp);
-    disasmAddString(pParam->szParam, (pCpu->addrmode == CPUMODE_32BIT) ? "ES:EDI" : "ES:DI");
+unsigned ParseYb(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    NOREF(uCodePtr); NOREF(pOp);
 
     pParam->flags |= USE_POINTER_ES_BASED;
@@ -1770,5 +1734,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseTwoByteEsc(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseTwoByteEsc(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     const OPCODE *pOpcode;
@@ -1777,5 +1741,5 @@
 
     /* 2nd byte */
-    pCpu->opcode = DISReadByte(pCpu, lpszCodeBlock);
+    pCpu->opcode = DISReadByte(pCpu, uCodePtr);
 
     /* default to the non-prefixed table. */
@@ -1824,10 +1788,10 @@
     }
 
-    size += ParseInstruction(lpszCodeBlock+size, pOpcode, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseThreeByteEsc4(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr+size, pOpcode, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseThreeByteEsc4(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     const OPCODE *pOpcode;
@@ -1836,5 +1800,5 @@
 
     /* 3rd byte */
-    pCpu->opcode = DISReadByte(pCpu, lpszCodeBlock);
+    pCpu->opcode = DISReadByte(pCpu, uCodePtr);
 
     /* default to the non-prefixed table. */
@@ -1885,10 +1849,10 @@
     }
 
-    size += ParseInstruction(lpszCodeBlock+size, pOpcode, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseThreeByteEsc5(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr+size, pOpcode, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseThreeByteEsc5(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     const OPCODE *pOpcode;
@@ -1897,5 +1861,5 @@
 
     /* 3rd byte */
-    pCpu->opcode = DISReadByte(pCpu, lpszCodeBlock);
+    pCpu->opcode = DISReadByte(pCpu, uCodePtr);
 
     /** @todo Should we take the first or last prefix byte in case of multiple prefix bytes??? */
@@ -1920,10 +1884,10 @@
         pOpcode = &g_InvalidOpcode[0];
 
-    size += ParseInstruction(lpszCodeBlock+size, pOpcode, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseNopPause(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr+size, pOpcode, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseNopPause(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0;
@@ -1938,10 +1902,10 @@
         pOp = &g_aMapX86_NopPause[0]; /* NOP */
 
-    size += ParseInstruction(pu8CodeBlock, pOp, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseImmGrpl(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseImmGrpl(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     int idx = (pCpu->opcode - 0x80) * 8;
@@ -1949,5 +1913,5 @@
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -1957,11 +1921,11 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseShiftGrp2(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseShiftGrp2(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     int idx;
@@ -1988,5 +1952,5 @@
     }
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -1997,11 +1961,11 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp3(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp3(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     int idx = (pCpu->opcode - 0xF6) * 8;
@@ -2009,5 +1973,5 @@
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -2018,16 +1982,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp4(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp4(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -2038,16 +2002,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp5(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp5(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -2058,5 +2022,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
 
     return size;
@@ -2068,5 +2032,5 @@
 //
 //*****************************************************************************
-unsigned Parse3DNow(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned Parse3DNow(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrmsize;
@@ -2077,12 +2041,12 @@
 #endif
 
-    unsigned ModRM = DISReadByte(pCpu, lpszCodeBlock);
+    unsigned ModRM = DISReadByte(pCpu, uCodePtr);
     pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM);
     pCpu->ModRM.Bits.Mod = MODRM_MOD(ModRM);
     pCpu->ModRM.Bits.Reg = MODRM_REG(ModRM);
 
-    modrmsize = QueryModRM(lpszCodeBlock+sizeof(uint8_t), pOp, pParam, pCpu);
-
-    uint8_t opcode = DISReadByte(pCpu, lpszCodeBlock+sizeof(uint8_t)+modrmsize);
+    modrmsize = QueryModRM(uCodePtr+sizeof(uint8_t), pOp, pParam, pCpu);
+
+    uint8_t opcode = DISReadByte(pCpu, uCodePtr+sizeof(uint8_t)+modrmsize);
 
     pOp = (PCOPCODE)&g_aTwoByteMapX86_3DNow[opcode];
@@ -2097,5 +2061,5 @@
     }
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
     size += sizeof(uint8_t);   //imm8_opcode uint8_t
 
@@ -2104,10 +2068,10 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseGrp6(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseGrp6(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -2118,16 +2082,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp7(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp7(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg, rm, mod;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     mod   = MODRM_MOD(modrm);
     reg   = MODRM_REG(modrm);
@@ -2146,16 +2110,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp8(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp8(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -2166,16 +2130,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp9(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp9(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -2186,16 +2150,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp10(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp10(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -2206,16 +2170,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp12(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp12(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -2229,15 +2193,15 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp13(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp13(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
     if (pCpu->prefix & PREFIX_OPSIZE)
@@ -2250,16 +2214,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp14(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp14(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
     if (pCpu->prefix & PREFIX_OPSIZE)
@@ -2272,16 +2236,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp15(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp15(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg, mod, rm;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     mod   = MODRM_MOD(modrm);
     reg   = MODRM_REG(modrm);
@@ -2297,15 +2261,15 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp16(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp16(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, lpszCodeBlock);
+    modrm = DISReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -2316,5 +2280,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(lpszCodeBlock, pOp, pCpu);
+    size += ParseInstruction(uCodePtr, pOp, pCpu);
     return size;
 }
@@ -2331,5 +2295,5 @@
 static const int   IndexModRMReg16[4] = { USE_REG_SI, USE_REG_DI, USE_REG_SI, USE_REG_DI};
 //*****************************************************************************
-void disasmModRMReg(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam, int fRegAddr)
+static void disasmModRMReg(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam, int fRegAddr)
 {
     int subtype, type, mod;
@@ -2375,5 +2339,4 @@
             idx += (USE_REG_SPL - USE_REG_AH);
         }
-        disasmAddString(pParam->szParam, szModRMReg8[idx]);
 
         pParam->flags |= USE_REG_GEN8;
@@ -2382,5 +2345,4 @@
 
     case OP_PARM_w:
-        disasmAddString(pParam->szParam, szModRMReg16[idx]);
         Assert(idx < (pCpu->prefix & PREFIX_REX) ? 16 : 8);
 
@@ -2390,5 +2352,4 @@
 
     case OP_PARM_d:
-        disasmAddString(pParam->szParam, szModRMReg32[idx]);
         Assert(idx < (pCpu->prefix & PREFIX_REX) ? 16 : 8);
 
@@ -2398,5 +2359,4 @@
 
     case OP_PARM_q:
-        disasmAddString(pParam->szParam, szModRMReg64[idx]);
         pParam->flags |= USE_REG_GEN64;
         pParam->base.reg_gen = idx;
@@ -2411,8 +2371,7 @@
 //*****************************************************************************
 //*****************************************************************************
-void disasmModRMReg16(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam)
+static void disasmModRMReg16(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam)
 {
     NOREF(pCpu); NOREF(pOp);
-    disasmAddString(pParam->szParam, szModRMReg1616[idx]);
     pParam->flags |= USE_REG_GEN16;
     pParam->base.reg_gen = BaseModRMReg16[idx];
@@ -2425,5 +2384,5 @@
 //*****************************************************************************
 //*****************************************************************************
-void disasmModRMSReg(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam)
+static void disasmModRMSReg(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam)
 {
     NOREF(pOp);
@@ -2435,100 +2394,6 @@
     }
 
-    disasmAddString(pParam->szParam, szModRMSegReg[idx]);
     pParam->flags |= USE_REG_SEG;
     pParam->base.reg_seg = (DIS_SELREG)idx;
-}
-//*****************************************************************************
-//*****************************************************************************
-void disasmPrintAbs32(POP_PARAMETER pParam)
-{
-    disasmAddStringF1(pParam->szParam, "%08Xh", pParam->uDisp.i32); NOREF(pParam);
-}
-//*****************************************************************************
-//*****************************************************************************
-void disasmPrintDisp32(POP_PARAMETER pParam)
-{
-    disasmAddStringF1(pParam->szParam, "%08Xh", pParam->uDisp.i32); NOREF(pParam);
-}
-//*****************************************************************************
-//*****************************************************************************
-void disasmPrintDisp64(POP_PARAMETER pParam)
-{
-    disasmAddStringF1(pParam->szParam, "%16RX64h", pParam->uDisp.i64); NOREF(pParam);
-}
-//*****************************************************************************
-//*****************************************************************************
-void disasmPrintDisp8(POP_PARAMETER pParam)
-{
-    disasmAddStringF1(pParam->szParam, "%d", pParam->uDisp.i8); NOREF(pParam);
-}
-//*****************************************************************************
-//*****************************************************************************
-void disasmPrintDisp16(POP_PARAMETER pParam)
-{
-    disasmAddStringF1(pParam->szParam, "%04Xh", pParam->uDisp.i16); NOREF(pParam);
-}
-//*****************************************************************************
-//*****************************************************************************
-void disasmGetPtrString(PDISCPUSTATE pCpu, PCOPCODE pOp, POP_PARAMETER pParam)
-{
-    int subtype = OP_PARM_VSUBTYPE(pParam->param);
-    NOREF(pOp);
-
-    if (subtype == OP_PARM_v)
-    {
-        switch(pCpu->opmode)
-        {
-        case CPUMODE_32BIT:
-            subtype = OP_PARM_d;
-            break;
-        case CPUMODE_64BIT:
-            subtype = OP_PARM_q;
-            break;
-        case CPUMODE_16BIT:
-            subtype = OP_PARM_w;
-            break;
-        default:
-            /* make gcc happy */
-            break;
-        }
-    }
-
-    switch (subtype)
-    {
-    case OP_PARM_a: //two words or dwords depending on operand size (bound only)
-        break;
-
-    case OP_PARM_b:
-        disasmAddString(pParam->szParam, "byte ptr ");
-        break;
-
-    case OP_PARM_w:
-        disasmAddString(pParam->szParam, "word ptr ");
-        break;
-
-    case OP_PARM_d:
-        disasmAddString(pParam->szParam, "dword ptr ");
-        break;
-
-    case OP_PARM_q:
-    case OP_PARM_dq:
-        disasmAddString(pParam->szParam, "qword ptr ");
-        break;
-
-    case OP_PARM_p:
-        disasmAddString(pParam->szParam, "far ptr ");
-        break;
-
-    case OP_PARM_s:
-        break; //??
-
-    case OP_PARM_z:
-        break;
-    default:
-        break; //no pointer type specified/necessary
-    }
-    if (pCpu->prefix & PREFIX_SEG)
-        disasmAddStringF1(pParam->szParam, "%s:", szModRMSegReg[pCpu->enmPrefixSeg]);
 }
 
@@ -2722,36 +2587,4 @@
     return uTemp.u;
 }
-
-#if !defined(DIS_CORE_ONLY) && defined(LOG_ENABLED)
-//*****************************************************************************
-//*****************************************************************************
-void disasmAddString(char *psz, const char *pszAdd)
-{
-    strcat(psz, pszAdd);
-}
-//*****************************************************************************
-//*****************************************************************************
-void disasmAddStringF(char *psz, const char *pszFormat, ...)
-{
-    va_list args;
-    va_start(args, pszFormat);
-    size_t  cchCur = strlen(psz);
-    Assert(cchCur < RT_SIZEOFMEMB(OP_PARAMETER, szParam));
-    RTStrPrintfV(psz + cchCur, RT_SIZEOFMEMB(OP_PARAMETER, szParam) - cchCur,
-                 pszFormat, args);
-    va_end(args);
-}
-
-//*****************************************************************************
-//*****************************************************************************
-void disasmAddChar(char *psz, char ch)
-{
-    char sz[2];
-
-    sz[0] = ch;
-    sz[1] = '\0';
-    strcat(psz, sz);
-}
-#endif /* !DIS_CORE_ONLY */
 
 
Index: /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp	(revision 41667)
+++ /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp	(revision 41668)
@@ -348,8 +348,8 @@
     {
 #if HC_ARCH_BITS == 64 || GC_ARCH_BITS == 64
-        if (pCpu->opaddr >= _4G)
-            PUT_NUM(9, "%08x`", (uint32_t)(pCpu->opaddr >> 32));
+        if (pCpu->uInstrAddr >= _4G)
+            PUT_NUM(9, "%08x`", (uint32_t)(pCpu->uInstrAddr >> 32));
 #endif
-        PUT_NUM(8, "%08x", (uint32_t)pCpu->opaddr);
+        PUT_NUM(8, "%08x", (uint32_t)pCpu->uInstrAddr);
         PUT_C(' ');
     }
@@ -896,5 +896,5 @@
                             PUT_SZ(" (");
 
-                        RTUINTPTR uTrgAddr = pCpu->opaddr + pCpu->opsize + offDisplacement;
+                        RTUINTPTR uTrgAddr = pCpu->uInstrAddr + pCpu->opsize + offDisplacement;
                         if (pCpu->mode == CPUMODE_16BIT)
                             PUT_NUM_16(uTrgAddr);
@@ -1132,8 +1132,8 @@
             PUT_C(' ');
 #if HC_ARCH_BITS == 64 || GC_ARCH_BITS == 64
-            if (pCpu->opaddr >= _4G)
-                PUT_NUM(9, "%08x`", (uint32_t)(pCpu->opaddr >> 32));
+            if (pCpu->uInstrAddr >= _4G)
+                PUT_NUM(9, "%08x`", (uint32_t)(pCpu->uInstrAddr >> 32));
 #endif
-            PUT_NUM(8, "%08x", (uint32_t)pCpu->opaddr);
+            PUT_NUM(8, "%08x", (uint32_t)pCpu->uInstrAddr);
         }
 
Index: /trunk/src/VBox/Disassembler/DisasmInternal.h
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmInternal.h	(revision 41667)
+++ /trunk/src/VBox/Disassembler/DisasmInternal.h	(revision 41668)
@@ -1,10 +1,9 @@
+/* $Id$ */
 /** @file
- *
- * VBox disassembler:
- * Internal header
+ * VBox disassembler - Internal header.
  */
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -20,5 +19,4 @@
 #define ___DisasmInternal_h___
 
-#include <VBox/cdefs.h>
 #include <VBox/types.h>
 #include <VBox/dis.h>
@@ -72,83 +70,9 @@
 
 
-extern PFNDISPARSE  pfnFullDisasm[IDX_ParseMax];
-extern PFNDISPARSE  pfnCalcSize[IDX_ParseMax];
-
+extern PFNDISPARSE  g_apfnFullDisasm[IDX_ParseMax];
+extern PFNDISPARSE  g_apfnCalcSize[IDX_ParseMax];
 
 unsigned ParseInstruction(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, PDISCPUSTATE pCpu);
-
-unsigned ParseIllegal(RTUINTPTR lpszCodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseModRM(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseModRM_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned UseModRM(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmByte(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmByte_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmByteSX(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmByteSX_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmBRel(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmBRel_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmUshort(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmUshort_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmV(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmV_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmVRel(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmVRel_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmZ(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmZ_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-
-unsigned ParseImmAddr(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmAddr_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmAddrF(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmAddrF_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseFixedReg(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmUlong(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmUlong_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmQword(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmQword_SizeOnly(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-
-unsigned ParseTwoByteEsc(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseThreeByteEsc4(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseThreeByteEsc5(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseImmGrpl(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseShiftGrp2(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp3(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp4(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp5(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned Parse3DNow(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp6(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp7(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp8(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp9(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp10(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp12(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp13(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp14(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp15(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseGrp16(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseModFence(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseNopPause(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-
-unsigned ParseYv(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseYb(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseXv(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-unsigned ParseXb(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-
-/* Floating point parsing */
-unsigned ParseEscFP(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
-
 void disValidateLockSequence(PDISCPUSTATE pCpu);
-
-/* Disassembler printf */
-void disasmSprintf(char *pszOutput, RTUINTPTR pu8Instruction, PDISCPUSTATE pCpu, POP_PARAMETER pParam1, POP_PARAMETER pParam2, POP_PARAMETER pParam3 = NULL);
-void disasmGetPtrString(PDISCPUSTATE pCpu, PCOPCODE pOp, POP_PARAMETER pParam);
-void disasmModRMReg(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam, int fRegAddr);
-void disasmModRMReg16(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam);
-void disasmModRMSReg(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam);
-void disasmPrintAbs32(POP_PARAMETER pParam);
-void disasmPrintDisp32(POP_PARAMETER pParam);
-void disasmPrintDisp64(POP_PARAMETER pParam);
-void disasmPrintDisp8(POP_PARAMETER pParam);
-void disasmPrintDisp16(POP_PARAMETER pParam);
-
 
 /* Read functions */
@@ -161,4 +85,4 @@
 size_t disFormatBytes(PCDISCPUSTATE pCpu, char *pszDst, size_t cchDst, uint32_t fFlags);
 
-#endif /* !___DisasmInternal_h___ */
+#endif
 
Index: /trunk/src/VBox/Disassembler/DisasmReg.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41667)
+++ /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41668)
@@ -1,10 +1,9 @@
+/* $Id$ */
 /** @file
- *
- * VBox disassembler:
- * Core components
+ * VBox disassembler- Register Info Helpers.
  */
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -22,8 +21,4 @@
 *******************************************************************************/
 #define LOG_GROUP LOG_GROUP_DIS
-#ifdef USING_VISUAL_STUDIO
-# include <stdafx.h>
-#endif
-
 #include <VBox/dis.h>
 #include <VBox/disopcode.h>
@@ -36,9 +31,4 @@
 #include "DisasmInternal.h"
 #include "DisasmTables.h"
-
-#if !defined(DIS_CORE_ONLY) && defined(LOG_ENABLED)
-# include <stdlib.h>
-# include <stdio.h>
-#endif
 
 
@@ -825,4 +815,3 @@
     return VERR_INVALID_PARAMETER;
 }
-//*****************************************************************************
-//*****************************************************************************
+
Index: /trunk/src/VBox/Disassembler/DisasmTables.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmTables.cpp	(revision 41667)
+++ /trunk/src/VBox/Disassembler/DisasmTables.cpp	(revision 41668)
@@ -1,8 +1,9 @@
+/* $Id$ */
 /** @file
- * VBox disassembler - Tables.
+ * VBox disassembler - Tables for X86 (32-bit and 16-bit modes).
  */
 
 /*
- * Copyright (C) 2006-2011 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -19,7 +20,4 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#ifdef USING_VISUAL_STUDIO
-# include <stdafx.h>
-#endif
 #include <VBox/dis.h>
 #include <VBox/disopcode.h>
@@ -27,19 +25,4 @@
 #include "DisasmInternal.h"
 
-
-/** @def O
- * Wrapper which initializes an OPCODE.
- * We must use this so that we can exclude unused fields in order
- * to save precious bytes in the GC version.
- *
- * @internal
- */
-#ifndef DIS_CORE_ONLY
-# define OP(pszOpcode, idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype) \
-    { pszOpcode, idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype }
-#else
-# define OP(pszOpcode, idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype) \
-    { idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype }
-#endif
 
 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Index: /trunk/src/VBox/Disassembler/DisasmTables.h
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmTables.h	(revision 41667)
+++ /trunk/src/VBox/Disassembler/DisasmTables.h	(revision 41668)
@@ -1,10 +1,9 @@
+/* $Id$ */
 /** @file
- *
- * VBox disassembler:
- * Tables.header
+ * VBox disassembler - Tables Header.
  */
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -17,6 +16,6 @@
  */
 
-#ifndef __disasmtable_h__
-#define __disasmtable_h__
+#ifndef ___disasmtable_h___
+#define ___disasmtable_h___
 
 #include <VBox/dis.h>
@@ -99,4 +98,19 @@
 /** @} */
 
-#endif /* !__disasmtable_h__ */
+/** @def OP
+ * Wrapper which initializes an OPCODE.
+ * We must use this so that we can exclude unused fields in order
+ * to save precious bytes in the GC version.
+ *
+ * @internal
+ */
+#ifndef DIS_CORE_ONLY
+# define OP(pszOpcode, idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype) \
+    { pszOpcode, idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype }
+#else
+# define OP(pszOpcode, idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype) \
+    { idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype }
+#endif
 
+#endif
+
Index: /trunk/src/VBox/Disassembler/DisasmTablesX64.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmTablesX64.cpp	(revision 41667)
+++ /trunk/src/VBox/Disassembler/DisasmTablesX64.cpp	(revision 41668)
@@ -1,8 +1,9 @@
+/* $Id$ */
 /** @file
- * VBox disassembler - Tables for AMD64 (long mode).
+ * VBox disassembler - Tables for AMD64 (64-bit mode).
  */
 
 /*
- * Copyright (C) 2006-2011 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -19,7 +20,4 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#ifdef USING_VISUAL_STUDIO
-# include <stdafx.h>
-#endif
 #include <VBox/dis.h>
 #include <VBox/disopcode.h>
@@ -27,19 +25,4 @@
 #include "DisasmInternal.h"
 
-
-/** @def O
- * Wrapper which initializes an OPCODE.
- * We must use this so that we can exclude unused fields in order
- * to save precious bytes in the GC version.
- *
- * @internal
- */
-#ifndef DIS_CORE_ONLY
-# define OP(pszOpcode, idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype) \
-    { pszOpcode, idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype }
-#else
-# define OP(pszOpcode, idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype) \
-    { idxParse1, idxParse2, idxParse3, opcode, param1, param2, param3, optype }
-#endif
 
 //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Index: /trunk/src/VBox/Disassembler/DisasmTestCore.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmTestCore.cpp	(revision 41667)
+++ /trunk/src/VBox/Disassembler/DisasmTestCore.cpp	(revision 41668)
@@ -39,5 +39,5 @@
         unsigned    cb;
         DISCPUSTATE cpu;
-        if (DISCoreOneEx((uintptr_t)&DISCoreOneEx, CPUMODE_32BIT, NULL /*pfnReadBytes*/, NULL /*pvUser*/, &cpu, &cb))
+        if (DISCoreOne((uintptr_t)&DISCoreOne, CPUMODE_32BIT, &cpu, &cb))
             printf("ok %d\n", cpu.addrmode);
         else
Index: /trunk/src/VBox/Disassembler/testcase/tstDisasm-2.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/testcase/tstDisasm-2.cpp	(revision 41667)
+++ /trunk/src/VBox/Disassembler/testcase/tstDisasm-2.cpp	(revision 41668)
@@ -103,5 +103,5 @@
 #endif
 
-    RTPrintf("    %s ; %08llu %s", szTmp, pState->uAddress, pState->szLine);
+    RTPrintf("    %s ; %s", szTmp, pState->szLine);
 }
 
Index: /trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp
===================================================================
--- /trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp	(revision 41667)
+++ /trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp	(revision 41668)
@@ -164,7 +164,7 @@
         char        szOutput[256];
         unsigned    cbInstr;
-        int rc = DISCoreOneEx(uNearAddr + i, pCpu->mode,
-                              MyReadBytes, (uint8_t *)pvCodeBlock - (uintptr_t)uNearAddr,
-                              pCpu, &cbInstr);
+        int rc = DISCoreOneWithReader(uNearAddr + i, pCpu->mode,
+                                      MyReadBytes, (uint8_t *)pvCodeBlock - (uintptr_t)uNearAddr,
+                                      pCpu, &cbInstr);
         RTAssertSetMayPanic(fMayPanic);
         RTAssertSetQuiet(fQuiet);
Index: /trunk/src/VBox/Runtime/testcase/tstLdrDisasmTest.cpp
===================================================================
--- /trunk/src/VBox/Runtime/testcase/tstLdrDisasmTest.cpp	(revision 41667)
+++ /trunk/src/VBox/Runtime/testcase/tstLdrDisasmTest.cpp	(revision 41668)
@@ -105,5 +105,5 @@
 {
     uint32_t cb;
-    int rc = DISCoreOneEx(CodeIndex, CPUMODE_32BIT, DisasmTest1ReadCode, 0, pCpu, &cb);
+    int rc = DISCoreOneWithReader(CodeIndex, CPUMODE_32BIT, DisasmTest1ReadCode, 0, pCpu, &cb);
     *pcb = cb;
     MY_PRINTF(("DISCoreOneEx -> rc=%d cb=%d  Cpu: opcode=%#x pCurInstr=%p (42=%d)\n", \
Index: /trunk/src/VBox/Runtime/testcase/tstLdrObj.cpp
===================================================================
--- /trunk/src/VBox/Runtime/testcase/tstLdrObj.cpp	(revision 41667)
+++ /trunk/src/VBox/Runtime/testcase/tstLdrObj.cpp	(revision 41668)
@@ -98,5 +98,5 @@
     static unsigned cb;
     DISCPUSTATE Cpu;
-    DISCoreOneEx((uintptr_t)SomeExportFunction3, CPUMODE_32BIT, NULL /*pfnReadBytes*/, NULL /*pvUser*/, &Cpu, &cb);
+    DISCoreOne((uintptr_t)SomeExportFunction3, CPUMODE_32BIT, &Cpu, &cb);
     return (void *)(uintptr_t)&SomeExportFunction1;
 }
Index: /trunk/src/VBox/Runtime/testcase/tstLdrObjR0.cpp
===================================================================
--- /trunk/src/VBox/Runtime/testcase/tstLdrObjR0.cpp	(revision 41667)
+++ /trunk/src/VBox/Runtime/testcase/tstLdrObjR0.cpp	(revision 41668)
@@ -98,5 +98,5 @@
     Cpu.mode = CPUMODE_32BIT;
 
-    DISCoreOneEx((uintptr_t)SomeExportFunction3, CPUMODE_32BIT, NULL /*pfnReadBytes*/, NULL /*pvUser*/, &Cpu, &cb);
+    DISCoreOne((uintptr_t)SomeExportFunction3, CPUMODE_32BIT, &Cpu, &cb);
     return (void *)(uintptr_t)&SomeExportFunction1;
 }
Index: /trunk/src/VBox/VMM/VMMAll/EMAll.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/EMAll.cpp	(revision 41667)
+++ /trunk/src/VBox/VMM/VMMAll/EMAll.cpp	(revision 41668)
@@ -364,5 +364,5 @@
         State.GCPtr = NIL_RTGCPTR;
     }
-    return DISCoreOneEx(InstrGC, pDis->mode, emReadBytes, &State, pDis, pOpsize);
+    return DISCoreOneWithReader(InstrGC, pDis->mode, emReadBytes, &State, pDis, pOpsize);
 }
 
@@ -377,5 +377,5 @@
     State.GCPtr = InstrGC;
 
-    return DISCoreOneEx(InstrGC, pDis->mode, emReadBytes, &State, pDis, pOpsize);
+    return DISCoreOneWithReader(InstrGC, pDis->mode, emReadBytes, &State, pDis, pOpsize);
 }
 
@@ -459,8 +459,6 @@
 #endif
 
-    rc = DISCoreOneEx(GCPtrInstr,
-                      SELMGetCpuModeFromSelector(pVCpu, pCtxCore->eflags, pCtxCore->cs, (PCPUMSELREGHID)&pCtxCore->csHid),
-                      emReadBytes, &State,
-                      pDis, pcbInstr);
+    DISCPUMODE enmCpuMode = SELMGetCpuModeFromSelector(pVCpu, pCtxCore->eflags, pCtxCore->cs, (PCPUMSELREGHID)&pCtxCore->csHid);
+    rc = DISCoreOneWithReader(GCPtrInstr, enmCpuMode, emReadBytes, &State, pDis, pcbInstr);
     if (RT_SUCCESS(rc))
         return VINF_SUCCESS;
Index: /trunk/src/VBox/VMM/VMMR3/DBGFDisas.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/DBGFDisas.cpp	(revision 41667)
+++ /trunk/src/VBox/VMM/VMMR3/DBGFDisas.cpp	(revision 41668)
@@ -140,10 +140,10 @@
 
     uint32_t cbInstr;
-    int rc = DISCoreOneEx(GCPtr,
-                          enmCpuMode,
-                          dbgfR3DisasInstrRead,
-                          &pState->Cpu,
-                          &pState->Cpu,
-                          &cbInstr);
+    int rc = DISCoreOneWithReader(GCPtr,
+                                  enmCpuMode,
+                                  dbgfR3DisasInstrRead,
+                                  &pState->Cpu,
+                                  &pState->Cpu,
+                                  &cbInstr);
     if (RT_SUCCESS(rc))
     {
Index: /trunk/src/VBox/VMM/VMMRC/PATMRC.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMRC/PATMRC.cpp	(revision 41667)
+++ /trunk/src/VBox/VMM/VMMRC/PATMRC.cpp	(revision 41668)
@@ -523,6 +523,5 @@
             rc = VBOXSTRICTRC_TODO(rcStrict);
 #else
-            rc = DISCoreOneEx((uintptr_t)&pRec->patch.aPrivInstr[0], cpu.mode, NULL /*pfnReadBytes*/, NULL /*pvUser*/,
-                              &cpu, &cbOp);
+            rc = DISCoreOne((uintptr_t)&pRec->patch.aPrivInstr[0], cpu.mode, &cpu, &cbOp);
             if (RT_FAILURE(rc))
             {