Changeset 41732 in vbox for trunk/src/VBox/VMM

Timestamp:

Jun 14, 2012 11:57:45 PM (13 years ago)

Author:

vboxsync

Message:

DISCPUSTATE::opsize -> cbInstr.

Location:

trunk/src/VBox/VMM

Files:

• VMMAll/EMAll.cpp (modified) (4 diffs)
• VMMAll/PGMAllPool.cpp (modified) (1 diff)
• VMMAll/TRPMAll.cpp (modified) (3 diffs)
• VMMR0/HWSVMR0.cpp (modified) (1 diff)
• VMMR0/HWVMXR0.cpp (modified) (3 diffs)
• VMMR3/CSAM.cpp (modified) (18 diffs)
• VMMR3/DBGFDisas.cpp (modified) (2 diffs)
• VMMR3/EMHwaccm.cpp (modified) (1 diff)
• VMMR3/EMRaw.cpp (modified) (3 diffs)
• VMMR3/PATM.cpp (modified) (62 diffs)
• VMMR3/PATMPatch.cpp (modified) (8 diffs)
• VMMRC/TRPMRC.cpp (modified) (1 diff)
• VMMRC/TRPMRCHandlers.cpp (modified) (3 diffs)
• include/CSAMInternal.h (modified) (1 diff)
• include/PATMInternal.h (modified) (1 diff)
• testcase/tstVMStruct.h (modified) (1 diff)

trunk/src/VBox/VMM/VMMAll/EMAll.cpp

@@ -507 +507 @@
         if (RT_SUCCESS(rc))
         {
-            Assert(cbOp == pDis->opsize);
+            Assert(cbOp == pDis->cbInstr);
             uint32_t cbIgnored;
             rc = emInterpretInstructionCPUOuter(pVCpu, pDis, pRegFrame, pvFault, EMCODETYPE_SUPERVISOR, &cbIgnored);
@@ -561 +561 @@
         if (RT_SUCCESS(rc))
         {
-            Assert(cbOp == pDis->opsize);
+            Assert(cbOp == pDis->cbInstr);
             rc = emInterpretInstructionCPUOuter(pVCpu, pDis, pRegFrame, pvFault, EMCODETYPE_SUPERVISOR, pcbWritten);
             if (RT_SUCCESS(rc))
@@ -617 +617 @@
     VBOXSTRICTRC rc = emInterpretInstructionCPUOuter(pVCpu, pDis, pRegFrame, pvFault, enmCodeType, &cbIgnored);
     if (RT_SUCCESS(rc))
-        pRegFrame->rip += pDis->opsize; /* Move on to the next instruction. */
+        pRegFrame->rip += pDis->cbInstr; /* Move on to the next instruction. */
     return rc;
 #endif
@@ -2688 +2688 @@
     Assert(pvFault == SELMToFlat(pVM, DISSELREG_CS, pRegFrame, (RTGCPTR)pRegFrame->rip));
 
-    pVCpu->em.s.GCPtrInhibitInterrupts = pRegFrame->eip + pDis->opsize;
+    pVCpu->em.s.GCPtrInhibitInterrupts = pRegFrame->eip + pDis->cbInstr;
     VMCPU_FF_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
 

trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp

@@ -936 +936 @@
         pRegFrame->rcx--;
     }
-    pRegFrame->rip += pDis->opsize;
+    pRegFrame->rip += pDis->cbInstr;
 
     LogFlow(("pgmPoolAccessHandlerSTOSD: returns\n"));

trunk/src/VBox/VMM/VMMAll/TRPMAll.cpp

@@ -352 +352 @@
  * @param   pRegFrame   Pointer to the register frame for the trap.
  * @param   iGate       Trap or interrupt gate number
- * @param   opsize      Instruction size (only relevant for software interrupts)
+ * @param   cbInstr     Instruction size (only relevant for software interrupts)
  * @param   enmError    TRPM_TRAP_HAS_ERRORCODE or TRPM_TRAP_NO_ERRORCODE.
  * @param   enmType     TRPM event type
@@ -358 +358 @@
  * @internal
  */
-VMMDECL(int) TRPMForwardTrap(PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t iGate, uint32_t opsize,
+VMMDECL(int) TRPMForwardTrap(PVMCPU pVCpu, PCPUMCTXCORE pRegFrame, uint32_t iGate, uint32_t cbInstr,
                              TRPMERRORCODE enmError, TRPMEVENT enmType, int32_t iOrgTrap)
 {
@@ -639 +639 @@
                     if (enmType == TRPM_SOFTWARE_INT)
                     {
-                        Assert(opsize);
-                        pTrapStack[--idx] = pRegFrame->eip + opsize;    /* return address = next instruction */
+                        Assert(cbInstr);
+                        pTrapStack[--idx] = pRegFrame->eip + cbInstr;    /* return address = next instruction */
                     }
                     else

trunk/src/VBox/VMM/VMMR0/HWSVMR0.cpp

@@ -2987 +2987 @@
             if (RT_SUCCESS(rc) && pDis->pCurInstr->opcode == OP_INVLPG)
             {
-                Assert(cbOp == pDis->opsize);
+                Assert(cbOp == pDis->cbInstr);
                 rc = hmR0svmInterpretInvlPg(pVCpu, pDis, pRegFrame, uASID);
                 if (RT_SUCCESS(rc))

trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

@@ -3553 +3553 @@
 
                     rc = VINF_SUCCESS;
-                    Assert(cbOp == pDis->opsize);
+                    Assert(cbOp == pDis->cbInstr);
                     switch (pDis->pCurInstr->opcode)
                     {
@@ -3563 +3563 @@
                     case OP_STI:
                         pCtx->eflags.Bits.u1IF = 1;
-                        EMSetInhibitInterruptsPC(pVCpu, pCtx->rip + pDis->opsize);
+                        EMSetInhibitInterruptsPC(pVCpu, pCtx->rip + pDis->cbInstr);
                         Assert(VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS));
                         rc2 = VMXWriteVMCS(VMX_VMCS32_GUEST_INTERRUPTIBILITY_STATE,
@@ -3574 +3574 @@
                         fUpdateRIP = false;
                         rc = VINF_EM_HALT;
-                        pCtx->rip += pDis->opsize;
+                        pCtx->rip += pDis->cbInstr;
                         STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitHlt);
                         break;

trunk/src/VBox/VMM/VMMR3/CSAM.cpp

@@ -835 +835 @@
     case OP_CLI:
     {
-        uint32_t     cbInstr = 0;
-        uint32_t     opsize  = pCpu->opsize;
-        bool         fCode32 = pPage->fCode32;
+        uint32_t     cbInstrs   = 0;
+        uint32_t     cbCurInstr = pCpu->cbInstr;
+        bool         fCode32    = pPage->fCode32;
 
         Assert(fCode32);
@@ -848 +848 @@
             DISCPUSTATE  cpu;
 
-            if (cbInstr + opsize >= SIZEOF_NEARJUMP32)
+            if (cbInstrs + cbCurInstr >= SIZEOF_NEARJUMP32)
                 break;
 
-            if (csamIsCodeScanned(pVM, pCurInstrGC + opsize, &pPage) == true)
+            if (csamIsCodeScanned(pVM, pCurInstrGC + cbCurInstr, &pPage) == true)
             {
                 /* We've scanned the next instruction(s) already. This means we've followed a branch that ended up there before -> dangerous!! */
-                PATMR3DetectConflict(pVM, pCurInstrGC, pCurInstrGC + opsize);
+                PATMR3DetectConflict(pVM, pCurInstrGC, pCurInstrGC + cbCurInstr);
                 break;
             }
-            pCurInstrGC += opsize;
-            cbInstr     += opsize;
+            pCurInstrGC += cbCurInstr;
+            cbInstrs    += cbCurInstr;
 
             {   /* Force pCurInstrHC out of scope after we stop using it (page lock!) */
@@ -871 +871 @@
 
                 rc = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, (fCode32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
-                                    &cpu, &opsize, NULL, 0);
+                                    &cpu, &cbCurInstr, NULL, 0);
             }
             AssertRC(rc);
@@ -1018 +1018 @@
         {
             DISCPUSTATE  cpu;
-            uint32_t     opsize;
+            uint32_t     cbInstr;
             int          rc2;
 #ifdef DEBUG
@@ -1054 +1054 @@
 #ifdef DEBUG
                 rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, (fCode32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
-                                     &cpu, &opsize, szOutput, sizeof(szOutput));
+                                     &cpu, &cbInstr, szOutput, sizeof(szOutput));
                 if (RT_SUCCESS(rc2)) Log(("CSAM Call Analysis: %s", szOutput));
 #else
                 rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, (fCode32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
-                                     &cpu, &opsize, NULL, 0);
+                                     &cpu, &cbInstr, NULL, 0);
 #endif
                 STAM_PROFILE_STOP(&pVM->csam.s.StatTimeDisasm, a);
@@ -1067 +1067 @@
                 }
 
-                STAM_COUNTER_ADD(&pVM->csam.s.StatNrBytesRead, opsize);
+                STAM_COUNTER_ADD(&pVM->csam.s.StatNrBytesRead, cbInstr);
 
                 RCPTRTYPE(uint8_t *) addr = 0;
                 PCSAMPAGE pJmpPage = NULL;
 
-                if (PAGE_ADDRESS(pCurInstrGC) != PAGE_ADDRESS(pCurInstrGC + opsize - 1))
+                if (PAGE_ADDRESS(pCurInstrGC) != PAGE_ADDRESS(pCurInstrGC + cbInstr - 1))
                 {
-                    if (!PGMGstIsPagePresent(pVM, pCurInstrGC + opsize - 1))
+                    if (!PGMGstIsPagePresent(pVM, pCurInstrGC + cbInstr - 1))
                     {
                         /// @todo fault in the page
@@ -1081 +1081 @@
                     }
                     //all is fine, let's continue
-                    csamR3CheckPageRecord(pVM, pCurInstrGC + opsize - 1);
+                    csamR3CheckPageRecord(pVM, pCurInstrGC + cbInstr - 1);
                 }
 
@@ -1169 +1169 @@
                 }
                 /* Mark it as scanned. */
-                csamMarkCode(pVM, pPage, pCurInstrGC, opsize, true);
-                pCurInstrGC += opsize;
+                csamMarkCode(pVM, pPage, pCurInstrGC, cbInstr, true);
+                pCurInstrGC += cbInstr;
             } /* for at most 16 instructions */
 next_function:
@@ -1202 +1202 @@
     PCSAMPAGE pPage = (PCSAMPAGE)pUserData;
     int rc = VWRN_CONTINUE_ANALYSIS;
-    uint32_t opsize;
+    uint32_t cbInstr;
     int rc2;
     Assert(pVM->cCpus == 1);
@@ -1267 +1267 @@
 #ifdef DEBUG
             rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, fCode32 ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
-                                 &cpu, &opsize, szOutput, sizeof(szOutput));
+                                 &cpu, &cbInstr, szOutput, sizeof(szOutput));
             if (RT_SUCCESS(rc2)) Log(("CSAM Analysis: %s", szOutput));
 #else
             rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, fCode32 ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
-                                 &cpu, &opsize, NULL, 0);
+                                 &cpu, &cbInstr, NULL, 0);
 #endif
             STAM_PROFILE_STOP(&pVM->csam.s.StatTimeDisasm, a);
@@ -1282 +1282 @@
         }
 
-        STAM_COUNTER_ADD(&pVM->csam.s.StatNrBytesRead, opsize);
-
-        csamMarkCode(pVM, pPage, pCurInstrGC, opsize, true);
+        STAM_COUNTER_ADD(&pVM->csam.s.StatNrBytesRead, cbInstr);
+
+        csamMarkCode(pVM, pPage, pCurInstrGC, cbInstr, true);
 
         RCPTRTYPE(uint8_t *) addr = 0;
         PCSAMPAGE pJmpPage = NULL;
 
-        if (PAGE_ADDRESS(pCurInstrGC) != PAGE_ADDRESS(pCurInstrGC + opsize - 1))
-        {
-            if (!PGMGstIsPagePresent(pVCpu, pCurInstrGC + opsize - 1))
+        if (PAGE_ADDRESS(pCurInstrGC) != PAGE_ADDRESS(pCurInstrGC + cbInstr - 1))
+        {
+            if (!PGMGstIsPagePresent(pVCpu, pCurInstrGC + cbInstr - 1))
             {
                 /// @todo fault in the page
@@ -1299 +1299 @@
             }
             //all is fine, let's continue
-            csamR3CheckPageRecord(pVM, pCurInstrGC + opsize - 1);
+            csamR3CheckPageRecord(pVM, pCurInstrGC + cbInstr - 1);
         }
         /*
@@ -1317 +1317 @@
             &&  pCacheRec->pCallExitRec->cInstrAfterRet < CSAM_MAX_CALLEXIT_RET)
         {
-            pCacheRec->pCallExitRec->pInstrAfterRetGC[pCacheRec->pCallExitRec->cInstrAfterRet] = pCurInstrGC + opsize;
+            pCacheRec->pCallExitRec->pInstrAfterRetGC[pCacheRec->pCallExitRec->cInstrAfterRet] = pCurInstrGC + cbInstr;
             pCacheRec->pCallExitRec->cInstrAfterRet++;
         }
@@ -1463 +1463 @@
             goto done;
         }
-        pCurInstrGC += opsize;
+        pCurInstrGC += cbInstr;
     }
 done:
@@ -2181 +2181 @@
  * @param   pPage       Patch structure pointer
  * @param   pInstr      Instruction pointer
- * @param   opsize      Instruction size
+ * @param   cbInstr      Instruction size
  * @param   fScanned    Mark as scanned or not
  */
-static void csamMarkCode(PVM pVM, PCSAMPAGE pPage, RTRCPTR pInstr, uint32_t opsize, bool fScanned)
-{
-    LogFlow(("csamMarkCodeAsScanned %RRv opsize=%d\n", pInstr, opsize));
+static void csamMarkCode(PVM pVM, PCSAMPAGE pPage, RTRCPTR pInstr, uint32_t cbInstr, bool fScanned)
+{
+    LogFlow(("csamMarkCodeAsScanned %RRv cbInstr=%d\n", pInstr, cbInstr));
     CSAMMarkPage(pVM, pInstr, fScanned);
 
@@ -2198 +2198 @@
         if (ASMBitTest(pPage->pBitmap, pInstr & PAGE_OFFSET_MASK) == 0)
         {
-            pPage->uSize += opsize;
+            pPage->uSize += cbInstr;
             STAM_COUNTER_ADD(&pVM->csam.s.StatNrInstr, 1);
         }
@@ -2220 +2220 @@
  * @param   pVM         The VM to operate on.
  * @param   pInstr      Instruction pointer
- * @param   opsize      Instruction size
+ * @param   cbInstr      Instruction size
  * @param   fScanned    Mark as scanned or not
  */
-VMMR3DECL(int) CSAMR3MarkCode(PVM pVM, RTRCPTR pInstr, uint32_t opsize, bool fScanned)
+VMMR3DECL(int) CSAMR3MarkCode(PVM pVM, RTRCPTR pInstr, uint32_t cbInstr, bool fScanned)
 {
     PCSAMPAGE pPage = 0;
@@ -2236 +2236 @@
     }
 
-    Log(("CSAMR3MarkCode: %RRv size=%d fScanned=%d\n", pInstr, opsize, fScanned));
-    csamMarkCode(pVM, pPage, pInstr, opsize, fScanned);
+    Log(("CSAMR3MarkCode: %RRv size=%d fScanned=%d\n", pInstr, cbInstr, fScanned));
+    csamMarkCode(pVM, pPage, pInstr, cbInstr, fScanned);
     return VINF_SUCCESS;
 }

trunk/src/VBox/VMM/VMMR3/DBGFDisas.cpp

@@ -500 +500 @@
     else
     {
-        uint32_t cbBits = State.Cpu.opsize;
+        uint32_t cbBits = State.Cpu.cbInstr;
         uint8_t *pau8Bits = (uint8_t *)alloca(cbBits);
         rc = dbgfR3DisasInstrRead(&State.Cpu, pau8Bits, GCPtr, cbBits);
@@ -542 +542 @@
 
     if (pcbInstr)
-        *pcbInstr = State.Cpu.opsize;
+        *pcbInstr = State.Cpu.cbInstr;
 
     dbgfR3DisasInstrDone(&State);

trunk/src/VBox/VMM/VMMR3/EMHwaccm.cpp

@@ -354 +354 @@
         if (IOM_SUCCESS(rcStrict))
         {
-            pCtx->rip += Cpu.opsize;
+            pCtx->rip += Cpu.cbInstr;
             STAM_PROFILE_STOP(&pVCpu->em.s.StatIOEmu, a);
             return VBOXSTRICTRC_TODO(rcStrict);

trunk/src/VBox/VMM/VMMR3/EMRaw.cpp

@@ -475 +475 @@
         if (IOM_SUCCESS(rcStrict))
         {
-            pCtx->rip += Cpu.opsize;
+            pCtx->rip += Cpu.cbInstr;
             STAM_PROFILE_STOP(&pVCpu->em.s.StatIOEmu, a);
             return VBOXSTRICTRC_TODO(rcStrict);
@@ -1048 +1048 @@
                 case OP_CLI:
                     pCtx->eflags.u32 &= ~X86_EFL_IF;
-                    Assert(Cpu.opsize == 1);
-                    pCtx->rip += Cpu.opsize;
+                    Assert(Cpu.cbInstr == 1);
+                    pCtx->rip += Cpu.cbInstr;
                     STAM_PROFILE_STOP(&pVCpu->em.s.StatPrivEmu, a);
                     return VINF_EM_RESCHEDULE_REM; /* must go to the recompiler now! */
@@ -1055 +1055 @@
                 case OP_STI:
                     pCtx->eflags.u32 |= X86_EFL_IF;
-                    EMSetInhibitInterruptsPC(pVCpu, pCtx->rip + Cpu.opsize);
-                    Assert(Cpu.opsize == 1);
-                    pCtx->rip += Cpu.opsize;
+                    EMSetInhibitInterruptsPC(pVCpu, pCtx->rip + Cpu.cbInstr);
+                    Assert(Cpu.cbInstr == 1);
+                    pCtx->rip += Cpu.cbInstr;
                     STAM_PROFILE_STOP(&pVCpu->em.s.StatPrivEmu, a);
                     return VINF_SUCCESS;

trunk/src/VBox/VMM/VMMR3/PATM.cpp

@@ -1414 +1414 @@
         {
             if (   pCurInstrGC > pPatch->pPrivInstrGC
-                && pCurInstrGC + pCpu->opsize < pPatch->pPrivInstrGC + SIZEOF_NEARJUMP32) /* hardcoded patch jump size; cbPatchJump is still zero */
+                && pCurInstrGC + pCpu->cbInstr < pPatch->pPrivInstrGC + SIZEOF_NEARJUMP32) /* hardcoded patch jump size; cbPatchJump is still zero */
             {
                 Log(("Dangerous unconditional jump ends in our generated patch jump!! (%x vs %x)\n", pCurInstrGC, pPatch->pPrivInstrGC));
@@ -1449 +1449 @@
     }
 
-    pPatch->cbPatchBlockSize += pCpu->opsize;
+    pPatch->cbPatchBlockSize += pCpu->cbInstr;
 
     /* Illegal instruction -> end of analysis phase for this code block */
@@ -1514 +1514 @@
     {
         /* The end marker for this kind of patch is any instruction at a location outside our patch jump. */
-        Log(("End of block at %RRv size %d\n", pCurInstrGC, pCpu->opsize));
+        Log(("End of block at %RRv size %d\n", pCurInstrGC, pCpu->cbInstr));
         return VINF_SUCCESS;
     }
@@ -1591 +1591 @@
     }
 
-    pPatch->cbPatchBlockSize += pCpu->opsize;
+    pPatch->cbPatchBlockSize += pCpu->cbInstr;
 
     /* Illegal instruction -> end of analysis phase for this code block */
@@ -1681 +1681 @@
     else
     if (pCurInstrGC > pPatch->pInstrGCHighest)
-        pPatch->pInstrGCHighest = pCurInstrGC + pCpu->opsize;
+        pPatch->pInstrGCHighest = pCurInstrGC + pCpu->cbInstr;
 
     /* Illegal instruction -> end of recompile phase for this code block. */
@@ -1790 +1790 @@
             pPatch->flags   |= PATMFL_INHIBIT_IRQS | PATMFL_GENERATE_JUMPTOGUEST;
             fInhibitIRQInstr = true;
-            pNextInstrGC     = pCurInstrGC + pCpu->opsize;
+            pNextInstrGC     = pCurInstrGC + pCpu->cbInstr;
             Log(("Inhibit irqs for instruction OP_STI at %RRv\n", pCurInstrGC));
         }
@@ -1798 +1798 @@
         {
             DISCPUSTATE cpu = *pCpu;
-            unsigned    opsize;
+            unsigned    cbInstr;
             int         disret;
             RCPTRTYPE(uint8_t *) pReturnInstrGC;
@@ -1804 +1804 @@
             pPatch->flags |= PATMFL_FOUND_PATCHEND;
 
-            pNextInstrGC = pCurInstrGC + pCpu->opsize;
+            pNextInstrGC = pCurInstrGC + pCpu->cbInstr;
             {   /* Force pNextInstrHC out of scope after using it */
                 uint8_t *pNextInstrHC = PATMGCVirtToHCVirt(pVM, pCacheRec, pNextInstrGC);
@@ -1814 +1814 @@
 
                 // Disassemble the next instruction
-                disret = patmR3DisInstr(pVM, pPatch, pNextInstrGC, pNextInstrHC, PATMREAD_ORGCODE, &cpu, &opsize);
+                disret = patmR3DisInstr(pVM, pPatch, pNextInstrGC, pNextInstrHC, PATMREAD_ORGCODE, &cpu, &cbInstr);
             }
             if (disret == false)
@@ -1821 +1821 @@
                 return VERR_PATCHING_REFUSED;
             }
-            pReturnInstrGC = pNextInstrGC + opsize;
+            pReturnInstrGC = pNextInstrGC + cbInstr;
 
             if (   (pPatch->flags & (PATMFL_DUPLICATE_FUNCTION))
@@ -1848 +1848 @@
     case OP_POPF:
     {
-        bool fGenerateJmpBack = (pCurInstrGC + pCpu->opsize - pInstrGC >= SIZEOF_NEARJUMP32);
+        bool fGenerateJmpBack = (pCurInstrGC + pCpu->cbInstr - pInstrGC >= SIZEOF_NEARJUMP32);
 
         /* Not an exit point for IDT handler or function replacement patches */
@@ -1855 +1855 @@
             fGenerateJmpBack = false;
 
-        rc = patmPatchGenPopf(pVM, pPatch, pCurInstrGC + pCpu->opsize, !!(pCpu->prefix & DISPREFIX_OPSIZE), fGenerateJmpBack);
+        rc = patmPatchGenPopf(pVM, pPatch, pCurInstrGC + pCpu->cbInstr, !!(pCpu->prefix & DISPREFIX_OPSIZE), fGenerateJmpBack);
         if (RT_SUCCESS(rc))
         {
@@ -2024 +2024 @@
     {
         int     rc2;
-        RTRCPTR pNextInstrGC = pCurInstrGC + pCpu->opsize;
+        RTRCPTR pNextInstrGC = pCurInstrGC + pCpu->cbInstr;
 
         pPatch->flags &= ~PATMFL_INHIBIT_IRQS;
@@ -2048 +2048 @@
         // If single instruction patch, we've copied enough instructions *and* the current instruction is not a relative jump
         if (    (pPatch->flags & PATMFL_CHECK_SIZE)
-             &&  pCurInstrGC + pCpu->opsize - pInstrGC >= SIZEOF_NEARJUMP32
+             &&  pCurInstrGC + pCpu->cbInstr - pInstrGC >= SIZEOF_NEARJUMP32
              &&  !(pCpu->pCurInstr->optype & DISOPTYPE_RELATIVE_CONTROLFLOW)
              &&  !(pPatch->flags & PATMFL_RECOMPILE_NEXT) /* do not do this when the next instruction *must* be executed! */
            )
         {
-            RTRCPTR pNextInstrGC = pCurInstrGC + pCpu->opsize;
+            RTRCPTR pNextInstrGC = pCurInstrGC + pCpu->cbInstr;
 
             // The end marker for this kind of patch is any instruction at a location outside our patch jump
-            Log(("patmRecompileCallback: end found for single instruction patch at %RRv opsize %d\n", pNextInstrGC, pCpu->opsize));
+            Log(("patmRecompileCallback: end found for single instruction patch at %RRv cbInstr %d\n", pNextInstrGC, pCpu->cbInstr));
 
             rc = patmPatchGenJumpToGuest(pVM, pPatch, pNextInstrGC);
@@ -2179 +2179 @@
     PPATCHINFO pPatch = (PPATCHINFO)pCacheRec->pPatch;
     int rc = VWRN_CONTINUE_ANALYSIS;
-    uint32_t opsize, delta;
+    uint32_t cbInstr, delta;
     R3PTRTYPE(uint8_t *) pCurInstrHC = 0;
     bool disret;
@@ -2199 +2199 @@
 
         disret = patmR3DisInstrToStr(pVM, pPatch, pCurInstrGC, pCurInstrHC, PATMREAD_RAWCODE,
-                                     &cpu, &opsize, szOutput, sizeof(szOutput));
+                                     &cpu, &cbInstr, szOutput, sizeof(szOutput));
         if (PATMIsPatchGCAddr(pVM, pCurInstrGC))
         {
@@ -2283 +2283 @@
             rc = VWRN_CONTINUE_ANALYSIS;
         }
-        pCurInstrGC += opsize;
+        pCurInstrGC += cbInstr;
     }
 end:
@@ -2349 +2349 @@
     PPATCHINFO pPatch = (PPATCHINFO)pCacheRec->pPatch;
     int rc = VWRN_CONTINUE_ANALYSIS;
-    uint32_t opsize;
+    uint32_t cbInstr;
     R3PTRTYPE(uint8_t *) pCurInstrHC = 0;
     bool disret;
@@ -2366 +2366 @@
 #ifdef LOG_ENABLED
         disret = patmR3DisInstrToStr(pVM, pPatch, pCurInstrGC, pCurInstrHC, PATMREAD_ORGCODE,
-                                     &cpu, &opsize, szOutput, sizeof(szOutput));
+                                     &cpu, &cbInstr, szOutput, sizeof(szOutput));
         Log(("Recompile: %s", szOutput));
 #else
-        disret = patmR3DisInstr(pVM, pPatch, pCurInstrGC, pCurInstrHC, PATMREAD_ORGCODE, &cpu, &opsize);
+        disret = patmR3DisInstr(pVM, pPatch, pCurInstrGC, pCurInstrHC, PATMREAD_ORGCODE, &cpu, &cbInstr);
 #endif
         if (disret == false)
@@ -2392 +2392 @@
                 uint32_t    opsizenext;
                 uint8_t *pNextInstrHC;
-                RTRCPTR  pNextInstrGC = pCurInstrGC + opsize;
+                RTRCPTR  pNextInstrGC = pCurInstrGC + cbInstr;
 
                 Log(("patmRecompileCodeStream: irqs inhibited by instruction %RRv\n", pNextInstrGC));
@@ -2473 +2473 @@
                 Log(("patmRecompileCodeStream continue passed conditional jump\n"));
                 /* First we need to finish this linear code stream until the next exit point. */
-                rc = patmRecompileCodeStream(pVM, pInstrGC, pCurInstrGC+opsize, pfnPATMR3Recompile, pCacheRec);
+                rc = patmRecompileCodeStream(pVM, pInstrGC, pCurInstrGC+cbInstr, pfnPATMR3Recompile, pCacheRec);
                 if (RT_FAILURE(rc))
                 {
@@ -2522 +2522 @@
             goto end;
         }
-        pCurInstrGC += opsize;
+        pCurInstrGC += cbInstr;
     }
 end:
@@ -2631 +2631 @@
     DISCPUSTATE cpu;
     char szOutput[256];
-    uint32_t opsize, i = 0;
+    uint32_t cbInstr, i = 0;
     bool disret;
 
@@ -2637 +2637 @@
     {
         disret = patmR3DisInstrToStr(pVM, pPatch, pPatch->pPrivInstrGC + i, NULL, PATMREAD_ORGCODE,
-                                     &cpu, &opsize, szOutput, sizeof(szOutput));
+                                     &cpu, &cbInstr, szOutput, sizeof(szOutput));
         if (disret == false)
             break;
 
         Log(("Org patch jump: %s", szOutput));
-        Assert(opsize);
-        i += opsize;
+        Assert(cbInstr);
+        i += cbInstr;
     }
 #endif
@@ -2656 +2656 @@
         {
             disret = patmR3DisInstrToStr(pVM, pPatch, pPatch->pPrivInstrGC + i, NULL, PATMREAD_ORGCODE,
-                                         &cpu, &opsize, szOutput, sizeof(szOutput));
+                                         &cpu, &cbInstr, szOutput, sizeof(szOutput));
             if (disret == false)
                 break;
 
             Log(("Org instr: %s", szOutput));
-            Assert(opsize);
-            i += opsize;
+            Assert(cbInstr);
+            i += cbInstr;
         }
     }
@@ -2963 +2963 @@
     bool disret;
     DISCPUSTATE cpuPush, cpuJmp;
-    uint32_t opsize;
+    uint32_t cbInstr;
     RTRCPTR  pCurInstrGC = pInstrGC;
     uint8_t *pCurInstrHC, *pInstrHC;
@@ -2976 +2976 @@
      * condition here and only patch the common entypoint once.
      */
-    disret = patmR3DisInstr(pVM, pPatch, pCurInstrGC, pCurInstrHC, PATMREAD_ORGCODE, &cpuPush, &opsize);
+    disret = patmR3DisInstr(pVM, pPatch, pCurInstrGC, pCurInstrHC, PATMREAD_ORGCODE, &cpuPush, &cbInstr);
     Assert(disret);
     if (disret && cpuPush.pCurInstr->opcode == OP_PUSH)
@@ -2982 +2982 @@
         RTRCPTR  pJmpInstrGC;
         int      rc;
-        pCurInstrGC += opsize;
-
-        disret = patmR3DisInstr(pVM, pPatch, pCurInstrGC, pCurInstrHC, PATMREAD_ORGCODE, &cpuJmp, &opsize);
+        pCurInstrGC += cbInstr;
+
+        disret = patmR3DisInstr(pVM, pPatch, pCurInstrGC, pCurInstrHC, PATMREAD_ORGCODE, &cpuJmp, &cbInstr);
         if (   disret
             && cpuJmp.pCurInstr->opcode == OP_JMP
@@ -3569 +3569 @@
     RTRCPTR       pTargetGC;
     PPATMPATCHREC pPatchFunction;
-    uint32_t      opsize;
+    uint32_t      cbInstr;
     bool          disret;
 
     Assert(pPatch->flags & PATMFL_REPLACE_FUNCTION_CALL);
-    Assert((pCpu->pCurInstr->opcode == OP_CALL || pCpu->pCurInstr->opcode == OP_JMP) && pCpu->opsize == SIZEOF_NEARJUMP32);
-
-    if ((pCpu->pCurInstr->opcode != OP_CALL && pCpu->pCurInstr->opcode != OP_JMP) || pCpu->opsize != SIZEOF_NEARJUMP32)
+    Assert((pCpu->pCurInstr->opcode == OP_CALL || pCpu->pCurInstr->opcode == OP_JMP) && pCpu->cbInstr == SIZEOF_NEARJUMP32);
+
+    if ((pCpu->pCurInstr->opcode != OP_CALL && pCpu->pCurInstr->opcode != OP_JMP) || pCpu->cbInstr != SIZEOF_NEARJUMP32)
     {
         rc = VERR_PATCHING_REFUSED;
@@ -3604 +3604 @@
                 break;
 
-            disret = patmR3DisInstr(pVM, pPatch, pTargetGC, pTmpInstrHC, PATMREAD_ORGCODE, &cpu, &opsize);
+            disret = patmR3DisInstr(pVM, pPatch, pTargetGC, pTmpInstrHC, PATMREAD_ORGCODE, &cpu, &cbInstr);
             if (disret == false || cpu.pCurInstr->opcode != OP_JMP)
                 break;
@@ -3639 +3639 @@
     /* Lowest and highest address for write monitoring. */
     pPatch->pInstrGCLowest  = pInstrGC;
-    pPatch->pInstrGCHighest = pInstrGC + pCpu->opsize;
+    pPatch->pInstrGCHighest = pInstrGC + pCpu->cbInstr;
     PATM_LOG_ORG_PATCH_INSTR(pVM, pPatch, "Call");
 
@@ -3684 +3684 @@
 
     /* Add relocation record for cached data access. */
-    if (patmPatchAddReloc32(pVM, pPatch, &pPB[pCpu->opsize - sizeof(RTRCPTR)], FIXUP_ABSOLUTE, pPatch->pPrivInstrGC, pVM->patm.s.mmio.pCachedData) != VINF_SUCCESS)
+    if (patmPatchAddReloc32(pVM, pPatch, &pPB[pCpu->cbInstr - sizeof(RTRCPTR)], FIXUP_ABSOLUTE, pPatch->pPrivInstrGC, pVM->patm.s.mmio.pCachedData) != VINF_SUCCESS)
     {
         Log(("Relocation failed for cached mmio address!!\n"));
@@ -3698 +3698 @@
 
     /* Replace address with that of the cached item. */
-    rc = PGMPhysSimpleDirtyWriteGCPtr(VMMGetCpu0(pVM), pInstrGC + pCpu->opsize - sizeof(RTRCPTR), &pVM->patm.s.mmio.pCachedData, sizeof(RTRCPTR));
+    rc = PGMPhysSimpleDirtyWriteGCPtr(VMMGetCpu0(pVM), pInstrGC + pCpu->cbInstr - sizeof(RTRCPTR), &pVM->patm.s.mmio.pCachedData, sizeof(RTRCPTR));
     AssertRC(rc);
     if (RT_FAILURE(rc))
@@ -3733 +3733 @@
 {
     DISCPUSTATE   cpu;
-    uint32_t      opsize;
+    uint32_t      cbInstr;
     bool          disret;
     uint8_t      *pInstrHC;
@@ -3745 +3745 @@
     /* Disassemble mmio instruction. */
     disret = patmR3DisInstrNoStrOpMode(pVM, pPatch, pInstrGC, pInstrHC, PATMREAD_ORGCODE,
-                                       &cpu, &opsize);
+                                       &cpu, &cbInstr);
     if (disret == false)
     {
@@ -3752 +3752 @@
     }
 
-    AssertMsg(opsize <= MAX_INSTR_SIZE, ("privileged instruction too big %d!!\n", opsize));
-    if (opsize > MAX_INSTR_SIZE)
+    AssertMsg(cbInstr <= MAX_INSTR_SIZE, ("privileged instruction too big %d!!\n", cbInstr));
+    if (cbInstr > MAX_INSTR_SIZE)
         return VERR_PATCHING_REFUSED;
     if (cpu.param2.fUse != DISUSE_DISPLACEMENT32)
@@ -3759 +3759 @@
 
     /* Add relocation record for cached data access. */
-    if (patmPatchAddReloc32(pVM, pPatch, &pInstrHC[cpu.opsize - sizeof(RTRCPTR)], FIXUP_ABSOLUTE) != VINF_SUCCESS)
+    if (patmPatchAddReloc32(pVM, pPatch, &pInstrHC[cpu.cbInstr - sizeof(RTRCPTR)], FIXUP_ABSOLUTE) != VINF_SUCCESS)
     {
         Log(("Relocation failed for cached mmio address!!\n"));
@@ -3765 +3765 @@
     }
     /* Replace address with that of the cached item. */
-    *(RTRCPTR *)&pInstrHC[cpu.opsize - sizeof(RTRCPTR)] = pVM->patm.s.mmio.pCachedData;
+    *(RTRCPTR *)&pInstrHC[cpu.cbInstr - sizeof(RTRCPTR)] = pVM->patm.s.mmio.pCachedData;
 
     /* Lowest and highest address for write monitoring. */
     pPatch->pInstrGCLowest  = pInstrGC;
-    pPatch->pInstrGCHighest = pInstrGC + cpu.opsize;
+    pPatch->pInstrGCHighest = pInstrGC + cpu.cbInstr;
 
     PATM_LOG_ORG_PATCH_INSTR(pVM, pPatch, "MMIO");
@@ -3859 +3859 @@
     /* Lowest and highest address for write monitoring. */
     pPatch->pInstrGCLowest  = pInstrGC;
-    pPatch->pInstrGCHighest = pInstrGC + pCpu->opsize;
+    pPatch->pInstrGCHighest = pInstrGC + pCpu->cbInstr;
 
     pPatch->uState = PATCH_ENABLED;
@@ -3921 +3921 @@
             goto failure;
 
-        Assert(pCpu->opsize == SIZEOF_NEARJUMP32 || pCpu->opsize == SIZEOF_NEAR_COND_JUMP32);
-        if (pCpu->opsize != SIZEOF_NEARJUMP32 && pCpu->opsize != SIZEOF_NEAR_COND_JUMP32)
+        Assert(pCpu->cbInstr == SIZEOF_NEARJUMP32 || pCpu->cbInstr == SIZEOF_NEAR_COND_JUMP32);
+        if (pCpu->cbInstr != SIZEOF_NEARJUMP32 && pCpu->cbInstr != SIZEOF_NEAR_COND_JUMP32)
             goto failure;
 
-        if (PAGE_ADDRESS(pInstrGC) != PAGE_ADDRESS(pInstrGC + pCpu->opsize))
+        if (PAGE_ADDRESS(pInstrGC) != PAGE_ADDRESS(pInstrGC + pCpu->cbInstr))
         {
             STAM_COUNTER_INC(&pVM->patm.s.StatPageBoundaryCrossed);
@@ -3940 +3940 @@
 
     // make a copy of the guest code bytes that will be overwritten
-    Assert(pCpu->opsize <= sizeof(pPatch->aPrivInstr));
-    Assert(pCpu->opsize >= SIZEOF_NEARJUMP32);
-    pPatch->cbPatchJump = pCpu->opsize;
+    Assert(pCpu->cbInstr <= sizeof(pPatch->aPrivInstr));
+    Assert(pCpu->cbInstr >= SIZEOF_NEARJUMP32);
+    pPatch->cbPatchJump = pCpu->cbInstr;
 
     rc = PGMPhysSimpleReadGCPtr(VMMGetCpu0(pVM), pPatch->aPrivInstr, pPatch->pPrivInstrGC, pPatch->cbPatchJump);
@@ -3952 +3952 @@
      * references the target instruction in the conflict patch.
      */
-    RTRCPTR pJmpDest = PATMR3GuestGCPtrToPatchGCPtr(pVM, pInstrGC + pCpu->opsize + (int32_t)pCpu->param1.parval);
-
-    AssertMsg(pJmpDest, ("PATMR3GuestGCPtrToPatchGCPtr failed for %RRv\n", pInstrGC + pCpu->opsize + (int32_t)pCpu->param1.parval));
+    RTRCPTR pJmpDest = PATMR3GuestGCPtrToPatchGCPtr(pVM, pInstrGC + pCpu->cbInstr + (int32_t)pCpu->param1.parval);
+
+    AssertMsg(pJmpDest, ("PATMR3GuestGCPtrToPatchGCPtr failed for %RRv\n", pInstrGC + pCpu->cbInstr + (int32_t)pCpu->param1.parval));
     pPatch->pPatchJumpDestGC = pJmpDest;
 
@@ -4026 +4026 @@
     DISCPUSTATE cpu;
     R3PTRTYPE(uint8_t *) pInstrHC;
-    uint32_t opsize;
+    uint32_t cbInstr;
     PPATMPATCHREC pPatchRec;
     PCPUMCTX pCtx = 0;
@@ -4242 +4242 @@
     }
 
-    disret = patmR3DisInstrNoStrOpMode(pVM, &pPatchRec->patch, pInstrGC, NULL, PATMREAD_ORGCODE, &cpu, &opsize);
+    disret = patmR3DisInstrNoStrOpMode(pVM, &pPatchRec->patch, pInstrGC, NULL, PATMREAD_ORGCODE, &cpu, &cbInstr);
     if (disret == false)
     {
@@ -4249 +4249 @@
     }
 
-    AssertMsg(opsize <= MAX_INSTR_SIZE, ("privileged instruction too big %d!!\n", opsize));
-    if (opsize > MAX_INSTR_SIZE)
+    AssertMsg(cbInstr <= MAX_INSTR_SIZE, ("privileged instruction too big %d!!\n", cbInstr));
+    if (cbInstr > MAX_INSTR_SIZE)
         return VERR_PATCHING_REFUSED;
 
-    pPatchRec->patch.cbPrivInstr = opsize;
+    pPatchRec->patch.cbPrivInstr = cbInstr;
     pPatchRec->patch.opcode      = cpu.pCurInstr->opcode;
 
@@ -4308 +4308 @@
             pPatchRec->patch.flags |= PATMFL_IDTHANDLER;    /* we treat a sysenter handler as an IDT handler */
 
-        rc = patmIdtHandler(pVM, pInstrGC, opsize, pPatchRec, &cacheRec);
+        rc = patmIdtHandler(pVM, pInstrGC, cbInstr, pPatchRec, &cacheRec);
 #ifdef VBOX_WITH_STATISTICS
         if (    rc == VINF_SUCCESS
@@ -4384 +4384 @@
         case OP_CLI:
             Log(("PATMR3InstallPatch %s %RRv code32=%d\n", patmGetInstructionString(pPatchRec->patch.opcode, pPatchRec->patch.flags), pInstrGC, (flags & PATMFL_CODE32) ? 1 : 0));
-            rc = PATMR3PatchBlock(pVM, pInstrGC, pInstrHC, cpu.pCurInstr->opcode, opsize, pPatchRec);
+            rc = PATMR3PatchBlock(pVM, pInstrGC, pInstrHC, cpu.pCurInstr->opcode, cbInstr, pPatchRec);
             break;
 
@@ -4493 +4493 @@
         DISCPUSTATE cpu;
         bool        disret;
-        uint32_t    opsize;
-
-        disret = patmR3DisInstr(pVM, pPatch, pInstrGC, pInstrHC, PATMREAD_ORGCODE | PATMREAD_NOCHECK, &cpu, &opsize);
+        uint32_t    cbInstr;
+
+        disret = patmR3DisInstr(pVM, pPatch, pInstrGC, pInstrHC, PATMREAD_ORGCODE | PATMREAD_NOCHECK, &cpu, &cbInstr);
         PGMPhysReleasePageMappingLock(pVM, &Lock);
         if (disret)
-            return opsize;
+            return cbInstr;
     }
     return 0;
@@ -5187 +5187 @@
     DISCPUSTATE          cpu;
     R3PTRTYPE(uint8_t *) pInstrHC;
-    uint32_t             opsize;
+    uint32_t             cbInstr;
     bool                 disret;
     int                  rc;
@@ -5193 +5193 @@
     RT_ZERO(patch);
     pInstrHC = PATMGCVirtToHCVirt(pVM, &patch, pInstrGC);
-    disret = patmR3DisInstr(pVM, &patch, pInstrGC, pInstrHC, PATMREAD_ORGCODE, &cpu, &opsize);
+    disret = patmR3DisInstr(pVM, &patch, pInstrGC, pInstrHC, PATMREAD_ORGCODE, &cpu, &cbInstr);
     /*
      * If it's a 5 byte relative jump, then we can work around the problem by replacing the 32 bits relative offset
@@ -5335 +5335 @@
                         DISCPUSTATE cpu;
                         char szOutput[256];
-                        uint32_t opsize;
+                        uint32_t cbInstr;
                         uint32_t i = 0;
                         bool disret;
@@ -5341 +5341 @@
                         {
                             disret = patmR3DisInstrToStr(pVM, pPatch, pPatch->pPrivInstrGC + i, NULL, PATMREAD_ORGCODE,
-                                                         &cpu, &opsize, szOutput, sizeof(szOutput));
+                                                         &cpu, &cbInstr, szOutput, sizeof(szOutput));
                             Log(("Renewed patch instr: %s", szOutput));
-                            i += opsize;
+                            i += cbInstr;
                         }
                     }
@@ -6020 +6020 @@
         {
             if (RT_SUCCESS(rc))
-                cbDirty += CpuOld.opsize;
+                cbDirty += CpuOld.cbInstr;
             else
             if (!cbDirty)
@@ -6040 +6040 @@
         pPatchToGuestRec = NULL;
 
-        pCurPatchInstrGC += CpuOld.opsize;
-        cbDirty          += CpuOld.opsize;
+        pCurPatchInstrGC += CpuOld.cbInstr;
+        cbDirty          += CpuOld.cbInstr;
 
         /* Let's see if there's another dirty instruction right after. */
@@ -6086 +6086 @@
             /* If the instruction is completely harmless (which implies a 1:1 patch copy). */
             if (    rc == VINF_SUCCESS
-                &&  CpuNew.opsize <= cbLeft /* must still fit */
+                &&  CpuNew.cbInstr <= cbLeft /* must still fit */
                 &&  fValidInstr
                )
@@ -6098 +6098 @@
 
                 /* Copy the new instruction. */
-                rc = PGMPhysSimpleReadGCPtr(VMMGetCpu0(pVM), pCurPatchInstrHC, pCurInstrGC, CpuNew.opsize);
+                rc = PGMPhysSimpleReadGCPtr(VMMGetCpu0(pVM), pCurPatchInstrHC, pCurInstrGC, CpuNew.cbInstr);
                 AssertRC(rc);
 
@@ -6119 +6119 @@
                 break;
             }
-            pCurInstrGC      += CpuNew.opsize;
-            pCurPatchInstrHC += CpuNew.opsize;
-            pCurPatchInstrGC += CpuNew.opsize;
-            cbLeft           -= CpuNew.opsize;
+            pCurInstrGC      += CpuNew.cbInstr;
+            pCurPatchInstrHC += CpuNew.cbInstr;
+            pCurPatchInstrGC += CpuNew.cbInstr;
+            cbLeft           -= CpuNew.cbInstr;
 
             /* Check if we expanded a complex guest instruction into a patch stream (e.g. call) */
@@ -6402 +6402 @@
         DISCPUSTATE cpu;
         bool        disret;
-        uint32_t    opsize;
+        uint32_t    cbInstr;
         PATMP2GLOOKUPREC cacheRec;
         RT_ZERO(cacheRec);
@@ -6408 +6408 @@
 
         disret = patmR3DisInstr(pVM, &pPatch->patch, pNewEip, PATMGCVirtToHCVirt(pVM, &cacheRec, pNewEip), PATMREAD_RAWCODE,
-                                &cpu, &opsize);
+                                &cpu, &cbInstr);
         if (cacheRec.Lock.pvMap)
             PGMPhysReleasePageMappingLock(pVM, &cacheRec.Lock);
@@ -6441 +6441 @@
         DISCPUSTATE cpu;
         bool        disret;
-        uint32_t    opsize;
+        uint32_t    cbInstr;
         PATMP2GLOOKUPREC cacheRec;
         RT_ZERO(cacheRec);
@@ -6447 +6447 @@
 
         disret = patmR3DisInstr(pVM, &pPatch->patch, pNewEip, PATMGCVirtToHCVirt(pVM, &cacheRec, pNewEip), PATMREAD_ORGCODE,
-                                &cpu, &opsize);
+                                &cpu, &cbInstr);
         if (cacheRec.Lock.pvMap)
             PGMPhysReleasePageMappingLock(pVM, &cacheRec.Lock);
@@ -6455 +6455 @@
             cpu.mode = (pPatch->patch.flags & PATMFL_CODE32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
             disret = patmR3DisInstr(pVM, &pPatch->patch, pNewEip, PATMGCVirtToHCVirt(pVM, &cacheRec, pNewEip), PATMREAD_RAWCODE,
-                                    &cpu, &opsize);
+                                    &cpu, &cbInstr);
             if (cacheRec.Lock.pvMap)
                 PGMPhysReleasePageMappingLock(pVM, &cacheRec.Lock);

trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp

@@ -421 +421 @@
     PATCHGEN_PROLOG(pVM, pPatch);
 
-    uint32_t const cbInstrShutUpGcc = pCpu->opsize;
+    uint32_t const cbInstrShutUpGcc = pCpu->cbInstr;
     rc = patmPatchReadBytes(pVM, pPB, pCurInstrGC, cbInstrShutUpGcc);
     AssertRC(rc);
@@ -712 +712 @@
             i++;    //skip segment prefix
 
-        rc = patmPatchReadBytes(pVM, &pPB[offset], (RTRCPTR)((RTGCUINTPTR32)pCurInstrGC + i), pCpu->opsize - i);
+        rc = patmPatchReadBytes(pVM, &pPB[offset], (RTRCPTR)((RTGCUINTPTR32)pCurInstrGC + i), pCpu->cbInstr - i);
         AssertRCReturn(rc, rc);
-        offset += (pCpu->opsize - i);
+        offset += (pCpu->cbInstr - i);
     }
     else
@@ -725 +725 @@
 
         /* Relative call to patch code (patch to patch -> no fixup). */
-        Log(("PatchGenCall from %RRv (next=%RRv) to %RRv\n", pCurInstrGC, pCurInstrGC + pCpu->opsize, pTargetGC));
+        Log(("PatchGenCall from %RRv (next=%RRv) to %RRv\n", pCurInstrGC, pCurInstrGC + pCpu->cbInstr, pTargetGC));
 
         /* We push it onto the stack here, so the guest's context isn't ruined when this happens to cause
@@ -749 +749 @@
     /* 3: Generate code to lookup address in our local cache; call hypervisor PATM code if it can't be located. */
     PATCHGEN_PROLOG_NODEF(pVM, pPatch);
-    callInfo.pReturnGC      = pCurInstrGC + pCpu->opsize;
+    callInfo.pReturnGC      = pCurInstrGC + pCpu->cbInstr;
     callInfo.pTargetGC      = (fIndirect) ? 0xDEADBEEF : pTargetGC;
     size = patmPatchGenCode(pVM, pPatch, pPB, (fIndirect) ? &PATMCallIndirectRecord : &PATMCallRecord, 0, false, &callInfo);
@@ -809 +809 @@
         i++;    //skip segment prefix
 
-    rc = patmPatchReadBytes(pVM, &pPB[offset], (RTRCPTR)((RTGCUINTPTR32)pCurInstrGC + i), pCpu->opsize - i);
+    rc = patmPatchReadBytes(pVM, &pPB[offset], (RTRCPTR)((RTGCUINTPTR32)pCurInstrGC + i), pCpu->cbInstr - i);
     AssertRCReturn(rc, rc);
-    offset += (pCpu->opsize - i);
+    offset += (pCpu->cbInstr - i);
 
     /* align this block properly to make sure the jump table will not be misaligned. */
@@ -826 +826 @@
     /* 3: Generate code to lookup address in our local cache; call hypervisor PATM code if it can't be located. */
     PATCHGEN_PROLOG_NODEF(pVM, pPatch);
-    callInfo.pReturnGC      = pCurInstrGC + pCpu->opsize;
+    callInfo.pReturnGC      = pCurInstrGC + pCpu->cbInstr;
     callInfo.pTargetGC      = 0xDEADBEEF;
     size = patmPatchGenCode(pVM, pPatch, pPB, &PATMJumpIndirectRecord, 0, false, &callInfo);
@@ -1375 +1375 @@
             i++;    //skip segment prefix
 
-        rc = patmPatchReadBytes(pVM, &pPB[offset], (RTRCPTR)((RTGCUINTPTR32)pCurInstrGC + i), pCpu->opsize - i);
+        rc = patmPatchReadBytes(pVM, &pPB[offset], (RTRCPTR)((RTGCUINTPTR32)pCurInstrGC + i), pCpu->cbInstr - i);
         AssertRCReturn(rc, rc);
-        offset += (pCpu->opsize - i);
+        offset += (pCpu->cbInstr - i);
 
         pPB[offset++] = 0x66;              // mov       ax, CPUMCTX.tr/ldtr
@@ -1469 +1469 @@
     if (pCpu->prefix == DISPREFIX_SEG)
         i++;    //skip segment prefix
-    rc = patmPatchReadBytes(pVM, &pPB[offset], (RTRCPTR)((RTGCUINTPTR32)pCurInstrGC + i), pCpu->opsize - i);
+    rc = patmPatchReadBytes(pVM, &pPB[offset], (RTRCPTR)((RTGCUINTPTR32)pCurInstrGC + i), pCpu->cbInstr - i);
     AssertRCReturn(rc, rc);
-    offset += (pCpu->opsize - i);
+    offset += (pCpu->cbInstr - i);
 
     pPB[offset++] = 0x66;              // mov       ax, CPUMCTX.gdtr.limit

trunk/src/VBox/VMM/VMMRC/TRPMRC.cpp

@@ -187 +187 @@
         {
             /* Just ignore the write. */
-            pRegFrame->eip += Cpu.opsize;
+            pRegFrame->eip += Cpu.cbInstr;
             return VINF_SUCCESS;
         }

trunk/src/VBox/VMM/VMMRC/TRPMRCHandlers.cpp

@@ -754 +754 @@
                 }
             }
-            rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->param1.parval, pCpu->opsize, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
+            rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->param1.parval, pCpu->cbInstr, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
             if (RT_SUCCESS(rc) && rc != VINF_EM_RAW_GUEST_TRAP)
                 return trpmGCExitTrap(pVM, pVCpu, VINF_SUCCESS, pRegFrame);
@@ -775 +775 @@
                 break;
 
-            pRegFrame->eip += pCpu->opsize;
+            pRegFrame->eip += pCpu->cbInstr;
             return trpmGCExitTrap(pVM, pVCpu, VINF_EM_HALT, pRegFrame);
 
@@ -846 +846 @@
         {
             Assert(pCpu->param1.fUse & DISUSE_IMMEDIATE8);
-            rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->param1.parval, pCpu->opsize, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
+            rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->param1.parval, pCpu->cbInstr, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
             if (RT_SUCCESS(rc) && rc != VINF_EM_RAW_GUEST_TRAP)
                 return trpmGCExitTrap(pVM, pVCpu, VINF_SUCCESS, pRegFrame);

trunk/src/VBox/VMM/include/CSAMInternal.h

@@ -271 +271 @@
     }
 #ifdef IN_RC
-    return (RTRCPTR)((uint8_t *)pBranchInstrGC + pCpu->opsize + disp);
+    return (RTRCPTR)((uint8_t *)pBranchInstrGC + pCpu->cbInstr + disp);
 #else
-    return pBranchInstrGC + pCpu->opsize + disp;
+    return pBranchInstrGC + pCpu->cbInstr + disp;
 #endif
 }

trunk/src/VBox/VMM/include/PATMInternal.h

@@ -781 +781 @@
     }
 #ifdef IN_RC
-    return (RTRCPTR)((uint8_t *)pBranchInstrGC + pCpu->opsize + disp);
+    return (RTRCPTR)((uint8_t *)pBranchInstrGC + pCpu->cbInstr + disp);
 #else
-    return pBranchInstrGC + pCpu->opsize + disp;
+    return pBranchInstrGC + pCpu->cbInstr + disp;
 #endif
 }

trunk/src/VBox/VMM/testcase/tstVMStruct.h

@@ -1404 +1404 @@
     GEN_CHECK_OFF(DISCPUSTATE, fFilter);
     GEN_CHECK_OFF(DISCPUSTATE, uInstrAddr);
-#endif    
+    GEN_CHECK_OFF(DISCPUSTATE, abInstr);
+    GEN_CHECK_OFF(DISCPUSTATE, pvUser);
+#endif