VirtualBox

Changeset 41663 in vbox


Ignore:
Timestamp:
Jun 12, 2012 8:40:22 AM (12 years ago)
Author:
vboxsync
Message:

DIS,EM,PGM,PATM: Changed the size and scale members of OP_PARAMETER from uint32_t to uint8_t, saving 4 more bytes.

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/dis.h

    r41662 r41663  
    383383        uint32_t    u8;
    384384    } uDisp;
    385     uint32_t        size;
    386385    int32_t         param;
    387386
    … …  
    410409
    411410    /** 2, 4 or 8. */
    412     uint32_t scale;
     411    uint8_t         scale;
     412    /** Parameter size. */
     413    uint8_t         cb;
    413414
    414415#ifndef DIS_SEPARATE_FORMATTER

  • trunk/src/VBox/Disassembler/DisasmCore.cpp

    r41662 r41663  
    394394    {
    395395        size += pCpu->pfnDisasmFnTable[pOp->idxParse1](lpszCodeBlock, pOp, &pCpu->param1, pCpu);
    396         if (fFiltered == false) pCpu->param1.size = DISGetParamSize(pCpu, &pCpu->param1);
     396        if (fFiltered == false) pCpu->param1.cb = DISGetParamSize(pCpu, &pCpu->param1);
    397397    }
    398398
    … …  
    400400    {
    401401        size += pCpu->pfnDisasmFnTable[pOp->idxParse2](lpszCodeBlock+size, pOp, &pCpu->param2, pCpu);
    402         if (fFiltered == false) pCpu->param2.size = DISGetParamSize(pCpu, &pCpu->param2);
     402        if (fFiltered == false) pCpu->param2.cb = DISGetParamSize(pCpu, &pCpu->param2);
    403403    }
    404404
    … …  
    406406    {
    407407        size += pCpu->pfnDisasmFnTable[pOp->idxParse3](lpszCodeBlock+size, pOp, &pCpu->param3, pCpu);
    408         if (fFiltered == false) pCpu->param3.size = DISGetParamSize(pCpu, &pCpu->param3);
     408        if (fFiltered == false) pCpu->param3.cb = DISGetParamSize(pCpu, &pCpu->param3);
    409409    }
    410410    // else simple one byte instruction
    … …  
    11411141    pParam->parval = DISReadByte(pCpu, lpszCodeBlock);
    11421142    pParam->flags |= USE_IMMEDIATE8;
    1143     pParam->size   = sizeof(uint8_t);
     1143    pParam->cb     = sizeof(uint8_t);
    11441144
    11451145    disasmAddStringF1(pParam->szParam, "0%02Xh", (uint32_t)pParam->parval);
    … …  
    11621162        pParam->parval = (uint32_t)(int8_t)DISReadByte(pCpu, lpszCodeBlock);
    11631163        pParam->flags |= USE_IMMEDIATE32_SX8;
    1164         pParam->size   = sizeof(uint32_t);
     1164        pParam->cb     = sizeof(uint32_t);
    11651165        disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
    11661166    }
    … …  
    11701170        pParam->parval = (uint64_t)(int8_t)DISReadByte(pCpu, lpszCodeBlock);
    11711171        pParam->flags |= USE_IMMEDIATE64_SX8;
    1172         pParam->size   = sizeof(uint64_t);
     1172        pParam->cb     = sizeof(uint64_t);
    11731173        disasmAddStringF1(pParam->szParam, "0%016RX64h", pParam->parval);
    11741174    }
    … …  
    11771177        pParam->parval = (uint16_t)(int8_t)DISReadByte(pCpu, lpszCodeBlock);
    11781178        pParam->flags |= USE_IMMEDIATE16_SX8;
    1179         pParam->size   = sizeof(uint16_t);
     1179        pParam->cb     = sizeof(uint16_t);
    11801180        disasmAddStringF1(pParam->szParam, "0%04Xh", (uint16_t)pParam->parval);
    11811181    }
    … …  
    11961196    pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
    11971197    pParam->flags |= USE_IMMEDIATE16;
    1198     pParam->size   = sizeof(uint16_t);
     1198    pParam->cb     = sizeof(uint16_t);
    11991199
    12001200    disasmAddStringF1(pParam->szParam, "0%04Xh", (uint16_t)pParam->parval);
    … …  
    12151215    pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
    12161216    pParam->flags |= USE_IMMEDIATE32;
    1217     pParam->size   = sizeof(uint32_t);
     1217    pParam->cb     = sizeof(uint32_t);
    12181218
    12191219    disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
    … …  
    12341234    pParam->parval = DISReadQWord(pCpu, lpszCodeBlock);
    12351235    pParam->flags |= USE_IMMEDIATE64;
    1236     pParam->size   = sizeof(uint64_t);
     1236    pParam->cb     = sizeof(uint64_t);
    12371237
    12381238    disasmAddStringF2(pParam->szParam, "0%08X%08Xh",
    … …  
    12561256        pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
    12571257        pParam->flags |= USE_IMMEDIATE32;
    1258         pParam->size   = sizeof(uint32_t);
     1258        pParam->cb     = sizeof(uint32_t);
    12591259
    12601260        disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
    … …  
    12661266        pParam->parval = DISReadQWord(pCpu, lpszCodeBlock);
    12671267        pParam->flags |= USE_IMMEDIATE64;
    1268         pParam->size   = sizeof(uint64_t);
     1268        pParam->cb     = sizeof(uint64_t);
    12691269
    12701270        disasmAddStringF1(pParam->szParam, "0%RX64h", pParam->parval);
    … …  
    12751275        pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
    12761276        pParam->flags |= USE_IMMEDIATE16;
    1277         pParam->size   = sizeof(uint16_t);
     1277        pParam->cb     = sizeof(uint16_t);
    12781278
    12791279        disasmAddStringF1(pParam->szParam, "0%04Xh", (uint32_t)pParam->parval);
    … …  
    13021302        pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
    13031303        pParam->flags |= USE_IMMEDIATE16;
    1304         pParam->size   = sizeof(uint16_t);
     1304        pParam->cb     = sizeof(uint16_t);
    13051305
    13061306        disasmAddStringF1(pParam->szParam, "0%04Xh", (uint32_t)pParam->parval);
    … …  
    13141314            pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, lpszCodeBlock);
    13151315            pParam->flags |= USE_IMMEDIATE64;
    1316             pParam->size   = sizeof(uint64_t);
     1316            pParam->cb     = sizeof(uint64_t);
    13171317            disasmAddStringF1(pParam->szParam, "0%RX64h", pParam->parval);
    13181318        }
    … …  
    13211321            pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
    13221322            pParam->flags |= USE_IMMEDIATE32;
    1323             pParam->size   = sizeof(uint32_t);
     1323            pParam->cb     = sizeof(uint32_t);
    13241324            disasmAddStringF1(pParam->szParam, "0%08Xh", (uint32_t)pParam->parval);
    13251325        }
    … …  
    13461346    pParam->parval = DISReadByte(pCpu, lpszCodeBlock);
    13471347    pParam->flags |= USE_IMMEDIATE8_REL;
    1348     pParam->size   = sizeof(uint8_t);
     1348    pParam->cb     = sizeof(uint8_t);
    13491349
    13501350    disasmAddStringF1(pParam->szParam, " (0%02Xh)", (uint32_t)pParam->parval);
    … …  
    13691369        pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
    13701370        pParam->flags |= USE_IMMEDIATE32_REL;
    1371         pParam->size   = sizeof(int32_t);
     1371        pParam->cb     = sizeof(int32_t);
    13721372
    13731373        disasmAddStringF1(pParam->szParam, " (0%08Xh)", (uint32_t)pParam->parval);
    … …  
    13801380        pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, lpszCodeBlock);
    13811381        pParam->flags |= USE_IMMEDIATE64_REL;
    1382         pParam->size   = sizeof(int64_t);
     1382        pParam->cb     = sizeof(int64_t);
    13831383
    13841384        disasmAddStringF1(pParam->szParam, " (0%RX64h)", pParam->parval);
    … …  
    13891389        pParam->parval = DISReadWord(pCpu, lpszCodeBlock);
    13901390        pParam->flags |= USE_IMMEDIATE16_REL;
    1391         pParam->size   = sizeof(int16_t);
     1391        pParam->cb     = sizeof(int16_t);
    13921392
    13931393        disasmAddStringF1(pParam->szParam, " (0%04Xh)", (uint32_t)pParam->parval);
    … …  
    14181418            *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, lpszCodeBlock+sizeof(uint32_t));
    14191419            pParam->flags  |= USE_IMMEDIATE_ADDR_16_32;
    1420             pParam->size   = sizeof(uint16_t) + sizeof(uint32_t);
     1420            pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
    14211421
    14221422            disasmAddStringF2(pParam->szParam, "0%04X:0%08Xh", (uint32_t)(pParam->parval>>32), (uint32_t)pParam->parval);
    … …  
    14311431            pParam->uDisp.i32 = DISReadDWord(pCpu, lpszCodeBlock);
    14321432            pParam->flags |= USE_DISPLACEMENT32;
    1433             pParam->size   = sizeof(uint32_t);
     1433            pParam->cb     = sizeof(uint32_t);
    14341434
    14351435            disasmAddStringF1(pParam->szParam, "[0%08Xh]", pParam->uDisp.i32);
    … …  
    14481448        pParam->uDisp.i64 = DISReadQWord(pCpu, lpszCodeBlock);
    14491449        pParam->flags |= USE_DISPLACEMENT64;
    1450         pParam->size   = sizeof(uint64_t);
     1450        pParam->cb     = sizeof(uint64_t);
    14511451
    14521452        disasmAddStringF2(pParam->szParam, "[0%08X%08Xh]", (uint32_t)(pParam->uDisp.i64 >> 32), (uint32_t)pParam->uDisp.i64);
    … …  
    14591459            pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
    14601460            pParam->flags |= USE_IMMEDIATE_ADDR_16_16;
    1461             pParam->size   = 2*sizeof(uint16_t);
     1461            pParam->cb     = 2*sizeof(uint16_t);
    14621462
    14631463            disasmAddStringF2(pParam->szParam, "0%04X:0%04Xh", (uint32_t)(pParam->parval>>16), (uint16_t)pParam->parval );
    … …  
    14721472            pParam->uDisp.i16 = DISReadWord(pCpu, lpszCodeBlock);
    14731473            pParam->flags |= USE_DISPLACEMENT16;
    1474             pParam->size   = sizeof(uint16_t);
     1474            pParam->cb     = sizeof(uint16_t);
    14751475
    14761476            disasmAddStringF1(pParam->szParam, "[0%04Xh]", (uint32_t)pParam->uDisp.i16);
    … …  
    15261526        *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, lpszCodeBlock+sizeof(uint32_t));
    15271527        pParam->flags  |= USE_IMMEDIATE_ADDR_16_32;
    1528         pParam->size   = sizeof(uint16_t) + sizeof(uint32_t);
     1528        pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
    15291529
    15301530        disasmAddStringF2(pParam->szParam, "0%04X:0%08Xh", (uint32_t)(pParam->parval>>32), (uint32_t)pParam->parval);
    … …  
    15361536        pParam->parval = DISReadDWord(pCpu, lpszCodeBlock);
    15371537        pParam->flags |= USE_IMMEDIATE_ADDR_16_16;
    1538         pParam->size   = 2*sizeof(uint16_t);
     1538        pParam->cb     = 2*sizeof(uint16_t);
    15391539
    15401540        disasmAddStringF2(pParam->szParam, "0%04X:0%04Xh", (uint32_t)(pParam->parval>>16), (uint16_t)pParam->parval );
    … …  
    15901590            pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN32_START;
    15911591            pParam->flags |= USE_REG_GEN32;
    1592             pParam->size   = 4;
     1592            pParam->cb     = 4;
    15931593        }
    15941594        else
    … …  
    16041604
    16051605            pParam->flags |= USE_REG_GEN64;
    1606             pParam->size   = 8;
     1606            pParam->cb     = 8;
    16071607        }
    16081608        else
    … …  
    16111611            pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN32_START;
    16121612            pParam->flags |= USE_REG_GEN16;
    1613             pParam->size   = 2;
     1613            pParam->cb     = 2;
    16141614            pParam->param = pParam->param - OP_PARM_REG_GEN32_START + OP_PARM_REG_GEN16_START;
    16151615        }
    … …  
    16211621        pParam->base.reg_seg = (DIS_SELREG)(pParam->param - OP_PARM_REG_SEG_START);
    16221622        pParam->flags |= USE_REG_SEG;
    1623         pParam->size   = 2;
     1623        pParam->cb     = 2;
    16241624    }
    16251625    else
    … …  
    16291629        pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN16_START;
    16301630        pParam->flags |= USE_REG_GEN16;
    1631         pParam->size   = 2;
     1631        pParam->cb     = 2;
    16321632    }
    16331633    else
    … …  
    16371637        pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN8_START;
    16381638        pParam->flags |= USE_REG_GEN8;
    1639         pParam->size   = 1;
     1639        pParam->cb     = 1;
    16401640
    16411641        if (pCpu->opmode == CPUMODE_64BIT)
    … …  
    16541654        pParam->base.reg_fp = pParam->param - OP_PARM_REG_FP_START;
    16551655        pParam->flags |= USE_REG_FP;
    1656         pParam->size   = 10;
     1656        pParam->cb     = 10;
    16571657    }
    16581658    Assert(!(pParam->param >= OP_PARM_REG_GEN64_START && pParam->param <= OP_PARM_REG_GEN64_END));

  • trunk/src/VBox/Disassembler/DisasmReg.cpp

    r41662 r41663  
    260260
    261261    default:
    262         if (pParam->size)
    263             return pParam->size;
     262        if (pParam->cb)
     263            return pParam->cb;
    264264        else //@todo dangerous!!!
    265265            return 4;
    … …  
    523523        // Effective address
    524524        pParamVal->type = PARMTYPE_ADDRESS;
    525         pParamVal->size = pParam->size;
     525        pParamVal->size = pParam->cb;
    526526
    527527        if (pParam->flags & USE_BASE)
    … …  
    651651            // Caller needs to interpret the register according to the instruction (source/target, special value etc)
    652652            pParamVal->type = PARMTYPE_REGISTER;
    653             pParamVal->size = pParam->size;
     653            pParamVal->size = pParam->cb;
    654654            return VINF_SUCCESS;
    655655        }
    … …  
    700700        {
    701701            pParamVal->flags |= PARAM_VAL8;
    702             if (pParam->size == 2)
     702            if (pParam->cb == 2)
    703703            {
    704704                pParamVal->size   = sizeof(uint16_t);
    … …  
    717717            pParamVal->size   = sizeof(uint16_t);
    718718            pParamVal->val.val16 = (uint16_t)pParam->parval;
    719             AssertMsg(pParamVal->size == pParam->size || ((pParam->size == 1) && (pParam->flags & USE_IMMEDIATE16_SX8)), ("pParamVal->size %d vs %d EIP=%RX32\n", pParamVal->size, pParam->size, pCtx->eip) );
     719            AssertMsg(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & USE_IMMEDIATE16_SX8)), ("pParamVal->size %d vs %d EIP=%RX32\n", pParamVal->size, pParam->cb, pCtx->eip) );
    720720        }
    721721        else
    … …  
    725725            pParamVal->size   = sizeof(uint32_t);
    726726            pParamVal->val.val32 = (uint32_t)pParam->parval;
    727             Assert(pParamVal->size == pParam->size || ((pParam->size == 1) && (pParam->flags & USE_IMMEDIATE32_SX8)) );
     727            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & USE_IMMEDIATE32_SX8)) );
    728728        }
    729729        else
    … …  
    733733            pParamVal->size   = sizeof(uint64_t);
    734734            pParamVal->val.val64 = pParam->parval;
    735             Assert(pParamVal->size == pParam->size || ((pParam->size == 1) && (pParam->flags & USE_IMMEDIATE64_SX8)) );
     735            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & USE_IMMEDIATE64_SX8)) );
    736736        }
    737737        else
    … …  
    742742            pParamVal->val.farptr.sel    = (uint16_t)RT_LOWORD(pParam->parval >> 16);
    743743            pParamVal->val.farptr.offset = (uint32_t)RT_LOWORD(pParam->parval);
    744             Assert(pParamVal->size == pParam->size);
     744            Assert(pParamVal->size == pParam->cb);
    745745        }
    746746        else
    … …  
    751751            pParamVal->val.farptr.sel    = (uint16_t)RT_LOWORD(pParam->parval >> 32);
    752752            pParamVal->val.farptr.offset = (uint32_t)(pParam->parval & 0xFFFFFFFF);
    753             Assert(pParam->size == 8);
     753            Assert(pParam->cb == 8);
    754754        }
    755755    }

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

    r41658 r41663  
    828828            uint64_t valpar1, valpar2;
    829829
    830             AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
     830            AssertReturn(pDis->param1.cb == pDis->param2.cb, VERR_EM_INTERPRETER);
    831831            switch(param1.type)
    832832            {
    … …  
    11141114            uint64_t valpar1, valpar2;
    11151115
    1116             if (pDis->param1.size != pDis->param2.size)
     1116            if (pDis->param1.cb != pDis->param2.cb)
    11171117            {
    1118                 if (pDis->param1.size < pDis->param2.size)
     1118                if (pDis->param1.cb < pDis->param2.cb)
    11191119                {
    1120                     AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size)); /* should never happen! */
     1120                    AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.cb, pDis->param2.cb)); /* should never happen! */
    11211121                    return VERR_EM_INTERPRETER;
    11221122                }
    11231123                /* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
    1124                 pDis->param2.size = pDis->param1.size;
     1124                pDis->param2.cb = pDis->param1.cb;
    11251125                param2.size     = param1.size;
    11261126            }
    … …  
    11951195
    11961196#if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0)
    1197     Assert(pDis->param1.size <= 4);
     1197    Assert(pDis->param1.cb <= 4);
    11981198#endif
    11991199
    … …  
    12061206        return VERR_EM_INTERPRETER;
    12071207
    1208     if (pDis->param1.size != pDis->param2.size)
    1209     {
    1210         AssertMsgReturn(pDis->param1.size >= pDis->param2.size, /* should never happen! */
    1211                         ("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size),
     1208    if (pDis->param1.cb != pDis->param2.cb)
     1209    {
     1210        AssertMsgReturn(pDis->param1.cb >= pDis->param2.cb, /* should never happen! */
     1211                        ("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.cb, pDis->param2.cb),
    12121212                        VERR_EM_INTERPRETER);
    12131213
    12141214        /* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
    1215         pDis->param2.size = pDis->param1.size;
     1215        pDis->param2.cb = pDis->param1.cb;
    12161216        param2.size       = param1.size;
    12171217    }
    … …  
    12381238
    12391239    /* Try emulate it with a one-shot #PF handler in place. (RC) */
    1240     Log2(("%s %RGv imm%d=%RX64\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
     1240    Log2(("%s %RGv imm%d=%RX64\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.cb*8, ValPar2));
    12411241
    12421242    RTGCUINTREG32 eflags = 0;
    1243     rc = pfnEmulate(pvParam1, ValPar2, pDis->param2.size, &eflags);
     1243    rc = pfnEmulate(pvParam1, ValPar2, pDis->param2.cb, &eflags);
    12441244    PGMPhysReleasePageMappingLock(pVM, &Lock);
    12451245    if (RT_FAILURE(rc))
    12461246    {
    1247         Log(("%s %RGv imm%d=%RX64-> emulation failed due to page fault!\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
     1247        Log(("%s %RGv imm%d=%RX64-> emulation failed due to page fault!\n", emGetMnemonic(pDis), GCPtrPar1, pDis->param2.cb*8, ValPar2));
    12481248        return VERR_EM_INTERPRETER;
    12491249    }
    … …  
    12831283            uint64_t valpar1, valpar2;
    12841284
    1285             if (pDis->param1.size != pDis->param2.size)
     1285            if (pDis->param1.cb != pDis->param2.cb)
    12861286            {
    1287                 if (pDis->param1.size < pDis->param2.size)
     1287                if (pDis->param1.cb < pDis->param2.cb)
    12881288                {
    1289                     AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.size, pDis->param2.size)); /* should never happen! */
     1289                    AssertMsgFailed(("%s at %RGv parameter mismatch %d vs %d!!\n", emGetMnemonic(pDis), (RTGCPTR)pRegFrame->rip, pDis->param1.cb, pDis->param2.cb)); /* should never happen! */
    12901290                    return VERR_EM_INTERPRETER;
    12911291                }
    12921292                /* Or %Ev, Ib -> just a hack to save some space; the data width of the 1st parameter determines the real width */
    1293                 pDis->param2.size = pDis->param1.size;
     1293                pDis->param2.cb = pDis->param1.cb;
    12941294                param2.size     = param1.size;
    12951295            }
    … …  
    14921492    {
    14931493        Log(("emInterpretLockBitTest %s: %RGv imm%d=%RX64 -> emulation failed due to page fault!\n",
    1494              emGetMnemonic(pDis), GCPtrPar1, pDis->param2.size*8, ValPar2));
     1494             emGetMnemonic(pDis), GCPtrPar1, pDis->param2.cb*8, ValPar2));
    14951495        return VERR_EM_INTERPRETER;
    14961496    }
    … …  
    18051805
    18061806#if HC_ARCH_BITS == 32 && !defined(VBOX_WITH_HYBRID_32BIT_KERNEL_IN_R0)
    1807     Assert(pDis->param1.size <= 4);
     1807    Assert(pDis->param1.cb <= 4);
    18081808#endif
    18091809
    … …  
    18331833    uint64_t eflags;
    18341834
    1835     AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
     1835    AssertReturn(pDis->param1.cb == pDis->param2.cb, VERR_EM_INTERPRETER);
    18361836    switch(param1.type)
    18371837    {
    … …  
    18511851
    18521852    if (pDis->prefix & PREFIX_LOCK)
    1853         eflags = EMEmulateLockCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.size);
     1853        eflags = EMEmulateLockCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.cb);
    18541854    else
    1855         eflags = EMEmulateCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.size);
     1855        eflags = EMEmulateCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.cb);
    18561856
    18571857    LogFlow(("%s %RGv rax=%RX64 %RX64 ZF=%d\n", emGetMnemonic(pDis), GCPtrPar1, pRegFrame->rax, valpar, !!(eflags & X86_EFL_ZF)));
    … …  
    18861886    PGMPAGEMAPLOCK Lock;
    18871887
    1888     AssertReturn(pDis->param1.size == 8, VERR_EM_INTERPRETER);
     1888    AssertReturn(pDis->param1.cb == 8, VERR_EM_INTERPRETER);
    18891889    switch(param1.type)
    18901890    {
    … …  
    19531953            PGMPAGEMAPLOCK  Lock;
    19541954
    1955             AssertReturn(pDis->param1.size == pDis->param2.size, VERR_EM_INTERPRETER);
     1955            AssertReturn(pDis->param1.cb == pDis->param2.cb, VERR_EM_INTERPRETER);
    19561956            switch(param1.type)
    19571957            {
    … …  
    31433143     * Whitelisted instructions are safe.
    31443144     */
    3145     if (    pDis->param1.size > 4
     3145    if (    pDis->param1.cb > 4
    31463146        &&  CPUMIsGuestIn64BitCode(pVCpu, pRegFrame))
    31473147    {

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

    r41464 r41663  
    887887                                          PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault)
    888888{
    889     unsigned uIncrement = pDis->param1.size;
     889    unsigned uIncrement = pDis->param1.cb;
    890890    NOREF(pVM);
    891891
    … …  
    11231123    if (    pPage->GCPtrLastAccessHandlerRip >= pRegFrame->rip - 0x40      /* observed loops in Windows 7 x64 */
    11241124        &&  pPage->GCPtrLastAccessHandlerRip <  pRegFrame->rip + 0x40
    1125         &&  pvFault == (pPage->GCPtrLastAccessHandlerFault + pDis->param1.size)
     1125        &&  pvFault == (pPage->GCPtrLastAccessHandlerFault + pDis->param1.cb)
    11261126        &&  pVCpu->pgm.s.cPoolAccessHandler == pPage->cLastAccessHandler + 1)
    11271127    {

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

    r41658 r41663  
    13231323           )
    13241324        {
    1325             Assert(pCpu->param1.size <= 4 || pCpu->param1.size == 6);
    1326             if (    pCpu->param1.size == 6 /* far call/jmp */
     1325            Assert(pCpu->param1.cb <= 4 || pCpu->param1.cb == 6);
     1326            if (    pCpu->param1.cb == 6 /* far call/jmp */
    13271327                ||  (pCpu->pCurInstr->opcode == OP_CALL && !(pPatch->flags & PATMFL_SUPPORT_CALLS))
    13281328                ||  (OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J && !(pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS))
    … …  
    14821482           )
    14831483        {
    1484             Assert(pCpu->param1.size <= 4 || pCpu->param1.size == 6);
    1485             if (    pCpu->param1.size == 6 /* far call/jmp */
     1484            Assert(pCpu->param1.cb <= 4 || pCpu->param1.cb == 6);
     1485            if (    pCpu->param1.cb == 6 /* far call/jmp */
    14861486                ||  (pCpu->pCurInstr->opcode == OP_CALL && !(pPatch->flags & PATMFL_SUPPORT_CALLS))
    14871487                ||  (OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J && !(pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS))
    … …  
    18691869         * In that case we'll jump to the original instruction and continue from there. Otherwise an int 3 is executed.
    18701870         */
    1871         Assert(pCpu->param1.size == 4 || pCpu->param1.size == 6);
    1872         if (pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS && pCpu->param1.size == 4 /* no far calls! */)
     1871        Assert(pCpu->param1.cb == 4 || pCpu->param1.cb == 6);
     1872        if (pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS && pCpu->param1.cb == 4 /* no far calls! */)
    18731873        {
    18741874            rc = patmPatchGenCall(pVM, pPatch, pCpu, pCurInstrGC, (RTRCPTR)0xDEADBEEF, true);
    … …  
    18861886         * In that case we'll jump to the original instruction and continue from there. Otherwise an int 3 is executed.
    18871887         */
    1888         Assert(pCpu->param1.size == 4 || pCpu->param1.size == 6);
    1889         if (pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS && pCpu->param1.size == 4 /* no far jumps! */)
     1888        Assert(pCpu->param1.cb == 4 || pCpu->param1.cb == 6);
     1889        if (pPatch->flags & PATMFL_SUPPORT_INDIRECT_CALLS && pCpu->param1.cb == 4 /* no far jumps! */)
    18901890        {
    18911891            rc = patmPatchGenJump(pVM, pPatch, pCpu, pCurInstrGC);
    … …  
    20592059
    20602060            bool disret = PATMR3DISInstr(pVM, pPatch, &cpu, pOrgJumpGC, pOrgJumpHC, &dummy, NULL);
    2061             if (!disret || cpu.pCurInstr->opcode != OP_CALL || cpu.param1.size != 4 /* only near calls */)
     2061            if (!disret || cpu.pCurInstr->opcode != OP_CALL || cpu.param1.cb != 4 /* only near calls */)
    20622062                return VINF_SUCCESS;
    20632063        }

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

    r39078 r41663  
    693693    {
    694694        Log(("patmPatchGenIndirectCall\n"));
    695         Assert(pCpu->param1.size == 4);
     695        Assert(pCpu->param1.cb == 4);
    696696        Assert(OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J);
    697697
    … …  
    789789
    790790    Log(("patmPatchGenIndirectJump\n"));
    791     Assert(pCpu->param1.size == 4);
     791    Assert(pCpu->param1.cb == 4);
    792792    Assert(OP_PARM_VTYPE(pCpu->pCurInstr->param1) != OP_PARM_J);
    793793
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette