Index: /trunk/include/VBox/dis.h
===================================================================
--- /trunk/include/VBox/dis.h	(revision 41689)
+++ /trunk/include/VBox/dis.h	(revision 41690)
@@ -442,8 +442,6 @@
 
 
-/** Pointer to opcode. */
-typedef struct OPCODE *POPCODE;
 /** Pointer to const opcode. */
-typedef const struct OPCODE *PCOPCODE;
+typedef const struct DISOPCODE *PCDISOPCODE;
 
 /**
@@ -464,5 +462,5 @@
 /** Parser callback.
  * @remark no DECLCALLBACK() here because it's considered to be internal (really, I'm too lazy to update all the functions). */
-typedef unsigned FNDISPARSE(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
+typedef unsigned FNDISPARSE(RTUINTPTR pu8CodeBlock, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
 typedef FNDISPARSE *PFNDISPARSE;
 
@@ -538,5 +536,5 @@
 
     /** Pointer to the current instruction. */
-    PCOPCODE        pCurInstr;
+    PCDISOPCODE     pCurInstr;
 #ifndef DIS_CORE_ONLY
     /** Opcode format string for current instruction. */
@@ -558,5 +556,5 @@
 /** Opcode. */
 #pragma pack(4)
-typedef struct OPCODE
+typedef struct DISOPCODE
 {
 #ifndef DIS_CORE_ONLY
@@ -571,6 +569,6 @@
     uint16_t    param3;
 
-    unsigned    optype;
-} OPCODE;
+    uint32_t    optype;
+} DISOPCODE;
 #pragma pack()
 
Index: /trunk/src/VBox/Disassembler/Disasm.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/Disasm.cpp	(revision 41689)
+++ /trunk/src/VBox/Disassembler/Disasm.cpp	(revision 41690)
@@ -27,5 +27,4 @@
 #include <iprt/string.h>
 #include "DisasmInternal.h"
-#include "DisasmTables.h"
 
 
Index: /trunk/src/VBox/Disassembler/DisasmCore.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41689)
+++ /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41690)
@@ -29,5 +29,4 @@
 #include <iprt/stdarg.h>
 #include "DisasmInternal.h"
-#include "DisasmTables.h"
 
 
@@ -35,14 +34,24 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-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);
+static int      disInstrWorker(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, PCDISOPCODE paOneByteMap, uint32_t *pcbInstr);
+static unsigned disParseInstruction(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISCPUSTATE pCpu);
+
+static unsigned QueryModRM(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc = NULL);
+static unsigned QueryModRM_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc = NULL);
+static void     UseSIB(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
+static unsigned ParseSIB_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu);
+
+static void     disasmModRMReg(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, POP_PARAMETER pParam, int fRegAddr);
+static void     disasmModRMReg16(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, POP_PARAMETER pParam);
+static void     disasmModRMSReg(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, POP_PARAMETER pParam);
+
+static void     disValidateLockSequence(PDISCPUSTATE pCpu);
+
+/* Read functions */
+static uint8_t  disReadByte(PDISCPUSTATE pCpu, RTUINTPTR pAddress);
+static uint16_t disReadWord(PDISCPUSTATE pCpu, RTUINTPTR pAddress);
+static uint32_t disReadDWord(PDISCPUSTATE pCpu, RTUINTPTR pAddress);
+static uint64_t disReadQWord(PDISCPUSTATE pCpu, RTUINTPTR pAddress);
+static DECLCALLBACK(int) disReadBytesDefault(PDISCPUSTATE pCpu, uint8_t *pbDst, RTUINTPTR uSrcAddr, uint32_t cbToRead);
 
 
@@ -105,5 +114,5 @@
 static FNDISPARSE ParseXb;
 
-/* Floating point parsing */
+/** Floating point parsing */
 static FNDISPARSE ParseEscFP;
 /** @}  */
@@ -114,5 +123,5 @@
 *******************************************************************************/
 /** Parser opcode table for full disassembly. */
-PFNDISPARSE  g_apfnFullDisasm[IDX_ParseMax] =
+static PFNDISPARSE  g_apfnFullDisasm[IDX_ParseMax] =
 {
     ParseIllegal,
@@ -160,5 +169,5 @@
 
 /** Parser opcode table for only calculating instruction size. */
-PFNDISPARSE  g_apfnCalcSize[IDX_ParseMax] =
+static PFNDISPARSE  g_apfnCalcSize[IDX_ParseMax] =
 {
     ParseIllegal,
@@ -275,5 +284,5 @@
                        PDISCPUSTATE pCpu, uint32_t *pcbInstr)
 {
-    const OPCODE *paOneByteMap;
+    PCDISOPCODE paOneByteMap;
 
     /*
@@ -305,10 +314,10 @@
     pCpu->apvUserData[0]    = pvUser;
 
-    return disCoreParseInstr(pCpu, uInstrAddr, paOneByteMap, pcbInstr);
+    return disInstrWorker(pCpu, uInstrAddr, paOneByteMap, pcbInstr);
 }
 
 
 /**
- * Internal worker for DISCoreOne and DISCoreOneEx.
+ * Internal worker for DISInstEx.
  *
  * @returns VBox status code.
@@ -318,5 +327,5 @@
  * @param   pcbInstr        Where to store the instruction size. Can be NULL.
  */
-static int disCoreParseInstr(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, const OPCODE *paOneByteMap, uint32_t *pcbInstr)
+static int disInstrWorker(PDISCPUSTATE pCpu, RTUINTPTR uInstrAddr, PCDISOPCODE paOneByteMap, uint32_t *pcbInstr)
 {
     /*
@@ -327,5 +336,5 @@
     for (;;)
     {
-        uint8_t codebyte = DISReadByte(pCpu, uInstrAddr+iByte);
+        uint8_t codebyte = disReadByte(pCpu, uInstrAddr+iByte);
         uint8_t opcode   = paOneByteMap[codebyte].opcode;
 
@@ -420,5 +429,5 @@
         pCpu->opcode = codebyte;
 
-        cbInc = ParseInstruction(uInstrAddr + iByte, &paOneByteMap[pCpu->opcode], pCpu);
+        cbInc = disParseInstruction(uInstrAddr + iByte, &paOneByteMap[pCpu->opcode], pCpu);
         iByte += cbInc;
         break;
@@ -437,5 +446,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseInstruction(RTUINTPTR uCodePtr, PCOPCODE pOp, PDISCPUSTATE pCpu)
+static unsigned disParseInstruction(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISCPUSTATE pCpu)
 {
     int  size = 0;
@@ -512,13 +521,13 @@
 /* Floating point opcode parsing */
 //*****************************************************************************
-unsigned ParseEscFP(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseEscFP(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     int index;
-    const OPCODE *fpop;
+    PCDISOPCODE fpop;
     unsigned size = 0;
     unsigned ModRM;
     NOREF(pOp);
 
-    ModRM = DISReadByte(pCpu, uCodePtr);
+    ModRM = disReadByte(pCpu, uCodePtr);
 
     index = pCpu->opcode - 0xD8;
@@ -526,5 +535,5 @@
     {
         fpop            = &(g_paMapX86_FP_Low[index])[MODRM_REG(ModRM)];
-        pCpu->pCurInstr = (PCOPCODE)fpop;
+        pCpu->pCurInstr = (PCDISOPCODE)fpop;
 
         // Should contain the parameter type on input
@@ -535,5 +544,5 @@
     {
         fpop            = &(g_paMapX86_FP_High[index])[ModRM - 0xC0];
-        pCpu->pCurInstr = (PCOPCODE)fpop;
+        pCpu->pCurInstr = (PCDISOPCODE)fpop;
     }
 
@@ -565,8 +574,8 @@
 
     if (fpop->idxParse1 != IDX_ParseNop)
-        size += pCpu->pfnDisasmFnTable[fpop->idxParse1](uCodePtr+size, (PCOPCODE)fpop, pParam, pCpu);
+        size += pCpu->pfnDisasmFnTable[fpop->idxParse1](uCodePtr+size, (PCDISOPCODE)fpop, pParam, pCpu);
 
     if (fpop->idxParse2 != IDX_ParseNop)
-        size += pCpu->pfnDisasmFnTable[fpop->idxParse2](uCodePtr+size, (PCOPCODE)fpop, pParam, pCpu);
+        size += pCpu->pfnDisasmFnTable[fpop->idxParse2](uCodePtr+size, (PCDISOPCODE)fpop, pParam, pCpu);
 
     // Store the opcode format string for disasmPrintf
@@ -590,5 +599,5 @@
 #endif
 //*****************************************************************************
-void UseSIB(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+void UseSIB(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned scale, base, index, regtype;
@@ -649,5 +658,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseSIB(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseSIB(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);
@@ -655,5 +664,5 @@
     NOREF(pOp); NOREF(pParam);
 
-    SIB = DISReadByte(pCpu, uCodePtr);
+    SIB = disReadByte(pCpu, uCodePtr);
     uCodePtr += size;
 
@@ -675,5 +684,5 @@
     {
         /* Additional 32 bits displacement. No change in long mode. */
-        pCpu->i32SibDisp = DISReadDWord(pCpu, uCodePtr);
+        pCpu->i32SibDisp = disReadDWord(pCpu, uCodePtr);
         size += sizeof(int32_t);
     }
@@ -682,5 +691,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseSIB_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseSIB_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);
@@ -688,5 +697,5 @@
     NOREF(pOp); NOREF(pParam);
 
-    SIB = DISReadByte(pCpu, uCodePtr);
+    SIB = disReadByte(pCpu, uCodePtr);
     uCodePtr += size;
 
@@ -716,5 +725,5 @@
 // Mod    Reg/Opcode  R/M
 //*****************************************************************************
-unsigned UseModRM(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned UseModRM(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     int      vtype = OP_PARM_VTYPE(pParam->param);
@@ -893,5 +902,5 @@
 // Query the size of the ModRM parameters and fetch the immediate data (if any)
 //*****************************************************************************
-unsigned QueryModRM(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
+unsigned QueryModRM(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
 {
     unsigned sibinc;
@@ -924,5 +933,5 @@
         case 0: /* Effective address */
             if (rm == 5) {  /* 32 bits displacement */
-                pCpu->i32SibDisp = DISReadDWord(pCpu, uCodePtr);
+                pCpu->i32SibDisp = disReadDWord(pCpu, uCodePtr);
                 size += sizeof(int32_t);
             }
@@ -931,10 +940,10 @@
 
         case 1: /* Effective address + 8 bits displacement */
-            pCpu->i32SibDisp = (int8_t)DISReadByte(pCpu, uCodePtr);
+            pCpu->i32SibDisp = (int8_t)disReadByte(pCpu, uCodePtr);
             size += sizeof(char);
             break;
 
         case 2: /* Effective address + 32 bits displacement */
-            pCpu->i32SibDisp = DISReadDWord(pCpu, uCodePtr);
+            pCpu->i32SibDisp = disReadDWord(pCpu, uCodePtr);
             size += sizeof(int32_t);
             break;
@@ -951,5 +960,5 @@
         case 0: /* Effective address */
             if (rm == 6) {
-                pCpu->i32SibDisp = DISReadWord(pCpu, uCodePtr);
+                pCpu->i32SibDisp = disReadWord(pCpu, uCodePtr);
                 size += sizeof(uint16_t);
             }
@@ -958,10 +967,10 @@
 
         case 1: /* Effective address + 8 bits displacement */
-            pCpu->i32SibDisp = (int8_t)DISReadByte(pCpu, uCodePtr);
+            pCpu->i32SibDisp = (int8_t)disReadByte(pCpu, uCodePtr);
             size += sizeof(char);
             break;
 
         case 2: /* Effective address + 32 bits displacement */
-            pCpu->i32SibDisp = (int16_t)DISReadWord(pCpu, uCodePtr);
+            pCpu->i32SibDisp = (int16_t)disReadWord(pCpu, uCodePtr);
             size += sizeof(uint16_t);
             break;
@@ -976,5 +985,5 @@
 // Query the size of the ModRM parameters and fetch the immediate data (if any)
 //*****************************************************************************
-unsigned QueryModRM_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
+unsigned QueryModRM_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu, unsigned *pSibInc)
 {
     unsigned sibinc;
@@ -1051,5 +1060,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseIllegal(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseIllegal(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
@@ -1059,10 +1068,10 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseModRM(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseModRM(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);   //ModRM byte
     unsigned sibinc, ModRM;
 
-    ModRM = DISReadByte(pCpu, uCodePtr);
+    ModRM = disReadByte(pCpu, uCodePtr);
     uCodePtr += sizeof(uint8_t);
 
@@ -1105,10 +1114,10 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseModRM_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseModRM_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = sizeof(uint8_t);   //ModRM byte
     unsigned sibinc, ModRM;
 
-    ModRM = DISReadByte(pCpu, uCodePtr);
+    ModRM = disReadByte(pCpu, uCodePtr);
     uCodePtr += sizeof(uint8_t);
 
@@ -1152,5 +1161,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseModFence(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseModFence(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     ////AssertMsgFailed(("??\n"));
@@ -1161,8 +1170,8 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmByte(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmByte(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->parval = DISReadByte(pCpu, uCodePtr);
+    pParam->parval = disReadByte(pCpu, uCodePtr);
     pParam->fUse  |= DISUSE_IMMEDIATE8;
     pParam->cb     = sizeof(uint8_t);
@@ -1171,5 +1180,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmByte_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmByte_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
@@ -1178,10 +1187,10 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmByteSX(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmByteSX(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
     if (pCpu->opmode == DISCPUMODE_32BIT)
     {
-        pParam->parval = (uint32_t)(int8_t)DISReadByte(pCpu, uCodePtr);
+        pParam->parval = (uint32_t)(int8_t)disReadByte(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE32_SX8;
         pParam->cb     = sizeof(uint32_t);
@@ -1190,5 +1199,5 @@
     if (pCpu->opmode == DISCPUMODE_64BIT)
     {
-        pParam->parval = (uint64_t)(int8_t)DISReadByte(pCpu, uCodePtr);
+        pParam->parval = (uint64_t)(int8_t)disReadByte(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE64_SX8;
         pParam->cb     = sizeof(uint64_t);
@@ -1196,5 +1205,5 @@
     else
     {
-        pParam->parval = (uint16_t)(int8_t)DISReadByte(pCpu, uCodePtr);
+        pParam->parval = (uint16_t)(int8_t)disReadByte(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE16_SX8;
         pParam->cb     = sizeof(uint16_t);
@@ -1204,5 +1213,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmByteSX_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmByteSX_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
@@ -1211,8 +1220,8 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmUshort(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmUshort(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->parval = DISReadWord(pCpu, uCodePtr);
+    pParam->parval = disReadWord(pCpu, uCodePtr);
     pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
@@ -1221,5 +1230,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmUshort_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmUshort_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
@@ -1228,8 +1237,8 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmUlong(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmUlong(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->parval = DISReadDWord(pCpu, uCodePtr);
+    pParam->parval = disReadDWord(pCpu, uCodePtr);
     pParam->fUse  |= DISUSE_IMMEDIATE32;
     pParam->cb     = sizeof(uint32_t);
@@ -1238,5 +1247,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmUlong_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmUlong_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
@@ -1245,8 +1254,8 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmQword(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmQword(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->parval = DISReadQWord(pCpu, uCodePtr);
+    pParam->parval = disReadQWord(pCpu, uCodePtr);
     pParam->fUse  |= DISUSE_IMMEDIATE64;
     pParam->cb     = sizeof(uint64_t);
@@ -1255,5 +1264,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmQword_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmQword_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
@@ -1262,10 +1271,10 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmV(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmV(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
     if (pCpu->opmode == DISCPUMODE_32BIT)
     {
-        pParam->parval = DISReadDWord(pCpu, uCodePtr);
+        pParam->parval = disReadDWord(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
@@ -1275,5 +1284,5 @@
     if (pCpu->opmode == DISCPUMODE_64BIT)
     {
-        pParam->parval = DISReadQWord(pCpu, uCodePtr);
+        pParam->parval = disReadQWord(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
@@ -1281,5 +1290,5 @@
     }
 
-    pParam->parval = DISReadWord(pCpu, uCodePtr);
+    pParam->parval = disReadWord(pCpu, uCodePtr);
     pParam->fUse  |= DISUSE_IMMEDIATE16;
     pParam->cb     = sizeof(uint16_t);
@@ -1288,5 +1297,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmV_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmV_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
@@ -1299,5 +1308,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmZ(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmZ(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
@@ -1305,5 +1314,5 @@
     if (pCpu->opmode == DISCPUMODE_16BIT)
     {
-        pParam->parval = DISReadWord(pCpu, uCodePtr);
+        pParam->parval = disReadWord(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE16;
         pParam->cb     = sizeof(uint16_t);
@@ -1314,5 +1323,5 @@
     if (pCpu->opmode == DISCPUMODE_64BIT)
     {
-        pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, uCodePtr);
+        pParam->parval = (uint64_t)(int32_t)disReadDWord(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE64;
         pParam->cb     = sizeof(uint64_t);
@@ -1320,5 +1329,5 @@
     else
     {
-        pParam->parval = DISReadDWord(pCpu, uCodePtr);
+        pParam->parval = disReadDWord(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE32;
         pParam->cb     = sizeof(uint32_t);
@@ -1328,5 +1337,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmZ_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmZ_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
@@ -1340,8 +1349,8 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-unsigned ParseImmBRel(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmBRel(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
-    pParam->parval = DISReadByte(pCpu, uCodePtr);
+    pParam->parval = disReadByte(pCpu, uCodePtr);
     pParam->fUse  |= DISUSE_IMMEDIATE8_REL;
     pParam->cb     = sizeof(uint8_t);
@@ -1351,5 +1360,5 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-unsigned ParseImmBRel_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmBRel_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp); NOREF(pParam); NOREF(pCpu);
@@ -1359,10 +1368,10 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-unsigned ParseImmVRel(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmVRel(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(pOp);
     if (pCpu->opmode == DISCPUMODE_32BIT)
     {
-        pParam->parval = DISReadDWord(pCpu, uCodePtr);
+        pParam->parval = disReadDWord(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE32_REL;
         pParam->cb     = sizeof(int32_t);
@@ -1373,5 +1382,5 @@
     {
         /* 32 bits relative immediate sign extended to 64 bits. */
-        pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, uCodePtr);
+        pParam->parval = (uint64_t)(int32_t)disReadDWord(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE64_REL;
         pParam->cb     = sizeof(int64_t);
@@ -1379,5 +1388,5 @@
     }
 
-    pParam->parval = DISReadWord(pCpu, uCodePtr);
+    pParam->parval = disReadWord(pCpu, uCodePtr);
     pParam->fUse  |= DISUSE_IMMEDIATE16_REL;
     pParam->cb     = sizeof(int16_t);
@@ -1387,5 +1396,5 @@
 // Relative displacement for branches (rel. to next instruction)
 //*****************************************************************************
-unsigned ParseImmVRel_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmVRel_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
@@ -1397,5 +1406,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmAddr(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmAddr(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     if (pCpu->addrmode == DISCPUMODE_32BIT)
@@ -1404,6 +1413,6 @@
         {
             /* far 16:32 pointer */
-            pParam->parval = DISReadDWord(pCpu, uCodePtr);
-            *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, uCodePtr+sizeof(uint32_t));
+            pParam->parval = disReadDWord(pCpu, uCodePtr);
+            *((uint32_t*)&pParam->parval+1) = disReadWord(pCpu, uCodePtr+sizeof(uint32_t));
             pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
             pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
@@ -1417,5 +1426,5 @@
          * so we treat it like displacement.
          */
-        pParam->uDisp.i32 = DISReadDWord(pCpu, uCodePtr);
+        pParam->uDisp.i32 = disReadDWord(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_DISPLACEMENT32;
         pParam->cb     = sizeof(uint32_t);
@@ -1432,5 +1441,5 @@
          * so we treat it like displacement.
          */
-        pParam->uDisp.i64 = DISReadQWord(pCpu, uCodePtr);
+        pParam->uDisp.i64 = disReadQWord(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_DISPLACEMENT64;
         pParam->cb     = sizeof(uint64_t);
@@ -1440,5 +1449,5 @@
     {
         /* far 16:16 pointer */
-        pParam->parval = DISReadDWord(pCpu, uCodePtr);
+        pParam->parval = disReadDWord(pCpu, uCodePtr);
         pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
         pParam->cb     = 2*sizeof(uint16_t);
@@ -1452,5 +1461,5 @@
      * so we treat it like displacement.
      */
-    pParam->uDisp.i16 = DISReadWord(pCpu, uCodePtr);
+    pParam->uDisp.i16 = disReadWord(pCpu, uCodePtr);
     pParam->fUse  |= DISUSE_DISPLACEMENT16;
     pParam->cb     = sizeof(uint16_t);
@@ -1459,5 +1468,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmAddr_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmAddr_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp);
@@ -1492,5 +1501,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmAddrF(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmAddrF(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     // immediate far pointers - only 16:16 or 16:32; determined by operand, *not* address size!
@@ -1500,6 +1509,6 @@
     {
         // far 16:32 pointer
-        pParam->parval = DISReadDWord(pCpu, uCodePtr);
-        *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, uCodePtr+sizeof(uint32_t));
+        pParam->parval = disReadDWord(pCpu, uCodePtr);
+        *((uint32_t*)&pParam->parval+1) = disReadWord(pCpu, uCodePtr+sizeof(uint32_t));
         pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
         pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
@@ -1508,5 +1517,5 @@
 
     // far 16:16 pointer
-    pParam->parval = DISReadDWord(pCpu, uCodePtr);
+    pParam->parval = disReadDWord(pCpu, uCodePtr);
     pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
     pParam->cb     = 2*sizeof(uint16_t);
@@ -1515,5 +1524,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseImmAddrF_SizeOnly(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseImmAddrF_SizeOnly(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp);
@@ -1534,5 +1543,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseFixedReg(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseFixedReg(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr);
@@ -1635,5 +1644,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseXv(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseXv(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr);
@@ -1660,5 +1669,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseXb(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseXb(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp);
@@ -1685,5 +1694,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseYv(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseYv(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr);
@@ -1710,5 +1719,5 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseYb(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseYb(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     NOREF(uCodePtr); NOREF(pOp);
@@ -1735,12 +1744,12 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseTwoByteEsc(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    const OPCODE *pOpcode;
+unsigned ParseTwoByteEsc(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    PCDISOPCODE   pOpcode;
     int           size    = sizeof(uint8_t);
     NOREF(pOp); NOREF(pParam);
 
     /* 2nd byte */
-    pCpu->opcode = DISReadByte(pCpu, uCodePtr);
+    pCpu->opcode = disReadByte(pCpu, uCodePtr);
 
     /* default to the non-prefixed table. */
@@ -1789,17 +1798,17 @@
     }
 
-    size += ParseInstruction(uCodePtr+size, pOpcode, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseThreeByteEsc4(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    const OPCODE *pOpcode;
+    size += disParseInstruction(uCodePtr+size, pOpcode, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseThreeByteEsc4(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    PCDISOPCODE   pOpcode;
     int           size    = sizeof(uint8_t);
     NOREF(pOp); NOREF(pParam);
 
     /* 3rd byte */
-    pCpu->opcode = DISReadByte(pCpu, uCodePtr);
+    pCpu->opcode = disReadByte(pCpu, uCodePtr);
 
     /* default to the non-prefixed table. */
@@ -1850,17 +1859,17 @@
     }
 
-    size += ParseInstruction(uCodePtr+size, pOpcode, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseThreeByteEsc5(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
-{
-    const OPCODE *pOpcode;
+    size += disParseInstruction(uCodePtr+size, pOpcode, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseThreeByteEsc5(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+{
+    PCDISOPCODE   pOpcode;
     int           size    = sizeof(uint8_t);
     NOREF(pOp); NOREF(pParam);
 
     /* 3rd byte */
-    pCpu->opcode = DISReadByte(pCpu, uCodePtr);
+    pCpu->opcode = disReadByte(pCpu, uCodePtr);
 
     /** @todo Should we take the first or last prefix byte in case of multiple prefix bytes??? */
@@ -1885,10 +1894,10 @@
         pOpcode = &g_InvalidOpcode[0];
 
-    size += ParseInstruction(uCodePtr+size, pOpcode, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseNopPause(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr+size, pOpcode, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseNopPause(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0;
@@ -1903,10 +1912,10 @@
         pOp = &g_aMapX86_NopPause[0]; /* NOP */
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseImmGrpl(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseImmGrpl(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     int idx = (pCpu->opcode - 0x80) * 8;
@@ -1914,19 +1923,19 @@
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
-    pOp = (PCOPCODE)&g_aMapX86_Group1[idx+reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group1[idx+reg];
     //little hack to make sure the ModRM byte is included in the returned size
     if (pOp->idxParse1 != IDX_ParseModRM && pOp->idxParse2 != IDX_ParseModRM)
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseShiftGrp2(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseShiftGrp2(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     int idx;
@@ -1953,8 +1962,8 @@
     }
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
-    pOp = (PCOPCODE)&g_aMapX86_Group2[idx+reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group2[idx+reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -1962,11 +1971,11 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp3(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp3(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     int idx = (pCpu->opcode - 0xF6) * 8;
@@ -1974,8 +1983,8 @@
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
-    pOp = (PCOPCODE)&g_aMapX86_Group3[idx+reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group3[idx+reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -1983,19 +1992,19 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp4(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp4(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
-    pOp = (PCOPCODE)&g_aMapX86_Group4[reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group4[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2003,19 +2012,19 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp5(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp5(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
-    pOp = (PCOPCODE)&g_aMapX86_Group5[reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group5[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2023,5 +2032,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
 
     return size;
@@ -2033,5 +2042,5 @@
 //
 //*****************************************************************************
-unsigned Parse3DNow(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned Parse3DNow(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrmsize;
@@ -2042,5 +2051,5 @@
 #endif
 
-    unsigned ModRM = DISReadByte(pCpu, uCodePtr);
+    unsigned ModRM = disReadByte(pCpu, uCodePtr);
     pCpu->ModRM.Bits.Rm  = MODRM_RM(ModRM);
     pCpu->ModRM.Bits.Mod = MODRM_MOD(ModRM);
@@ -2049,7 +2058,7 @@
     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];
+    uint8_t opcode = disReadByte(pCpu, uCodePtr+sizeof(uint8_t)+modrmsize);
+
+    pOp = (PCDISOPCODE)&g_aTwoByteMapX86_3DNow[opcode];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2062,5 +2071,5 @@
     }
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
     size += sizeof(uint8_t);   //imm8_opcode uint8_t
 
@@ -2069,13 +2078,13 @@
 //*****************************************************************************
 //*****************************************************************************
-unsigned ParseGrp6(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+unsigned ParseGrp6(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
-    pOp = (PCOPCODE)&g_aMapX86_Group6[reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group6[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2083,16 +2092,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp7(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp7(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg, rm, mod;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     mod   = MODRM_MOD(modrm);
     reg   = MODRM_REG(modrm);
@@ -2100,10 +2109,10 @@
 
     if (mod == 3 && rm == 0)
-        pOp = (PCOPCODE)&g_aMapX86_Group7_mod11_rm000[reg];
+        pOp = (PCDISOPCODE)&g_aMapX86_Group7_mod11_rm000[reg];
     else
     if (mod == 3 && rm == 1)
-        pOp = (PCOPCODE)&g_aMapX86_Group7_mod11_rm001[reg];
-    else
-        pOp = (PCOPCODE)&g_aMapX86_Group7_mem[reg];
+        pOp = (PCDISOPCODE)&g_aMapX86_Group7_mod11_rm001[reg];
+    else
+        pOp = (PCDISOPCODE)&g_aMapX86_Group7_mem[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2111,19 +2120,19 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp8(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp8(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
-    pOp = (PCOPCODE)&g_aMapX86_Group8[reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group8[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2131,19 +2140,19 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp9(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp9(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
-    pOp = (PCOPCODE)&g_aMapX86_Group9[reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group9[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2151,19 +2160,19 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp10(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp10(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
-    pOp = (PCOPCODE)&g_aMapX86_Group10[reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group10[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2171,16 +2180,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp12(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp12(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
@@ -2188,5 +2197,5 @@
         reg += 8;   //2nd table
 
-    pOp = (PCOPCODE)&g_aMapX86_Group12[reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group12[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2194,20 +2203,20 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp13(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp13(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
     if (pCpu->prefix & DISPREFIX_OPSIZE)
         reg += 8;   //2nd table
 
-    pOp = (PCOPCODE)&g_aMapX86_Group13[reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group13[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2215,21 +2224,21 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp14(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp14(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
     if (pCpu->prefix & DISPREFIX_OPSIZE)
         reg += 8;   //2nd table
 
-    pOp = (PCOPCODE)&g_aMapX86_Group14[reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group14[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2237,16 +2246,16 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp15(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp15(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg, mod, rm;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     mod   = MODRM_MOD(modrm);
     reg   = MODRM_REG(modrm);
@@ -2254,7 +2263,7 @@
 
     if (mod == 3 && rm == 0)
-        pOp = (PCOPCODE)&g_aMapX86_Group15_mod11_rm000[reg];
-    else
-        pOp = (PCOPCODE)&g_aMapX86_Group15_mem[reg];
+        pOp = (PCDISOPCODE)&g_aMapX86_Group15_mod11_rm000[reg];
+    else
+        pOp = (PCDISOPCODE)&g_aMapX86_Group15_mem[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2262,18 +2271,18 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
-    return size;
-}
-//*****************************************************************************
-//*****************************************************************************
-unsigned ParseGrp16(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
+    return size;
+}
+//*****************************************************************************
+//*****************************************************************************
+unsigned ParseGrp16(RTUINTPTR uCodePtr, PCDISOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
 {
     unsigned size = 0, modrm, reg;
     NOREF(pParam);
 
-    modrm = DISReadByte(pCpu, uCodePtr);
+    modrm = disReadByte(pCpu, uCodePtr);
     reg   = MODRM_REG(modrm);
 
-    pOp = (PCOPCODE)&g_aMapX86_Group16[reg];
+    pOp = (PCDISOPCODE)&g_aMapX86_Group16[reg];
 
     //little hack to make sure the ModRM byte is included in the returned size
@@ -2281,5 +2290,5 @@
         size = sizeof(uint8_t); //ModRM byte
 
-    size += ParseInstruction(uCodePtr, pOp, pCpu);
+    size += disParseInstruction(uCodePtr, pOp, pCpu);
     return size;
 }
@@ -2296,5 +2305,5 @@
 static const int   IndexModRMReg16[4] = { USE_REG_SI, USE_REG_DI, USE_REG_SI, USE_REG_DI};
 //*****************************************************************************
-static void disasmModRMReg(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam, int fRegAddr)
+static void disasmModRMReg(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, POP_PARAMETER pParam, int fRegAddr)
 {
     int subtype, type, mod;
@@ -2372,5 +2381,5 @@
 //*****************************************************************************
 //*****************************************************************************
-static void disasmModRMReg16(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam)
+static void disasmModRMReg16(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, POP_PARAMETER pParam)
 {
     NOREF(pCpu); NOREF(pOp);
@@ -2385,5 +2394,5 @@
 //*****************************************************************************
 //*****************************************************************************
-static void disasmModRMSReg(PDISCPUSTATE pCpu, PCOPCODE pOp, unsigned idx, POP_PARAMETER pParam)
+static void disasmModRMSReg(PDISCPUSTATE pCpu, PCDISOPCODE pOp, unsigned idx, POP_PARAMETER pParam)
 {
     NOREF(pOp);
@@ -2473,5 +2482,5 @@
 {
 #ifdef IN_RING0
-    AssertMsgFailed(("DISReadWord with no read callback in ring 0!!\n"));
+    AssertMsgFailed(("disReadWord with no read callback in ring 0!!\n"));
     RT_BZERO(pbDst, cbToRead);
     return VERR_DIS_NO_READ_CALLBACK;
@@ -2485,5 +2494,5 @@
 /* Read functions for getting the opcode bytes */
 //*****************************************************************************
-uint8_t DISReadByte(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
+uint8_t disReadByte(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
 {
     uint8_t bTemp = 0;
@@ -2491,5 +2500,5 @@
     if (RT_FAILURE(rc))
     {
-        Log(("DISReadByte failed!!\n"));
+        Log(("disReadByte failed!!\n"));
         pCpu->rc = VERR_DIS_MEM_READ;
     }
@@ -2507,5 +2516,5 @@
 //*****************************************************************************
 //*****************************************************************************
-uint16_t DISReadWord(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
+uint16_t disReadWord(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
 {
     RTUINT16U uTemp;
@@ -2514,5 +2523,5 @@
     if (RT_FAILURE(rc))
     {
-        Log(("DISReadWord failed!!\n"));
+        Log(("disReadWord failed!!\n"));
         pCpu->rc = VERR_DIS_MEM_READ;
     }
@@ -2532,5 +2541,5 @@
 //*****************************************************************************
 //*****************************************************************************
-uint32_t DISReadDWord(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
+uint32_t disReadDWord(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
 {
     RTUINT32U uTemp;
@@ -2539,5 +2548,5 @@
     if (RT_FAILURE(rc))
     {
-        Log(("DISReadDWord failed!!\n"));
+        Log(("disReadDWord failed!!\n"));
         pCpu->rc = VERR_DIS_MEM_READ;
     }
@@ -2559,5 +2568,5 @@
 //*****************************************************************************
 //*****************************************************************************
-uint64_t DISReadQWord(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
+uint64_t disReadQWord(PDISCPUSTATE pCpu, RTUINTPTR uAddress)
 {
     RTUINT64U uTemp;
@@ -2566,5 +2575,5 @@
     if (RT_FAILURE(rc))
     {
-        Log(("DISReadQWord %x failed!!\n", uAddress));
+        Log(("disReadQWord %x failed!!\n", uAddress));
         pCpu->rc = VERR_DIS_MEM_READ;
     }
@@ -2616,5 +2625,5 @@
  * @param   pCpu    Fully disassembled instruction.
  */
-void disValidateLockSequence(PDISCPUSTATE pCpu)
+static void disValidateLockSequence(PDISCPUSTATE pCpu)
 {
     Assert(pCpu->prefix & DISPREFIX_LOCK);
Index: /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp	(revision 41689)
+++ /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp	(revision 41690)
@@ -267,5 +267,5 @@
         fFlags = (fFlags & ~DIS_FMT_FLAGS_BYTES_LEFT) | DIS_FMT_FLAGS_BYTES_RIGHT;
 
-    PCOPCODE const  pOp = pCpu->pCurInstr;
+    PCDISOPCODE const pOp = pCpu->pCurInstr;
 
     /*
Index: /trunk/src/VBox/Disassembler/DisasmInternal.h
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmInternal.h	(revision 41689)
+++ /trunk/src/VBox/Disassembler/DisasmInternal.h	(revision 41690)
@@ -22,8 +22,12 @@
 #include <VBox/dis.h>
 
-#define ExceptionMemRead          0x666
-#define ExceptionInvalidModRM     0x667
-#define ExceptionInvalidParameter 0x668
 
+/** @defgroup grp_dis_int Internals.
+ * @ingroup grp_dis
+ * @{
+ */
+
+/** @name Index into g_apfnCalcSize and g_apfnFullDisasm.
+ * @{ */
 #define IDX_ParseNop                0
 #define IDX_ParseModRM              1
@@ -68,21 +72,106 @@
 #define IDX_ParseImmAddrF           40
 #define IDX_ParseMax                (IDX_ParseImmAddrF+1)
+/** @}  */
 
 
-extern PFNDISPARSE  g_apfnFullDisasm[IDX_ParseMax];
-extern PFNDISPARSE  g_apfnCalcSize[IDX_ParseMax];
+/** @name Opcode maps.
+ * @{ */
+extern const DISOPCODE g_InvalidOpcode[1];
 
-unsigned ParseInstruction(RTUINTPTR pu8CodeBlock, PCOPCODE pOp, PDISCPUSTATE pCpu);
-void disValidateLockSequence(PDISCPUSTATE pCpu);
+extern const DISOPCODE g_aOneByteMapX86[256];
+extern const DISOPCODE g_aOneByteMapX64[256];
+extern const DISOPCODE g_aTwoByteMapX86[256];
 
-/* Read functions */
-DECLCALLBACK(int) disReadBytesDefault(PDISCPUSTATE pCpu, uint8_t *pbDst, RTUINTPTR uSrcAddr, uint32_t cbToRead);
-uint8_t  DISReadByte(PDISCPUSTATE pCpu, RTUINTPTR pAddress);
-uint16_t DISReadWord(PDISCPUSTATE pCpu, RTUINTPTR pAddress);
-uint32_t DISReadDWord(PDISCPUSTATE pCpu, RTUINTPTR pAddress);
-uint64_t DISReadQWord(PDISCPUSTATE pCpu, RTUINTPTR pAddress);
+/** Two byte opcode map with prefix 0x66 */
+extern const DISOPCODE g_aTwoByteMapX86_PF66[256];
+
+/** Two byte opcode map with prefix 0xF2 */
+extern const DISOPCODE g_aTwoByteMapX86_PFF2[256];
+
+/** Two byte opcode map with prefix 0xF3 */
+extern const DISOPCODE g_aTwoByteMapX86_PFF3[256];
+
+/** Three byte opcode map (0xF 0x38) */
+extern PCDISOPCODE const g_apThreeByteMapX86_0F38[16];
+
+/** Three byte opcode map with prefix 0x66 (0xF 0x38) */
+extern PCDISOPCODE const g_apThreeByteMapX86_660F38[16];
+
+/** Three byte opcode map with prefix 0xF2 (0xF 0x38) */
+extern PCDISOPCODE const g_apThreeByteMapX86_F20F38[16];
+
+/** Three byte opcode map with prefix 0x66 (0xF 0x3A) */
+extern PCDISOPCODE const g_apThreeByteMapX86_660F3A[16];
+/** @} */
+
+/** @name Opcode extensions (Group tables)
+ * @{ */
+extern const DISOPCODE g_aMapX86_Group1[8*4];
+extern const DISOPCODE g_aMapX86_Group2[8*6];
+extern const DISOPCODE g_aMapX86_Group3[8*2];
+extern const DISOPCODE g_aMapX86_Group4[8];
+extern const DISOPCODE g_aMapX86_Group5[8];
+extern const DISOPCODE g_aMapX86_Group6[8];
+extern const DISOPCODE g_aMapX86_Group7_mem[8];
+extern const DISOPCODE g_aMapX86_Group7_mod11_rm000[8];
+extern const DISOPCODE g_aMapX86_Group7_mod11_rm001[8];
+extern const DISOPCODE g_aMapX86_Group8[8];
+extern const DISOPCODE g_aMapX86_Group9[8];
+extern const DISOPCODE g_aMapX86_Group10[8];
+extern const DISOPCODE g_aMapX86_Group11[8*2];
+extern const DISOPCODE g_aMapX86_Group12[8*2];
+extern const DISOPCODE g_aMapX86_Group13[8*2];
+extern const DISOPCODE g_aMapX86_Group14[8*2];
+extern const DISOPCODE g_aMapX86_Group15_mem[8];
+extern const DISOPCODE g_aMapX86_Group15_mod11_rm000[8];
+extern const DISOPCODE g_aMapX86_Group16[8];
+extern const DISOPCODE g_aMapX86_NopPause[2];
+/** @} */
+
+/** 3DNow! map (0x0F 0x0F prefix) */
+extern const DISOPCODE g_aTwoByteMapX86_3DNow[256];
+
+/** Floating point opcodes starting with escape byte 0xDF
+ * @{ */
+extern const DISOPCODE g_aMapX86_EscF0_Low[8];
+extern const DISOPCODE g_aMapX86_EscF0_High[16*4];
+extern const DISOPCODE g_aMapX86_EscF1_Low[8];
+extern const DISOPCODE g_aMapX86_EscF1_High[16*4];
+extern const DISOPCODE g_aMapX86_EscF2_Low[8];
+extern const DISOPCODE g_aMapX86_EscF2_High[16*4];
+extern const DISOPCODE g_aMapX86_EscF3_Low[8];
+extern const DISOPCODE g_aMapX86_EscF3_High[16*4];
+extern const DISOPCODE g_aMapX86_EscF4_Low[8];
+extern const DISOPCODE g_aMapX86_EscF4_High[16*4];
+extern const DISOPCODE g_aMapX86_EscF5_Low[8];
+extern const DISOPCODE g_aMapX86_EscF5_High[16*4];
+extern const DISOPCODE g_aMapX86_EscF6_Low[8];
+extern const DISOPCODE g_aMapX86_EscF6_High[16*4];
+extern const DISOPCODE g_aMapX86_EscF7_Low[8];
+extern const DISOPCODE g_aMapX86_EscF7_High[16*4];
+
+extern PCDISOPCODE     g_paMapX86_FP_Low[8];
+extern PCDISOPCODE     g_paMapX86_FP_High[8];
+/** @} */
+
+/** @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
+
 
 size_t disFormatBytes(PCDISCPUSTATE pCpu, char *pszDst, size_t cchDst, uint32_t fFlags);
 
+/** @} */
 #endif
 
Index: /trunk/src/VBox/Disassembler/DisasmReg.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41689)
+++ /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41690)
@@ -30,5 +30,4 @@
 #include <iprt/stdarg.h>
 #include "DisasmInternal.h"
-#include "DisasmTables.h"
 
 
Index: /trunk/src/VBox/Disassembler/DisasmTables.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmTables.cpp	(revision 41689)
+++ /trunk/src/VBox/Disassembler/DisasmTables.cpp	(revision 41690)
@@ -57,5 +57,5 @@
 
 /* Invalid opcode */
-const OPCODE g_InvalidOpcode[1] =
+const DISOPCODE g_InvalidOpcode[1] =
 {
     INVALID_OPCODE
@@ -63,5 +63,5 @@
 
 /* Tables for the elegant Intel X86 instruction set */
-const OPCODE g_aOneByteMapX86[256] =
+const DISOPCODE g_aOneByteMapX86[256] =
 {
     /* 0 */
@@ -365,5 +365,5 @@
 
 
-const OPCODE g_aTwoByteMapX86[256] =
+const DISOPCODE g_aTwoByteMapX86[256] =
 {
     /* 0 */
@@ -665,5 +665,5 @@
 
 /* Two byte opcode map with prefix 0x66 */
-const OPCODE g_aTwoByteMapX86_PF66[256] =
+const DISOPCODE g_aTwoByteMapX86_PF66[256] =
 {
     /* 0 */
@@ -867,5 +867,5 @@
 
 /* Two byte opcode map with prefix 0xF2 */
-const OPCODE g_aTwoByteMapX86_PFF2[256] =
+const DISOPCODE g_aTwoByteMapX86_PFF2[256] =
 {
     /* 0 */
@@ -1040,5 +1040,5 @@
 
 /* Two byte opcode map with prefix 0xF3 */
-const OPCODE g_aTwoByteMapX86_PFF3[256] =
+const DISOPCODE g_aTwoByteMapX86_PFF3[256] =
 {
     /* 0 */
@@ -1213,5 +1213,5 @@
 
 /** Three byte opcode map (0xF 0x38 0x0x) */
-const OPCODE g_aThreeByteMapX86_0F38_0[16] =
+const DISOPCODE g_aThreeByteMapX86_0F38_0[16] =
 {
     /* 0 */
@@ -1235,5 +1235,5 @@
 
 /** Three byte opcode map (0x0F 0x38 0x1x) */
-const OPCODE g_aThreeByteMapX86_0F38_1[16] =
+const DISOPCODE g_aThreeByteMapX86_0F38_1[16] =
 {
     /* 1 */
@@ -1256,6 +1256,6 @@
 };
 
-/* These tables are mostly sparse, so use another level of indirection to save space. */
-const OPCODE *g_apThreeByteMapX86_0F38[16] =
+/** These tables are mostly sparse, so use another level of indirection to save space. */
+PCDISOPCODE const g_apThreeByteMapX86_0F38[16] =
 {
     /* 0 */
@@ -1309,5 +1309,5 @@
 
 /** Three byte opcode map (0x66 0x0F 0x38 0x0x) */
-const OPCODE g_aThreeByteMapX86_660F38_0[16] =
+const DISOPCODE g_aThreeByteMapX86_660F38_0[16] =
 {
     /* 0 */
@@ -1331,5 +1331,5 @@
 
 /** Three byte opcode map (0x66 0x0F 0x38 0x1x) */
-const OPCODE g_aThreeByteMapX86_660F38_1[16] =
+const DISOPCODE g_aThreeByteMapX86_660F38_1[16] =
 {
     /* 1 */
@@ -1355,5 +1355,5 @@
 
 /** Three byte opcode map (0x66 0x0F 0x38 0x8x) */
-const OPCODE g_aThreeByteMapX86_660F38_8[16] =
+const DISOPCODE g_aThreeByteMapX86_660F38_8[16] =
 {
     /* 8 */
@@ -1377,5 +1377,5 @@
 
 /** Three byte opcode map with prefix 0x66 (0xF 0x38) */
-const OPCODE *g_apThreeByteMapX86_660F38[16] =
+PCDISOPCODE const g_apThreeByteMapX86_660F38[16] =
 {
     /* 0 */
@@ -1430,5 +1430,5 @@
 /** Three byte opcode map with prefix 0xF2 (0xF 0x38) */
 /** @todo remainder missing (too lazy now) */
-const OPCODE *g_apThreeByteMapX86_F20F38[16] =
+PCDISOPCODE const g_apThreeByteMapX86_F20F38[16] =
 {
     /* 0 */
@@ -1483,5 +1483,5 @@
 /** Three byte opcode map with prefix 0x66 (0xF 0x3A) */
 /** @todo remainder missing (too lazy now) */
-const OPCODE *g_apThreeByteMapX86_660F3A[16] =
+PCDISOPCODE const g_apThreeByteMapX86_660F3A[16] =
 {
     /* 0 */
@@ -1535,5 +1535,5 @@
 
 /* 3DNow! map (0x0F 0x0F prefix) */
-const OPCODE g_aTwoByteMapX86_3DNow[256] =
+const DISOPCODE g_aTwoByteMapX86_3DNow[256] =
 {
     /* 0 */
@@ -1677,5 +1677,5 @@
 
 /* Floating point opcode starting with escape byte 0xD8 (values 0-0xBF)*/
-const OPCODE g_aMapX86_EscF0_Low[8] =
+const DISOPCODE g_aMapX86_EscF0_Low[8] =
 {
     /* 0 */
@@ -1691,5 +1691,5 @@
 
 /* Floating point opcode starting with escape byte 0xD8 (outside 0-0xBF)*/
-const OPCODE g_aMapX86_EscF0_High[16*4] =
+const DISOPCODE g_aMapX86_EscF0_High[16*4] =
 {
     /* c */
@@ -1768,5 +1768,5 @@
 
 /* Floating point opcode starting with escape byte 0xD9 (values 0-0xBF)*/
-const OPCODE g_aMapX86_EscF1_Low[8] =
+const DISOPCODE g_aMapX86_EscF1_Low[8] =
 {
     /* 0 */
@@ -1785,5 +1785,5 @@
 
 /* Floating point opcode starting with escape byte 0xD9 (outside 0-0xBF)*/
-const OPCODE g_aMapX86_EscF1_High[16*4] =
+const DISOPCODE g_aMapX86_EscF1_High[16*4] =
 {
     /* c */
@@ -1863,5 +1863,5 @@
 
 /* Floating point opcode starting with escape byte 0xDA (values 0-0xBF)*/
-const OPCODE g_aMapX86_EscF2_Low[8] =
+const DISOPCODE g_aMapX86_EscF2_Low[8] =
 {
     /* 0 */
@@ -1878,5 +1878,5 @@
 
 /* Floating point opcode starting with escape byte 0xD9 (outside 0-0xBF)*/
-const OPCODE g_aMapX86_EscF2_High[16*4] =
+const DISOPCODE g_aMapX86_EscF2_High[16*4] =
 {
     /* c */
@@ -1940,5 +1940,5 @@
 
 /* Floating point opcode starting with escape byte 0xDB (values 0-0xBF)*/
-const OPCODE g_aMapX86_EscF3_Low[8] =
+const DISOPCODE g_aMapX86_EscF3_Low[8] =
 {
     /* 0 */
@@ -1955,5 +1955,5 @@
 
 /* Floating point opcode starting with escape byte 0xDB (outside 0-0xBF)*/
-const OPCODE g_aMapX86_EscF3_High[16*4] =
+const DISOPCODE g_aMapX86_EscF3_High[16*4] =
 {
     /* c */
@@ -2033,5 +2033,5 @@
 
 /* Floating point opcode starting with escape byte 0xDC (values 0-0xBF)*/
-const OPCODE g_aMapX86_EscF4_Low[8] =
+const DISOPCODE g_aMapX86_EscF4_Low[8] =
 {
     /* 0 */
@@ -2048,5 +2048,5 @@
 
 /* Floating point opcode starting with escape byte 0xDC (outside 0-0xBF)*/
-const OPCODE g_aMapX86_EscF4_High[16*4] =
+const DISOPCODE g_aMapX86_EscF4_High[16*4] =
 {
     /* c */
@@ -2111,5 +2111,5 @@
 
 /* Floating point opcode starting with escape byte 0xDD (values 0-0xBF)*/
-const OPCODE g_aMapX86_EscF5_Low[8] =
+const DISOPCODE g_aMapX86_EscF5_Low[8] =
 {
     /* 0 */
@@ -2126,5 +2126,5 @@
 
 /* Floating point opcode starting with escape byte 0xDD (outside 0-0xBF)*/
-const OPCODE g_aMapX86_EscF5_High[16*4] =
+const DISOPCODE g_aMapX86_EscF5_High[16*4] =
 {
     /* c */
@@ -2190,5 +2190,5 @@
 
 /* Floating point opcode starting with escape byte 0xDE (values 0-0xBF)*/
-const OPCODE g_aMapX86_EscF6_Low[8] =
+const DISOPCODE g_aMapX86_EscF6_Low[8] =
 {
     /* 0 */
@@ -2205,5 +2205,5 @@
 
 /* Floating point opcode starting with escape byte 0xDE (outside 0-0xBF)*/
-const OPCODE g_aMapX86_EscF6_High[16*4] =
+const DISOPCODE g_aMapX86_EscF6_High[16*4] =
 {
     /* c */
@@ -2282,5 +2282,5 @@
 
 /* Floating point opcode starting with escape byte 0xDF (values 0-0xBF)*/
-const OPCODE g_aMapX86_EscF7_Low[8] =
+const DISOPCODE g_aMapX86_EscF7_Low[8] =
 {
     /* 0 */
@@ -2297,5 +2297,5 @@
 
 /* Floating point opcode starting with escape byte 0xDF (outside 0-0xBF)*/
-const OPCODE g_aMapX86_EscF7_High[16*4] =
+const DISOPCODE g_aMapX86_EscF7_High[16*4] =
 {
     /* c */
@@ -2343,5 +2343,5 @@
 
 
-PCOPCODE g_paMapX86_FP_Low[8] =
+PCDISOPCODE g_paMapX86_FP_Low[8] =
 {
     g_aMapX86_EscF0_Low,
@@ -2355,5 +2355,5 @@
 };
 
-PCOPCODE g_paMapX86_FP_High[8] =
+PCDISOPCODE g_paMapX86_FP_High[8] =
 {
     g_aMapX86_EscF0_High,
@@ -2368,5 +2368,5 @@
 
 /* Opcode extensions (Group tables) */
-const OPCODE g_aMapX86_Group1[8*4] =
+const DISOPCODE g_aMapX86_Group1[8*4] =
 {
     /* 80 */
@@ -2411,5 +2411,5 @@
 };
 
-const OPCODE g_aMapX86_Group2[8*6] =
+const DISOPCODE g_aMapX86_Group2[8*6] =
 {
     /* C0 */
@@ -2476,5 +2476,5 @@
 
 
-const OPCODE g_aMapX86_Group3[8*2] =
+const DISOPCODE g_aMapX86_Group3[8*2] =
 {
     /* F6 */
@@ -2501,5 +2501,5 @@
 };
 
-const OPCODE g_aMapX86_Group4[8] =
+const DISOPCODE g_aMapX86_Group4[8] =
 {
     /* FE */
@@ -2514,5 +2514,5 @@
 };
 
-const OPCODE g_aMapX86_Group5[8] =
+const DISOPCODE g_aMapX86_Group5[8] =
 {
     /* FF */
@@ -2528,5 +2528,5 @@
 
 
-const OPCODE g_aMapX86_Group6[8] =
+const DISOPCODE g_aMapX86_Group6[8] =
 {
     /* 0F 00 */
@@ -2541,5 +2541,5 @@
 };
 
-const OPCODE g_aMapX86_Group7_mem[8] =
+const DISOPCODE g_aMapX86_Group7_mem[8] =
 {
     /* 0F 01 */
@@ -2554,5 +2554,5 @@
 };
 
-const OPCODE g_aMapX86_Group7_mod11_rm000[8] =
+const DISOPCODE g_aMapX86_Group7_mod11_rm000[8] =
 {
     /* 0F 01 MOD=11b */
@@ -2567,5 +2567,5 @@
 };
 
-const OPCODE g_aMapX86_Group7_mod11_rm001[8] =
+const DISOPCODE g_aMapX86_Group7_mod11_rm001[8] =
 {
     /* 0F 01 MOD=11b */
@@ -2580,5 +2580,5 @@
 };
 
-const OPCODE g_aMapX86_Group8[8] =
+const DISOPCODE g_aMapX86_Group8[8] =
 {
     /* 0F BA */
@@ -2593,5 +2593,5 @@
 };
 
-const OPCODE g_aMapX86_Group9[8] =
+const DISOPCODE g_aMapX86_Group9[8] =
 {
     /* 0F C7 */
@@ -2606,5 +2606,5 @@
 };
 
-const OPCODE g_aMapX86_Group10[8] =
+const DISOPCODE g_aMapX86_Group10[8] =
 {
     /* 0F B9 */
@@ -2620,5 +2620,5 @@
 
 
-const OPCODE g_aMapX86_Group11[8*2] =
+const DISOPCODE g_aMapX86_Group11[8*2] =
 {
     /* 0F C6 */
@@ -2644,5 +2644,5 @@
 
 /* 0xF 0x71 */
-const OPCODE g_aMapX86_Group12[8*2] =
+const DISOPCODE g_aMapX86_Group12[8*2] =
 {
     INVALID_OPCODE,
@@ -2667,5 +2667,5 @@
 
 /* 0xF 0x72 */
-const OPCODE g_aMapX86_Group13[8*2] =
+const DISOPCODE g_aMapX86_Group13[8*2] =
 {
     INVALID_OPCODE,
@@ -2690,5 +2690,5 @@
 
 /* 0xF 0x73 */
-const OPCODE g_aMapX86_Group14[8*2] =
+const DISOPCODE g_aMapX86_Group14[8*2] =
 {
     INVALID_OPCODE,
@@ -2714,5 +2714,5 @@
 
 /* 0xF 0xAE */
-const OPCODE g_aMapX86_Group15_mem[8] =
+const DISOPCODE g_aMapX86_Group15_mem[8] =
 {
     OP("fxsave %M",          IDX_ParseModRM,     0,          0,          OP_FXSAVE,  OP_PARM_M,          OP_PARM_NONE,   OP_PARM_NONE,   DISOPTYPE_HARMLESS),
@@ -2727,5 +2727,5 @@
 
 /* 0xF 0xAE */
-const OPCODE g_aMapX86_Group15_mod11_rm000[8] =
+const DISOPCODE g_aMapX86_Group15_mod11_rm000[8] =
 {
     INVALID_OPCODE,
@@ -2740,5 +2740,5 @@
 
 /* 0xF 0x18 */
-const OPCODE g_aMapX86_Group16[8] =
+const DISOPCODE g_aMapX86_Group16[8] =
 {
     OP("prefetchnta %Mb",  IDX_ParseModRM, 0,          0,          OP_PREFETCH,OP_PARM_Mb,        OP_PARM_NONE,   OP_PARM_NONE,   DISOPTYPE_HARMLESS),
@@ -2753,5 +2753,5 @@
 
 /* 0x90 or 0xF3 0x90 */
-const OPCODE g_aMapX86_NopPause[2] =
+const DISOPCODE g_aMapX86_NopPause[2] =
 {
     OP("nop",                0,              0,          0,       OP_NOP,     OP_PARM_NONE,       OP_PARM_NONE,   OP_PARM_NONE,   DISOPTYPE_HARMLESS),
Index: /trunk/src/VBox/Disassembler/DisasmTables.h
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmTables.h	(revision 41689)
+++ /trunk/src/VBox/Disassembler/DisasmTables.h	(revision 41690)
@@ -1,116 +1,1 @@
-/* $Id$ */
-/** @file
- * VBox disassembler - Tables Header.
- */
 
-/*
- * Copyright (C) 2006-2012 Oracle Corporation
- *
- * This file is part of VirtualBox Open Source Edition (OSE), as
- * available from http://www.virtualbox.org. This file is free software;
- * you can redistribute it and/or modify it under the terms of the GNU
- * General Public License (GPL) as published by the Free Software
- * Foundation, in version 2 as it comes in the "COPYING" file of the
- * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
- */
-
-#ifndef ___disasmtable_h___
-#define ___disasmtable_h___
-
-#include <VBox/dis.h>
-
-extern const OPCODE g_InvalidOpcode[1];
-
-extern const OPCODE g_aOneByteMapX86[256];
-extern const OPCODE g_aOneByteMapX64[256];
-extern const OPCODE g_aTwoByteMapX86[256];
-
-/** Two byte opcode map with prefix 0x66 */
-extern const OPCODE g_aTwoByteMapX86_PF66[256];
-
-/** Two byte opcode map with prefix 0xF2 */
-extern const OPCODE g_aTwoByteMapX86_PFF2[256];
-
-/** Two byte opcode map with prefix 0xF3 */
-extern const OPCODE g_aTwoByteMapX86_PFF3[256];
-
-/** Three byte opcode map (0xF 0x38) */
-extern const OPCODE *g_apThreeByteMapX86_0F38[16];
-
-/** Three byte opcode map with prefix 0x66 (0xF 0x38) */
-extern const OPCODE *g_apThreeByteMapX86_660F38[16];
-
-/** Three byte opcode map with prefix 0xF2 (0xF 0x38) */
-extern const OPCODE *g_apThreeByteMapX86_F20F38[16];
-
-/** Three byte opcode map with prefix 0x66 (0xF 0x3A) */
-extern const OPCODE *g_apThreeByteMapX86_660F3A[16];
-
-/** Opcode extensions (Group tables)
- * @{ */
-extern const OPCODE g_aMapX86_Group1[8*4];
-extern const OPCODE g_aMapX86_Group2[8*6];
-extern const OPCODE g_aMapX86_Group3[8*2];
-extern const OPCODE g_aMapX86_Group4[8];
-extern const OPCODE g_aMapX86_Group5[8];
-extern const OPCODE g_aMapX86_Group6[8];
-extern const OPCODE g_aMapX86_Group7_mem[8];
-extern const OPCODE g_aMapX86_Group7_mod11_rm000[8];
-extern const OPCODE g_aMapX86_Group7_mod11_rm001[8];
-extern const OPCODE g_aMapX86_Group8[8];
-extern const OPCODE g_aMapX86_Group9[8];
-extern const OPCODE g_aMapX86_Group10[8];
-extern const OPCODE g_aMapX86_Group11[8*2];
-extern const OPCODE g_aMapX86_Group12[8*2];
-extern const OPCODE g_aMapX86_Group13[8*2];
-extern const OPCODE g_aMapX86_Group14[8*2];
-extern const OPCODE g_aMapX86_Group15_mem[8];
-extern const OPCODE g_aMapX86_Group15_mod11_rm000[8];
-extern const OPCODE g_aMapX86_Group16[8];
-extern const OPCODE g_aMapX86_NopPause[2];
-/** @} */
-
-/** 3DNow! map (0x0F 0x0F prefix) */
-extern const OPCODE g_aTwoByteMapX86_3DNow[256];
-
-/** Floating point opcodes starting with escape byte 0xDF
- * @{ */
-extern const OPCODE g_aMapX86_EscF0_Low[8];
-extern const OPCODE g_aMapX86_EscF0_High[16*4];
-extern const OPCODE g_aMapX86_EscF1_Low[8];
-extern const OPCODE g_aMapX86_EscF1_High[16*4];
-extern const OPCODE g_aMapX86_EscF2_Low[8];
-extern const OPCODE g_aMapX86_EscF2_High[16*4];
-extern const OPCODE g_aMapX86_EscF3_Low[8];
-extern const OPCODE g_aMapX86_EscF3_High[16*4];
-extern const OPCODE g_aMapX86_EscF4_Low[8];
-extern const OPCODE g_aMapX86_EscF4_High[16*4];
-extern const OPCODE g_aMapX86_EscF5_Low[8];
-extern const OPCODE g_aMapX86_EscF5_High[16*4];
-extern const OPCODE g_aMapX86_EscF6_Low[8];
-extern const OPCODE g_aMapX86_EscF6_High[16*4];
-extern const OPCODE g_aMapX86_EscF7_Low[8];
-extern const OPCODE g_aMapX86_EscF7_High[16*4];
-
-extern PCOPCODE     g_paMapX86_FP_Low[8];
-extern PCOPCODE     g_paMapX86_FP_High[8];
-/** @} */
-
-/** @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 41689)
+++ /trunk/src/VBox/Disassembler/DisasmTablesX64.cpp	(revision 41690)
@@ -22,5 +22,4 @@
 #include <VBox/dis.h>
 #include <VBox/disopcode.h>
-#include "DisasmTables.h"
 #include "DisasmInternal.h"
 
@@ -32,9 +31,9 @@
 
 #ifndef DIS_CORE_ONLY
-static char SZINVALID_OPCODE[] = "Invalid Opcode";
+static char g_szInvalidOpcode[] = "Invalid Opcode";
 #endif
 
 #define INVALID_OPCODE  \
-    OP(SZINVALID_OPCODE,     0,              0,          0,          OP_INVALID, OP_PARM_NONE,       OP_PARM_NONE,   OP_PARM_NONE,   DISOPTYPE_INVALID)
+    OP(g_szInvalidOpcode,    0,              0,          0,          OP_INVALID, OP_PARM_NONE,       OP_PARM_NONE,   OP_PARM_NONE,   DISOPTYPE_INVALID)
 
 #define INVALID_OPCODE_BLOCK \
@@ -58,5 +57,5 @@
 /* Tables for the elegant Intel X64 instruction set */
 
-const OPCODE g_aOneByteMapX64[256] =
+const DISOPCODE g_aOneByteMapX64[256] =
 {
     /* 0 */
Index: /trunk/src/VBox/Disassembler/DisasmTest.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmTest.cpp	(revision 41689)
+++ /trunk/src/VBox/Disassembler/DisasmTest.cpp	(revision 41690)
@@ -1,10 +1,9 @@
+/* $Id$ */
 /** @file
- *
- * VBox disassembler:
- * Test application
+ * VBox disassembler - Test application 
  */
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
Index: /trunk/src/VBox/Disassembler/DisasmTestCore.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmTestCore.cpp	(revision 41689)
+++ /trunk/src/VBox/Disassembler/DisasmTestCore.cpp	(revision 41690)
@@ -1,10 +1,9 @@
+/* $Id$ */
 /** @file
- *
- * VBox disassembler:
- * Test application for core.
+ * VBox disassembler - Test application for core. 
  */
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
