Index: /trunk/include/VBox/dis.h
===================================================================
--- /trunk/include/VBox/dis.h	(revision 41735)
+++ /trunk/include/VBox/dis.h	(revision 41736)
@@ -528,5 +528,5 @@
     /* off: 0x06c (108) */
     /** The CPU mode (DISCPUMODE). */
-    uint8_t         mode;
+    uint8_t         uCpuMode;
     /** The addressing mode (DISCPUMODE). */
     uint8_t         uAddrMode;
Index: /trunk/src/VBox/Disassembler/DisasmCore.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41735)
+++ /trunk/src/VBox/Disassembler/DisasmCore.cpp	(revision 41736)
@@ -291,5 +291,5 @@
     RT_BZERO(pCpu, RT_OFFSETOF(DISCPUSTATE, pvUser2));
 
-    pCpu->mode              = enmCpuMode;
+    pCpu->uCpuMode          = enmCpuMode;
     if (enmCpuMode == DISCPUMODE_64BIT)
     {
@@ -360,5 +360,5 @@
                 pCpu->idxSegPrefix = (DISSELREG)(paOneByteMap[codebyte].param1 - OP_PARM_REG_SEG_START);
                 /* Segment prefixes for CS, DS, ES and SS are ignored in long mode. */
-                if (   pCpu->mode != DISCPUMODE_64BIT
+                if (   pCpu->uCpuMode != DISCPUMODE_64BIT
                     || pCpu->idxSegPrefix >= DISSELREG_FS)
                 {
@@ -377,8 +377,8 @@
             case OP_ADDRSIZE:
                 pCpu->fPrefix |= DISPREFIX_ADDRSIZE;
-                if (pCpu->mode == DISCPUMODE_16BIT)
+                if (pCpu->uCpuMode == DISCPUMODE_16BIT)
                     pCpu->uAddrMode = DISCPUMODE_32BIT;
                 else
-                if (pCpu->mode == DISCPUMODE_32BIT)
+                if (pCpu->uCpuMode == DISCPUMODE_32BIT)
                     pCpu->uAddrMode = DISCPUMODE_16BIT;
                 else
@@ -391,5 +391,5 @@
             case OP_OPSIZE:
                 pCpu->fPrefix |= DISPREFIX_OPSIZE;
-                if (pCpu->mode == DISCPUMODE_16BIT)
+                if (pCpu->uCpuMode == DISCPUMODE_16BIT)
                     pCpu->uOpMode = DISCPUMODE_32BIT;
                 else
@@ -411,5 +411,5 @@
 
             case OP_REX:
-                Assert(pCpu->mode == DISCPUMODE_64BIT);
+                Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
                 /* REX prefix byte */
                 pCpu->fPrefix   |= DISPREFIX_REX;
@@ -476,5 +476,5 @@
 
     /* Correct the operand size if the instruction is marked as forced or default 64 bits */
-    if (pCpu->mode == DISCPUMODE_64BIT)
+    if (pCpu->uCpuMode == DISCPUMODE_64BIT)
     {
         if (pOp->optype & DISOPTYPE_FORCED_64_OP_SIZE)
@@ -489,5 +489,5 @@
     {
         /* Forced 32 bits operand size for certain instructions (mov crx, mov drx). */
-        Assert(pCpu->mode != DISCPUMODE_64BIT);
+        Assert(pCpu->uCpuMode != DISCPUMODE_64BIT);
         pCpu->uOpMode = DISCPUMODE_32BIT;
     }
@@ -554,5 +554,5 @@
 
     /* Correct the operand size if the instruction is marked as forced or default 64 bits */
-    if (pCpu->mode == DISCPUMODE_64BIT)
+    if (pCpu->uCpuMode == DISCPUMODE_64BIT)
     {
         /* Note: redundant, but just in case this ever changes */
@@ -805,5 +805,5 @@
             {
                 /* 32 bits displacement */
-                if (pCpu->mode != DISCPUMODE_64BIT)
+                if (pCpu->uCpuMode != DISCPUMODE_64BIT)
                 {
                     pParam->fUse |= DISUSE_DISPLACEMENT32;
@@ -1082,5 +1082,5 @@
     if (pCpu->fPrefix & DISPREFIX_REX)
     {
-        Assert(pCpu->mode == DISCPUMODE_64BIT);
+        Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
 
         /* REX.R extends the Reg field. */
@@ -1128,5 +1128,5 @@
     if (pCpu->fPrefix & DISPREFIX_REX)
     {
-        Assert(pCpu->mode == DISCPUMODE_64BIT);
+        Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
 
         /* REX.R extends the Reg field. */
@@ -1761,5 +1761,5 @@
                 /* Cancel prefix changes. */
                 pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
-                pCpu->uOpMode  = pCpu->mode;
+                pCpu->uOpMode  = pCpu->uCpuMode;
             }
             break;
@@ -1828,5 +1828,5 @@
                 /* Cancel prefix changes. */
                 pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
-                pCpu->uOpMode  = pCpu->mode;
+                pCpu->uOpMode  = pCpu->uCpuMode;
             }
         }
@@ -1879,5 +1879,5 @@
             /* Cancel prefix changes. */
             pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
-            pCpu->uOpMode  = pCpu->mode;
+            pCpu->uOpMode  = pCpu->uCpuMode;
         }
     }
Index: /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp	(revision 41735)
+++ /trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp	(revision 41736)
@@ -800,5 +800,5 @@
 
                             case DISUSE_IMMEDIATE16:
-                                if (    pCpu->mode != pCpu->uOpMode
+                                if (    pCpu->uCpuMode != pCpu->uOpMode
                                     ||  (   (fFlags & DIS_FMT_FLAGS_STRICT)
                                          && (   (int8_t)pParam->parval == (int16_t)pParam->parval
@@ -823,5 +823,5 @@
 
                             case DISUSE_IMMEDIATE32:
-                                if (    pCpu->uOpMode != (pCpu->mode == DISCPUMODE_16BIT ? DISCPUMODE_16BIT : DISCPUMODE_32BIT) /* not perfect */
+                                if (    pCpu->uOpMode != (pCpu->uCpuMode == DISCPUMODE_16BIT ? DISCPUMODE_16BIT : DISCPUMODE_32BIT) /* not perfect */
                                     ||  (   (fFlags & DIS_FMT_FLAGS_STRICT)
                                          && (   (int8_t)pParam->parval == (int32_t)pParam->parval
@@ -908,7 +908,7 @@
 
                         RTUINTPTR uTrgAddr = pCpu->uInstrAddr + pCpu->cbInstr + offDisplacement;
-                        if (pCpu->mode == DISCPUMODE_16BIT)
+                        if (pCpu->uCpuMode == DISCPUMODE_16BIT)
                             PUT_NUM_16(uTrgAddr);
-                        else if (pCpu->mode == DISCPUMODE_32BIT)
+                        else if (pCpu->uCpuMode == DISCPUMODE_32BIT)
                             PUT_NUM_32(uTrgAddr);
                         else
@@ -1273,5 +1273,5 @@
             case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
             case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
-                f = pCpu->mode == DISCPUMODE_64BIT ? DISPREFIX_REX : 0;
+                f = pCpu->uCpuMode == DISCPUMODE_64BIT ? DISPREFIX_REX : 0;
                 break;
 
@@ -1291,5 +1291,5 @@
     {
         /* no effective address which it may apply to. */
-        Assert((pCpu->fPrefix & DISPREFIX_SEG) || pCpu->mode == DISCPUMODE_64BIT);
+        Assert((pCpu->fPrefix & DISPREFIX_SEG) || pCpu->uCpuMode == DISCPUMODE_64BIT);
         if (    !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.fUse)
             &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.fUse)
@@ -1517,5 +1517,5 @@
     if (    pCpu->pCurInstr->opcode == OP_MOVZX
         &&  pCpu->bOpCode == 0xB7
-        &&  (pCpu->mode == DISCPUMODE_16BIT) != !!(fPrefixes & DISPREFIX_OPSIZE))
+        &&  (pCpu->uCpuMode == DISCPUMODE_16BIT) != !!(fPrefixes & DISPREFIX_OPSIZE))
         return true;
 
Index: /trunk/src/VBox/Disassembler/DisasmReg.cpp
===================================================================
--- /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41735)
+++ /trunk/src/VBox/Disassembler/DisasmReg.cpp	(revision 41736)
@@ -587,8 +587,8 @@
         if (pParam->fUse & DISUSE_DISPLACEMENT8)
         {
-            if (pCpu->mode == DISCPUMODE_32BIT)
+            if (pCpu->uCpuMode == DISCPUMODE_32BIT)
                 pParamVal->val.val32 += (int32_t)pParam->uDisp.i8;
             else
-            if (pCpu->mode == DISCPUMODE_64BIT)
+            if (pCpu->uCpuMode == DISCPUMODE_64BIT)
                 pParamVal->val.val64 += (int64_t)pParam->uDisp.i8;
             else
@@ -598,8 +598,8 @@
         if (pParam->fUse & DISUSE_DISPLACEMENT16)
         {
-            if (pCpu->mode == DISCPUMODE_32BIT)
+            if (pCpu->uCpuMode == DISCPUMODE_32BIT)
                 pParamVal->val.val32 += (int32_t)pParam->uDisp.i16;
             else
-            if (pCpu->mode == DISCPUMODE_64BIT)
+            if (pCpu->uCpuMode == DISCPUMODE_64BIT)
                 pParamVal->val.val64 += (int64_t)pParam->uDisp.i16;
             else
@@ -609,5 +609,5 @@
         if (pParam->fUse & DISUSE_DISPLACEMENT32)
         {
-            if (pCpu->mode == DISCPUMODE_32BIT)
+            if (pCpu->uCpuMode == DISCPUMODE_32BIT)
                 pParamVal->val.val32 += pParam->uDisp.i32;
             else
@@ -617,5 +617,5 @@
         if (pParam->fUse & DISUSE_DISPLACEMENT64)
         {
-            Assert(pCpu->mode == DISCPUMODE_64BIT);
+            Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
             pParamVal->val.val64 += pParam->uDisp.i64;
         }
@@ -623,5 +623,5 @@
         if (pParam->fUse & DISUSE_RIPDISPLACEMENT32)
         {
-            Assert(pCpu->mode == DISCPUMODE_64BIT);
+            Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
             /* Relative to the RIP of the next instruction. */
             pParamVal->val.val64 += pParam->uDisp.i32 + pCtx->rip + pCpu->cbInstr;
Index: /trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp
===================================================================
--- /trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp	(revision 41735)
+++ /trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp	(revision 41736)
@@ -154,8 +154,9 @@
 
 
-static bool MyDisBlock(PDISCPUSTATE pCpu, RTHCUINTPTR pvCodeBlock, int32_t cbMax, RTUINTPTR off,
+static bool MyDisBlock(DISCPUMODE enmCpuMode, RTHCUINTPTR pvCodeBlock, int32_t cbMax, RTUINTPTR off,
                        RTUINTPTR uNearAddr, RTUINTPTR uSearchAddr)
 {
-    int32_t i = 0;
+    DISCPUSTATE Cpu;
+    int32_t     i = 0;
     while (i < cbMax)
     {
@@ -164,7 +165,7 @@
         char        szOutput[256];
         unsigned    cbInstr;
-        int rc = DISInstrWithReader(uNearAddr + i, (DISCPUMODE)pCpu->mode,
+        int rc = DISInstrWithReader(uNearAddr + i, enmCpuMode,
                                     MyReadBytes, (uint8_t *)pvCodeBlock - (uintptr_t)uNearAddr,
-                                    pCpu, &cbInstr);
+                                    &Cpu, &cbInstr);
         RTAssertSetMayPanic(fMayPanic);
         RTAssertSetQuiet(fQuiet);
@@ -172,5 +173,5 @@
             return false;
 
-        DISFormatYasmEx(pCpu, szOutput, sizeof(szOutput),
+        DISFormatYasmEx(&Cpu, szOutput, sizeof(szOutput),
                         DIS_FMT_FLAGS_RELATIVE_BRANCH | DIS_FMT_FLAGS_BYTES_RIGHT | DIS_FMT_FLAGS_ADDR_LEFT  | DIS_FMT_FLAGS_BYTES_SPACED,
                         MyGetSymbol, NULL);
@@ -244,13 +245,11 @@
     if (NearSym.Addr - NearSym.aSyms[0].Value < 0x10000)
     {
-        DISCPUSTATE Cpu;
-        memset(&Cpu, 0, sizeof(Cpu));
 #ifdef RT_ARCH_X86 /** @todo select according to the module type. */
-        Cpu.mode = DISCPUMODE_32BIT;
+        DISCPUMODE enmDisCpuMode = DISCPUMODE_32BIT;
 #else
-        Cpu.mode = DISCPUMODE_64BIT;
+        DISCPUMODE enmDisCpuMode = DISCPUMODE_64BIT;
 #endif
         uint8_t *pbCode = (uint8_t *)g_pvBits + (NearSym.aSyms[0].Value - g_uLoadAddr);
-        MyDisBlock(&Cpu, (uintptr_t)pbCode,
+        MyDisBlock(enmDisCpuMode, (uintptr_t)pbCode,
                    RT_MAX(NearSym.aSyms[1].Value - NearSym.aSyms[0].Value, 0x20000),
                    NearSym.aSyms[0].Value - (RTUINTPTR)pbCode,
Index: /trunk/src/VBox/Runtime/testcase/tstLdrDisasmTest.cpp
===================================================================
--- /trunk/src/VBox/Runtime/testcase/tstLdrDisasmTest.cpp	(revision 41735)
+++ /trunk/src/VBox/Runtime/testcase/tstLdrDisasmTest.cpp	(revision 41736)
@@ -122,5 +122,4 @@
 
     memset(&Cpu, 0, sizeof(Cpu));
-    Cpu.mode = DISCPUMODE_32BIT;
 
 #define DISAS_AND_CHECK(cbInstr, enmOp) \
Index: /trunk/src/VBox/Runtime/testcase/tstLdrObjR0.cpp
===================================================================
--- /trunk/src/VBox/Runtime/testcase/tstLdrObjR0.cpp	(revision 41735)
+++ /trunk/src/VBox/Runtime/testcase/tstLdrObjR0.cpp	(revision 41736)
@@ -96,5 +96,4 @@
 
     memset(&Cpu, 0, sizeof(Cpu));
-    Cpu.mode = DISCPUMODE_32BIT;
 
     DISInstr((void *)(uintptr_t)SomeExportFunction3, DISCPUMODE_32BIT, &Cpu, &cb);
Index: /trunk/src/VBox/VMM/VMMAll/EMAll.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/EMAll.cpp	(revision 41735)
+++ /trunk/src/VBox/VMM/VMMAll/EMAll.cpp	(revision 41736)
@@ -364,5 +364,5 @@
         State.GCPtr = NIL_RTGCPTR;
     }
-    return DISInstrWithReader(InstrGC, (DISCPUMODE)pDis->mode, emReadBytes, &State, pDis, pOpsize);
+    return DISInstrWithReader(InstrGC, (DISCPUMODE)pDis->uCpuMode, emReadBytes, &State, pDis, pOpsize);
 }
 
@@ -377,5 +377,5 @@
     State.GCPtr = InstrGC;
 
-    return DISInstrWithReader(InstrGC, (DISCPUMODE)pDis->mode, emReadBytes, &State, pDis, pOpsize);
+    return DISInstrWithReader(InstrGC, (DISCPUMODE)pDis->uCpuMode, emReadBytes, &State, pDis, pOpsize);
 }
 
@@ -503,5 +503,5 @@
         uint32_t     cbOp;
         PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
-        pDis->mode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
+        pDis->uCpuMode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
         rc = emDisCoreOne(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
         if (RT_SUCCESS(rc))
@@ -557,5 +557,5 @@
         uint32_t     cbOp;
         PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
-        pDis->mode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
+        pDis->uCpuMode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
         rc = emDisCoreOne(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
         if (RT_SUCCESS(rc))
@@ -1009,5 +1009,5 @@
 static int emInterpretPop(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
 {
-    Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
+    Assert(pDis->uCpuMode != DISCPUMODE_64BIT);    /** @todo check */
     DISQPVPARAMVAL param1;
     NOREF(pvFault);
@@ -1561,5 +1561,5 @@
             }
 #ifdef LOG_ENABLED
-            if (pDis->mode == DISCPUMODE_64BIT)
+            if (pDis->uCpuMode == DISCPUMODE_64BIT)
                 LogFlow(("EMInterpretInstruction at %RGv: OP_MOV %RGv <- %RX64 (%d) &val64=%RHv\n", (RTGCPTR)pRegFrame->rip, pDest, val64, param2.size, &val64));
             else
@@ -1624,5 +1624,5 @@
             }
 #ifdef LOG_ENABLED
-            if (pDis->mode == DISCPUMODE_64BIT)
+            if (pDis->uCpuMode == DISCPUMODE_64BIT)
                 LogFlow(("EMInterpretInstruction: OP_MOV %RGv -> %RX64 (%d)\n", pSrc, val64, param1.size));
             else
@@ -1870,5 +1870,5 @@
 static int emInterpretCmpXchg8b(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
 {
-    Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
+    Assert(pDis->uCpuMode != DISCPUMODE_64BIT);    /** @todo check */
     DISQPVPARAMVAL param1;
     NOREF(pvFault);
@@ -1924,5 +1924,5 @@
 static int emInterpretXAdd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
 {
-    Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
+    Assert(pDis->uCpuMode != DISCPUMODE_64BIT);    /** @todo check */
     DISQPVPARAMVAL param1;
     void *pvParamReg2;
Index: /trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp	(revision 41735)
+++ /trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp	(revision 41736)
@@ -107,5 +107,5 @@
             rc = EMInterpretDisasOne(pVM, pVCpu, pRegFrame, pDis, &cbOp);
             if (     RT_SUCCESS(rc)
-                &&   pDis->mode == DISCPUMODE_32BIT  /** @todo why does this matter? */
+                &&   pDis->uCpuMode == DISCPUMODE_32BIT  /** @todo why does this matter? */
                 &&  !(pDis->fPrefix & (DISPREFIX_REPNE | DISPREFIX_REP | DISPREFIX_SEG)))
             {
Index: /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp	(revision 41735)
+++ /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp	(revision 41736)
@@ -797,5 +797,5 @@
                )
             {
-                Assert(pDis->mode == DISCPUMODE_64BIT);
+                Assert(pDis->uCpuMode == DISCPUMODE_64BIT);
 
                 Log(("pgmPoolMonitorIsReused: OP_STOSQ\n"));
@@ -890,5 +890,5 @@
     NOREF(pVM);
 
-    Assert(pDis->mode == DISCPUMODE_32BIT || pDis->mode == DISCPUMODE_64BIT);
+    Assert(pDis->uCpuMode == DISCPUMODE_32BIT || pDis->uCpuMode == DISCPUMODE_64BIT);
     Assert(pRegFrame->rcx <= 0x20);
 
@@ -1198,10 +1198,10 @@
         if (    pDis->pCurInstr->opcode == OP_STOSWD
             &&  !pRegFrame->eflags.Bits.u1DF
-            &&  pDis->uOpMode == pDis->mode
-            &&  pDis->uAddrMode == pDis->mode)
+            &&  pDis->uOpMode == pDis->uCpuMode
+            &&  pDis->uAddrMode == pDis->uCpuMode)
         {
             bool fValidStosd = false;
 
-            if (    pDis->mode == DISCPUMODE_32BIT
+            if (    pDis->uCpuMode == DISCPUMODE_32BIT
                 &&  pDis->fPrefix == DISPREFIX_REP
                 &&  pRegFrame->ecx <= 0x20
@@ -1215,5 +1215,5 @@
             }
             else
-            if (    pDis->mode == DISCPUMODE_64BIT
+            if (    pDis->uCpuMode == DISCPUMODE_64BIT
                 &&  pDis->fPrefix == (DISPREFIX_REP | DISPREFIX_REX)
                 &&  pRegFrame->rcx <= 0x20
Index: /trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp	(revision 41735)
+++ /trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp	(revision 41736)
@@ -2982,5 +2982,5 @@
             PDISCPUSTATE pDis = &pVCpu->hwaccm.s.DisState;
 
-            pDis->mode = enmMode;
+            pDis->uCpuMode = enmMode;
             rc = EMInterpretDisasOneEx(pVM, pVCpu, pbCode, pRegFrame, pDis, &cbOp);
             Assert(RT_FAILURE(rc) || pDis->pCurInstr->opcode == OP_INVLPG);
Index: /trunk/src/VBox/VMM/VMMR3/PATM.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/PATM.cpp	(revision 41735)
+++ /trunk/src/VBox/VMM/VMMR3/PATM.cpp	(revision 41736)
@@ -3189,5 +3189,4 @@
     PPATCHINFO pPatch = &pPatchRec->patch;
     int rc = VERR_PATCHING_REFUSED;
-    DISCPUSTATE cpu;
     uint32_t orgOffsetPatchMem = ~0;
     bool fInserted;
@@ -3215,6 +3214,4 @@
     pPatch->pPatchBlockOffset = pVM->patm.s.offPatchMem;
     pPatch->uCurPatchOffset   = 0;
-
-    cpu.mode = (pPatch->flags & PATMFL_CODE32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
 
     /* Note: Set the PATM interrupt flag here; it was cleared before the patched call. (!!!) */
@@ -6453,5 +6450,4 @@
         if (disret && (cpu.pCurInstr->opcode == OP_SYSEXIT || cpu.pCurInstr->opcode == OP_HLT || cpu.pCurInstr->opcode == OP_INT3))
         {
-            cpu.mode = (pPatch->patch.flags & PATMFL_CODE32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
             disret = patmR3DisInstr(pVM, &pPatch->patch, pNewEip, PATMGCVirtToHCVirt(pVM, &cacheRec, pNewEip), PATMREAD_RAWCODE,
                                     &cpu, &cbInstr);
Index: /trunk/src/VBox/VMM/VMMRC/PATMRC.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMRC/PATMRC.cpp	(revision 41735)
+++ /trunk/src/VBox/VMM/VMMRC/PATMRC.cpp	(revision 41736)
@@ -510,6 +510,6 @@
             }
 
-            cpu.mode = SELMGetCpuModeFromSelector(VMMGetCpu0(pVM), pRegFrame->eflags, pRegFrame->cs, 0);
-            if (cpu.mode != DISCPUMODE_32BIT)
+            DISCPUMODE enmCpuMode = SELMGetCpuModeFromSelector(VMMGetCpu0(pVM), pRegFrame->eflags, pRegFrame->cs, 0);
+            if (enmCpuMode != DISCPUMODE_32BIT)
             {
                 AssertFailed();
@@ -523,5 +523,5 @@
             rc = VBOXSTRICTRC_TODO(rcStrict);
 #else
-            rc = DISInstr(&pRec->patch.aPrivInstr[0], (DISCPUMODE)cpu.mode, &cpu, &cbOp);
+            rc = DISInstr(&pRec->patch.aPrivInstr[0], enmCpuMode, &cpu, &cbOp);
             if (RT_FAILURE(rc))
             {