VirtualBox

Changeset 41741 in vbox for trunk/src


Ignore:
Timestamp:
Jun 15, 2012 1:50:13 AM (13 years ago)
Author:
vboxsync
Message:

DISOPPARAM: s/parval/uValue/ + doc

Location:
trunk/src/VBox
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Disassembler/DisasmCore.cpp

    r41740 r41741  
    11641164{
    11651165    NOREF(pOp);
    1166     pParam->parval = disReadByte(pCpu, uCodePtr);
     1166    pParam->uValue = disReadByte(pCpu, uCodePtr);
    11671167    pParam->fUse  |= DISUSE_IMMEDIATE8;
    11681168    pParam->cb     = sizeof(uint8_t);
     
    11831183    if (pCpu->uOpMode == DISCPUMODE_32BIT)
    11841184    {
    1185         pParam->parval = (uint32_t)(int8_t)disReadByte(pCpu, uCodePtr);
     1185        pParam->uValue = (uint32_t)(int8_t)disReadByte(pCpu, uCodePtr);
    11861186        pParam->fUse  |= DISUSE_IMMEDIATE32_SX8;
    11871187        pParam->cb     = sizeof(uint32_t);
     
    11901190    if (pCpu->uOpMode == DISCPUMODE_64BIT)
    11911191    {
    1192         pParam->parval = (uint64_t)(int8_t)disReadByte(pCpu, uCodePtr);
     1192        pParam->uValue = (uint64_t)(int8_t)disReadByte(pCpu, uCodePtr);
    11931193        pParam->fUse  |= DISUSE_IMMEDIATE64_SX8;
    11941194        pParam->cb     = sizeof(uint64_t);
     
    11961196    else
    11971197    {
    1198         pParam->parval = (uint16_t)(int8_t)disReadByte(pCpu, uCodePtr);
     1198        pParam->uValue = (uint16_t)(int8_t)disReadByte(pCpu, uCodePtr);
    11991199        pParam->fUse  |= DISUSE_IMMEDIATE16_SX8;
    12001200        pParam->cb     = sizeof(uint16_t);
     
    12141214{
    12151215    NOREF(pOp);
    1216     pParam->parval = disReadWord(pCpu, uCodePtr);
     1216    pParam->uValue = disReadWord(pCpu, uCodePtr);
    12171217    pParam->fUse  |= DISUSE_IMMEDIATE16;
    12181218    pParam->cb     = sizeof(uint16_t);
     
    12311231{
    12321232    NOREF(pOp);
    1233     pParam->parval = disReadDWord(pCpu, uCodePtr);
     1233    pParam->uValue = disReadDWord(pCpu, uCodePtr);
    12341234    pParam->fUse  |= DISUSE_IMMEDIATE32;
    12351235    pParam->cb     = sizeof(uint32_t);
     
    12481248{
    12491249    NOREF(pOp);
    1250     pParam->parval = disReadQWord(pCpu, uCodePtr);
     1250    pParam->uValue = disReadQWord(pCpu, uCodePtr);
    12511251    pParam->fUse  |= DISUSE_IMMEDIATE64;
    12521252    pParam->cb     = sizeof(uint64_t);
     
    12671267    if (pCpu->uOpMode == DISCPUMODE_32BIT)
    12681268    {
    1269         pParam->parval = disReadDWord(pCpu, uCodePtr);
     1269        pParam->uValue = disReadDWord(pCpu, uCodePtr);
    12701270        pParam->fUse  |= DISUSE_IMMEDIATE32;
    12711271        pParam->cb     = sizeof(uint32_t);
     
    12751275    if (pCpu->uOpMode == DISCPUMODE_64BIT)
    12761276    {
    1277         pParam->parval = disReadQWord(pCpu, uCodePtr);
     1277        pParam->uValue = disReadQWord(pCpu, uCodePtr);
    12781278        pParam->fUse  |= DISUSE_IMMEDIATE64;
    12791279        pParam->cb     = sizeof(uint64_t);
     
    12811281    }
    12821282
    1283     pParam->parval = disReadWord(pCpu, uCodePtr);
     1283    pParam->uValue = disReadWord(pCpu, uCodePtr);
    12841284    pParam->fUse  |= DISUSE_IMMEDIATE16;
    12851285    pParam->cb     = sizeof(uint16_t);
     
    13051305    if (pCpu->uOpMode == DISCPUMODE_16BIT)
    13061306    {
    1307         pParam->parval = disReadWord(pCpu, uCodePtr);
     1307        pParam->uValue = disReadWord(pCpu, uCodePtr);
    13081308        pParam->fUse  |= DISUSE_IMMEDIATE16;
    13091309        pParam->cb     = sizeof(uint16_t);
     
    13141314    if (pCpu->uOpMode == DISCPUMODE_64BIT)
    13151315    {
    1316         pParam->parval = (uint64_t)(int32_t)disReadDWord(pCpu, uCodePtr);
     1316        pParam->uValue = (uint64_t)(int32_t)disReadDWord(pCpu, uCodePtr);
    13171317        pParam->fUse  |= DISUSE_IMMEDIATE64;
    13181318        pParam->cb     = sizeof(uint64_t);
     
    13201320    else
    13211321    {
    1322         pParam->parval = disReadDWord(pCpu, uCodePtr);
     1322        pParam->uValue = disReadDWord(pCpu, uCodePtr);
    13231323        pParam->fUse  |= DISUSE_IMMEDIATE32;
    13241324        pParam->cb     = sizeof(uint32_t);
     
    13431343{
    13441344    NOREF(pOp);
    1345     pParam->parval = disReadByte(pCpu, uCodePtr);
     1345    pParam->uValue = disReadByte(pCpu, uCodePtr);
    13461346    pParam->fUse  |= DISUSE_IMMEDIATE8_REL;
    13471347    pParam->cb     = sizeof(uint8_t);
     
    13641364    if (pCpu->uOpMode == DISCPUMODE_32BIT)
    13651365    {
    1366         pParam->parval = disReadDWord(pCpu, uCodePtr);
     1366        pParam->uValue = disReadDWord(pCpu, uCodePtr);
    13671367        pParam->fUse  |= DISUSE_IMMEDIATE32_REL;
    13681368        pParam->cb     = sizeof(int32_t);
     
    13731373    {
    13741374        /* 32 bits relative immediate sign extended to 64 bits. */
    1375         pParam->parval = (uint64_t)(int32_t)disReadDWord(pCpu, uCodePtr);
     1375        pParam->uValue = (uint64_t)(int32_t)disReadDWord(pCpu, uCodePtr);
    13761376        pParam->fUse  |= DISUSE_IMMEDIATE64_REL;
    13771377        pParam->cb     = sizeof(int64_t);
     
    13791379    }
    13801380
    1381     pParam->parval = disReadWord(pCpu, uCodePtr);
     1381    pParam->uValue = disReadWord(pCpu, uCodePtr);
    13821382    pParam->fUse  |= DISUSE_IMMEDIATE16_REL;
    13831383    pParam->cb     = sizeof(int16_t);
     
    14041404        {
    14051405            /* far 16:32 pointer */
    1406             pParam->parval = disReadDWord(pCpu, uCodePtr);
    1407             *((uint32_t*)&pParam->parval+1) = disReadWord(pCpu, uCodePtr+sizeof(uint32_t));
     1406            pParam->uValue = disReadDWord(pCpu, uCodePtr);
     1407            *((uint32_t*)&pParam->uValue+1) = disReadWord(pCpu, uCodePtr+sizeof(uint32_t));
    14081408            pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
    14091409            pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
     
    14401440    {
    14411441        /* far 16:16 pointer */
    1442         pParam->parval = disReadDWord(pCpu, uCodePtr);
     1442        pParam->uValue = disReadDWord(pCpu, uCodePtr);
    14431443        pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
    14441444        pParam->cb     = 2*sizeof(uint16_t);
     
    15001500    {
    15011501        // far 16:32 pointer
    1502         pParam->parval = disReadDWord(pCpu, uCodePtr);
    1503         *((uint32_t*)&pParam->parval+1) = disReadWord(pCpu, uCodePtr+sizeof(uint32_t));
     1502        pParam->uValue = disReadDWord(pCpu, uCodePtr);
     1503        *((uint32_t*)&pParam->uValue+1) = disReadWord(pCpu, uCodePtr+sizeof(uint32_t));
    15041504        pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
    15051505        pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
     
    15081508
    15091509    // far 16:16 pointer
    1510     pParam->parval = disReadDWord(pCpu, uCodePtr);
     1510    pParam->uValue = disReadDWord(pCpu, uCodePtr);
    15111511    pParam->fUse  |= DISUSE_IMMEDIATE_ADDR_16_16;
    15121512    pParam->cb     = 2*sizeof(uint16_t);
  • trunk/src/VBox/Disassembler/DisasmFormatYasm.cpp

    r41740 r41741  
    796796                                   )
    797797                                    PUT_SZ("strict byte ");
    798                                 PUT_NUM_8(pParam->parval);
     798                                PUT_NUM_8(pParam->uValue);
    799799                                break;
    800800
     
    802802                                if (    pCpu->uCpuMode != pCpu->uOpMode
    803803                                    ||  (   (fFlags & DIS_FMT_FLAGS_STRICT)
    804                                          && (   (int8_t)pParam->parval == (int16_t)pParam->parval
     804                                         && (   (int8_t)pParam->uValue == (int16_t)pParam->uValue
    805805                                             || (pOp->fParam1 >= OP_PARM_REG_GEN16_START && pOp->fParam1 <= OP_PARM_REG_GEN16_END)
    806806                                             || (pOp->fParam2 >= OP_PARM_REG_GEN16_START && pOp->fParam2 <= OP_PARM_REG_GEN16_END))
     
    814814                                        PUT_SZ_STRICT("strict word ", "word ");
    815815                                }
    816                                 PUT_NUM_16(pParam->parval);
     816                                PUT_NUM_16(pParam->uValue);
    817817                                break;
    818818
    819819                            case DISUSE_IMMEDIATE16_SX8:
    820820                                PUT_SZ_STRICT("strict byte ", "byte ");
    821                                 PUT_NUM_16(pParam->parval);
     821                                PUT_NUM_16(pParam->uValue);
    822822                                break;
    823823
     
    825825                                if (    pCpu->uOpMode != (pCpu->uCpuMode == DISCPUMODE_16BIT ? DISCPUMODE_16BIT : DISCPUMODE_32BIT) /* not perfect */
    826826                                    ||  (   (fFlags & DIS_FMT_FLAGS_STRICT)
    827                                          && (   (int8_t)pParam->parval == (int32_t)pParam->parval
     827                                         && (   (int8_t)pParam->uValue == (int32_t)pParam->uValue
    828828                                             || (pOp->fParam1 >= OP_PARM_REG_GEN32_START && pOp->fParam1 <= OP_PARM_REG_GEN32_END)
    829829                                             || (pOp->fParam2 >= OP_PARM_REG_GEN32_START && pOp->fParam2 <= OP_PARM_REG_GEN32_END))
     
    837837                                        PUT_SZ_STRICT("strict dword ", "dword ");
    838838                                }
    839                                 PUT_NUM_32(pParam->parval);
     839                                PUT_NUM_32(pParam->uValue);
    840840                                break;
    841841
    842842                            case DISUSE_IMMEDIATE32_SX8:
    843843                                PUT_SZ_STRICT("strict byte ", "byte ");
    844                                 PUT_NUM_32(pParam->parval);
     844                                PUT_NUM_32(pParam->uValue);
    845845                                break;
    846846
    847847                            case DISUSE_IMMEDIATE64_SX8:
    848848                                PUT_SZ_STRICT("strict byte ", "byte ");
    849                                 PUT_NUM_64(pParam->parval);
     849                                PUT_NUM_64(pParam->uValue);
    850850                                break;
    851851
    852852                            case DISUSE_IMMEDIATE64:
    853                                 PUT_NUM_64(pParam->parval);
     853                                PUT_NUM_64(pParam->uValue);
    854854                                break;
    855855
     
    877877                            if (fPrefix)
    878878                                PUT_SZ("short ");
    879                             offDisplacement = (int8_t)pParam->parval;
     879                            offDisplacement = (int8_t)pParam->uValue;
    880880                            Assert(*pszFmt == 'b'); pszFmt++;
    881881
     
    887887                            if (fPrefix)
    888888                                PUT_SZ("near ");
    889                             offDisplacement = (int16_t)pParam->parval;
     889                            offDisplacement = (int16_t)pParam->uValue;
    890890                            Assert(*pszFmt == 'v'); pszFmt++;
    891891
     
    897897                            if (fPrefix)
    898898                                PUT_SZ("near ");
    899                             offDisplacement = (int32_t)pParam->parval;
     899                            offDisplacement = (int32_t)pParam->uValue;
    900900                            Assert(pParam->fUse & (DISUSE_IMMEDIATE32_REL|DISUSE_IMMEDIATE64_REL));
    901901                            Assert(*pszFmt == 'v'); pszFmt++;
     
    952952                        {
    953953                            case DISUSE_IMMEDIATE_ADDR_16_16:
    954                                 PUT_NUM_16(pParam->parval >> 16);
     954                                PUT_NUM_16(pParam->uValue >> 16);
    955955                                PUT_C(':');
    956                                 PUT_NUM_16(pParam->parval);
     956                                PUT_NUM_16(pParam->uValue);
    957957                                if (pfnGetSymbol)
    958                                     rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->parval >> 16), (uint16_t)pParam->parval, szSymbol, sizeof(szSymbol), &off, pvUser);
     958                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint16_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
    959959                                break;
    960960                            case DISUSE_IMMEDIATE_ADDR_16_32:
    961                                 PUT_NUM_16(pParam->parval >> 32);
     961                                PUT_NUM_16(pParam->uValue >> 32);
    962962                                PUT_C(':');
    963                                 PUT_NUM_32(pParam->parval);
     963                                PUT_NUM_32(pParam->uValue);
    964964                                if (pfnGetSymbol)
    965                                     rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->parval >> 16), (uint32_t)pParam->parval, szSymbol, sizeof(szSymbol), &off, pvUser);
     965                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint32_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
    966966                                break;
    967967                            case DISUSE_DISPLACEMENT16:
    968                                 PUT_NUM_16(pParam->parval);
     968                                PUT_NUM_16(pParam->uValue);
    969969                                if (pfnGetSymbol)
    970                                     rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint16_t)pParam->parval, szSymbol, sizeof(szSymbol), &off, pvUser);
     970                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint16_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
    971971                                break;
    972972                            case DISUSE_DISPLACEMENT32:
    973                                 PUT_NUM_32(pParam->parval);
     973                                PUT_NUM_32(pParam->uValue);
    974974                                if (pfnGetSymbol)
    975                                     rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint32_t)pParam->parval, szSymbol, sizeof(szSymbol), &off, pvUser);
     975                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint32_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
    976976                                break;
    977977                            case DISUSE_DISPLACEMENT64:
    978                                 PUT_NUM_64(pParam->parval);
     978                                PUT_NUM_64(pParam->uValue);
    979979                                if (pfnGetSymbol)
    980                                     rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint64_t)pParam->parval, szSymbol, sizeof(szSymbol), &off, pvUser);
     980                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_REG(DISSELREG_CS), (uint64_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
    981981                                break;
    982982                            default:
     
    10161016                        {
    10171017                            case DISUSE_IMMEDIATE_ADDR_16_16:
    1018                                 PUT_NUM_16(pParam->parval >> 16);
     1018                                PUT_NUM_16(pParam->uValue >> 16);
    10191019                                PUT_C(':');
    1020                                 PUT_NUM_16(pParam->parval);
     1020                                PUT_NUM_16(pParam->uValue);
    10211021                                if (pfnGetSymbol)
    1022                                     rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->parval >> 16), (uint16_t)pParam->parval, szSymbol, sizeof(szSymbol), &off, pvUser);
     1022                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint16_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
    10231023                                break;
    10241024                            case DISUSE_IMMEDIATE_ADDR_16_32:
    1025                                 PUT_NUM_16(pParam->parval >> 32);
     1025                                PUT_NUM_16(pParam->uValue >> 32);
    10261026                                PUT_C(':');
    1027                                 PUT_NUM_32(pParam->parval);
     1027                                PUT_NUM_32(pParam->uValue);
    10281028                                if (pfnGetSymbol)
    1029                                     rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->parval >> 16), (uint32_t)pParam->parval, szSymbol, sizeof(szSymbol), &off, pvUser);
     1029                                    rc = pfnGetSymbol(pCpu, DIS_FMT_SEL_FROM_VALUE(pParam->uValue >> 16), (uint32_t)pParam->uValue, szSymbol, sizeof(szSymbol), &off, pvUser);
    10301030                                break;
    10311031                            case DISUSE_DISPLACEMENT16:
     
    14491449    /* shl eax,1 will be assembled to the form without the immediate byte. */
    14501450    if (    pCpu->pCurInstr->fParam2 == OP_PARM_Ib
    1451         &&  (uint8_t)pCpu->Param2.parval == 1)
     1451        &&  (uint8_t)pCpu->Param2.uValue == 1)
    14521452    {
    14531453        switch (pCpu->pCurInstr->uOpcode)
  • trunk/src/VBox/Disassembler/DisasmReg.cpp

    r41740 r41741  
    688688            {
    689689                pParamVal->size   = sizeof(uint16_t);
    690                 pParamVal->val.val16 = (uint8_t)pParam->parval;
     690                pParamVal->val.val16 = (uint8_t)pParam->uValue;
    691691            }
    692692            else
    693693            {
    694694                pParamVal->size   = sizeof(uint8_t);
    695                 pParamVal->val.val8 = (uint8_t)pParam->parval;
     695                pParamVal->val.val8 = (uint8_t)pParam->uValue;
    696696            }
    697697        }
     
    701701            pParamVal->flags |= DISQPV_FLAG_16;
    702702            pParamVal->size   = sizeof(uint16_t);
    703             pParamVal->val.val16 = (uint16_t)pParam->parval;
     703            pParamVal->val.val16 = (uint16_t)pParam->uValue;
    704704            AssertMsg(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->fUse & DISUSE_IMMEDIATE16_SX8)), ("pParamVal->size %d vs %d EIP=%RX32\n", pParamVal->size, pParam->cb, pCtx->eip) );
    705705        }
     
    709709            pParamVal->flags |= DISQPV_FLAG_32;
    710710            pParamVal->size   = sizeof(uint32_t);
    711             pParamVal->val.val32 = (uint32_t)pParam->parval;
     711            pParamVal->val.val32 = (uint32_t)pParam->uValue;
    712712            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->fUse & DISUSE_IMMEDIATE32_SX8)) );
    713713        }
     
    717717            pParamVal->flags |= DISQPV_FLAG_64;
    718718            pParamVal->size   = sizeof(uint64_t);
    719             pParamVal->val.val64 = pParam->parval;
     719            pParamVal->val.val64 = pParam->uValue;
    720720            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->fUse & DISUSE_IMMEDIATE64_SX8)) );
    721721        }
     
    725725            pParamVal->flags |= DISQPV_FLAG_FARPTR16;
    726726            pParamVal->size   = sizeof(uint16_t)*2;
    727             pParamVal->val.farptr.sel    = (uint16_t)RT_LOWORD(pParam->parval >> 16);
    728             pParamVal->val.farptr.offset = (uint32_t)RT_LOWORD(pParam->parval);
     727            pParamVal->val.farptr.sel    = (uint16_t)RT_LOWORD(pParam->uValue >> 16);
     728            pParamVal->val.farptr.offset = (uint32_t)RT_LOWORD(pParam->uValue);
    729729            Assert(pParamVal->size == pParam->cb);
    730730        }
     
    734734            pParamVal->flags |= DISQPV_FLAG_FARPTR32;
    735735            pParamVal->size   = sizeof(uint16_t) + sizeof(uint32_t);
    736             pParamVal->val.farptr.sel    = (uint16_t)RT_LOWORD(pParam->parval >> 32);
    737             pParamVal->val.farptr.offset = (uint32_t)(pParam->parval & 0xFFFFFFFF);
     736            pParamVal->val.farptr.sel    = (uint16_t)RT_LOWORD(pParam->uValue >> 32);
     737            pParamVal->val.farptr.offset = (uint32_t)(pParam->uValue & 0xFFFFFFFF);
    738738            Assert(pParam->cb == 8);
    739739        }
  • trunk/src/VBox/VMM/VMMAll/IOMAll.cpp

    r41739 r41741  
    109109        {
    110110            *pcbSize  = 8;
    111             *pu64Data = pParam->parval;
     111            *pu64Data = pParam->uValue;
    112112            return true;
    113113        }
     
    116116        {
    117117            *pcbSize  = 4;
    118             *pu64Data = (uint32_t)pParam->parval;
     118            *pu64Data = (uint32_t)pParam->uValue;
    119119            return true;
    120120        }
     
    123123        {
    124124            *pcbSize  = 2;
    125             *pu64Data = (uint16_t)pParam->parval;
     125            *pu64Data = (uint16_t)pParam->uValue;
    126126            return true;
    127127        }
     
    130130        {
    131131            *pcbSize  = 1;
    132             *pu64Data = (uint8_t)pParam->parval;
     132            *pu64Data = (uint8_t)pParam->uValue;
    133133            return true;
    134134        }
  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

    r41739 r41741  
    37043704                        uint32_t intInfo2;
    37053705
    3706                         LogFlow(("Realmode: INT %x\n", pDis->Param1.parval & 0xff));
    3707                         intInfo2  = pDis->Param1.parval & 0xff;
     3706                        LogFlow(("Realmode: INT %x\n", pDis->Param1.uValue & 0xff));
     3707                        intInfo2  = pDis->Param1.uValue & 0xff;
    37083708                        intInfo2 |= (1 << VMX_EXIT_INTERRUPTION_INFO_VALID_SHIFT);
    37093709                        intInfo2 |= (VMX_EXIT_INTERRUPTION_INFO_TYPE_SW << VMX_EXIT_INTERRUPTION_INFO_TYPE_SHIFT);
  • trunk/src/VBox/VMM/VMMR3/CSAM.cpp

    r41739 r41741  
    801801    case OP_INT:
    802802        Assert(pCpu->Param1.fUse & DISUSE_IMMEDIATE8);
    803         if (pCpu->Param1.parval == 3)
     803        if (pCpu->Param1.uValue == 3)
    804804        {
    805805            //two byte int 3
     
    11011101                             && (   !(cpu.Param2.flags & DISUSE_REG_GEN32)
    11021102                                 || !(cpu.Param2.flags & (DISUSE_DISPLACEMENT8|DISUSE_DISPLACEMENT16|DISUSE_DISPLACEMENT32))
    1103                                  ||  cpu.Param2.parval != 0
     1103                                 ||  cpu.Param2.uValue != 0
    11041104                                )
    11051105                            )
  • trunk/src/VBox/VMM/VMMR3/HWACCM.cpp

    r41739 r41741  
    18451845                Assert(pDis->Param2.fUse == DISUSE_IMMEDIATE32);
    18461846                pPatch->enmType     = HWACCMTPRINSTR_WRITE_IMM;
    1847                 pPatch->uSrcOperand = pDis->Param2.parval;
     1847                pPatch->uSrcOperand = pDis->Param2.uValue;
    18481848            }
    18491849            rc = PGMPhysSimpleWriteGCPtr(pVCpu, pCtx->rip, aVMMCall, sizeof(aVMMCall));
     
    18751875                &&  pDis->Param1.base.reg_gen == uMmioReg
    18761876                &&  pDis->Param2.fUse == DISUSE_IMMEDIATE8
    1877                 &&  pDis->Param2.parval == 4
     1877                &&  pDis->Param2.uValue == 4
    18781878                &&  oldcbOp + cbOp < sizeof(pVM->hwaccm.s.aPatches[idx].aOpcode))
    18791879            {
     
    20482048                Assert(pDis->Param2.fUse == DISUSE_IMMEDIATE32);
    20492049                aPatch[off++] = 0xB8;    /* mov eax, immediate */
    2050                 *(uint32_t *)&aPatch[off] = pDis->Param2.parval;
     2050                *(uint32_t *)&aPatch[off] = pDis->Param2.uValue;
    20512051                off += sizeof(uint32_t);
    20522052            }
  • trunk/src/VBox/VMM/VMMR3/PATM.cpp

    r41739 r41741  
    39493949     * references the target instruction in the conflict patch.
    39503950     */
    3951     RTRCPTR pJmpDest = PATMR3GuestGCPtrToPatchGCPtr(pVM, pInstrGC + pCpu->cbInstr + (int32_t)pCpu->Param1.parval);
    3952 
    3953     AssertMsg(pJmpDest, ("PATMR3GuestGCPtrToPatchGCPtr failed for %RRv\n", pInstrGC + pCpu->cbInstr + (int32_t)pCpu->Param1.parval));
     3951    RTRCPTR pJmpDest = PATMR3GuestGCPtrToPatchGCPtr(pVM, pInstrGC + pCpu->cbInstr + (int32_t)pCpu->Param1.uValue);
     3952
     3953    AssertMsg(pJmpDest, ("PATMR3GuestGCPtrToPatchGCPtr failed for %RRv\n", pInstrGC + pCpu->cbInstr + (int32_t)pCpu->Param1.uValue));
    39543954    pPatch->pPatchJumpDestGC = pJmpDest;
    39553955
  • trunk/src/VBox/VMM/VMMR3/PATMPatch.cpp

    r41739 r41741  
    857857    /** @note optimization: multiple identical ret instruction in a single patch can share a single patched ret. */
    858858    if (    pPatch->pTempInfo->pPatchRetInstrGC
    859         &&  pPatch->pTempInfo->uPatchRetParam1 == (uint32_t)pCpu->Param1.parval) /* nr of bytes popped off the stack should be identical of course! */
     859        &&  pPatch->pTempInfo->uPatchRetParam1 == (uint32_t)pCpu->Param1.uValue) /* nr of bytes popped off the stack should be identical of course! */
    860860    {
    861861        Assert(pCpu->pCurInstr->uOpcode == OP_RETN);
     
    891891    {
    892892        pPatch->pTempInfo->pPatchRetInstrGC = pPatchRetInstrGC;
    893         pPatch->pTempInfo->uPatchRetParam1  = pCpu->Param1.parval;
     893        pPatch->pTempInfo->uPatchRetParam1  = pCpu->Param1.uValue;
    894894    }
    895895    return rc;
  • trunk/src/VBox/VMM/VMMRC/TRPMRCHandlers.cpp

    r41739 r41741  
    739739             */
    740740            pCpu->Param1.fUse  = DISUSE_IMMEDIATE8;
    741             pCpu->Param1.parval = 3;
     741            pCpu->Param1.uValue = 3;
    742742            /* fallthru */
    743743        case OP_INT:
     
    745745            Assert(pCpu->Param1.fUse & DISUSE_IMMEDIATE8);
    746746            Assert(!(PATMIsPatchGCAddr(pVM, PC)));
    747             if (pCpu->Param1.parval == 3)
     747            if (pCpu->Param1.uValue == 3)
    748748            {
    749749                /* Int 3 replacement patch? */
     
    754754                }
    755755            }
    756             rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->Param1.parval, pCpu->cbInstr, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
     756            rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->Param1.uValue, pCpu->cbInstr, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
    757757            if (RT_SUCCESS(rc) && rc != VINF_EM_RAW_GUEST_TRAP)
    758758                return trpmGCExitTrap(pVM, pVCpu, VINF_SUCCESS, pRegFrame);
     
    841841             */
    842842            pCpu->Param1.fUse  = DISUSE_IMMEDIATE8;
    843             pCpu->Param1.parval = 3;
     843            pCpu->Param1.uValue = 3;
    844844            /* fall thru */
    845845        case OP_INT:
    846846        {
    847847            Assert(pCpu->Param1.fUse & DISUSE_IMMEDIATE8);
    848             rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->Param1.parval, pCpu->cbInstr, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
     848            rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->Param1.uValue, pCpu->cbInstr, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
    849849            if (RT_SUCCESS(rc) && rc != VINF_EM_RAW_GUEST_TRAP)
    850850                return trpmGCExitTrap(pVM, pVCpu, VINF_SUCCESS, pRegFrame);
  • trunk/src/VBox/VMM/include/CSAMInternal.h

    r41739 r41741  
    253253    if (pCpu->Param1.fUse & DISUSE_IMMEDIATE8_REL)
    254254    {
    255         disp = (int32_t)(char)pCpu->Param1.parval;
     255        disp = (int32_t)(char)pCpu->Param1.uValue;
    256256    }
    257257    else
    258258    if (pCpu->Param1.fUse & DISUSE_IMMEDIATE16_REL)
    259259    {
    260         disp = (int32_t)(uint16_t)pCpu->Param1.parval;
     260        disp = (int32_t)(uint16_t)pCpu->Param1.uValue;
    261261    }
    262262    else
    263263    if (pCpu->Param1.fUse & DISUSE_IMMEDIATE32_REL)
    264264    {
    265         disp = (int32_t)pCpu->Param1.parval;
     265        disp = (int32_t)pCpu->Param1.uValue;
    266266    }
    267267    else
  • trunk/src/VBox/VMM/include/PATMInternal.h

    r41739 r41741  
    763763    if (pCpu->Param1.fUse & DISUSE_IMMEDIATE8_REL)
    764764    {
    765         disp = (int32_t)(char)pCpu->Param1.parval;
     765        disp = (int32_t)(char)pCpu->Param1.uValue;
    766766    }
    767767    else
    768768    if (pCpu->Param1.fUse & DISUSE_IMMEDIATE16_REL)
    769769    {
    770         disp = (int32_t)(uint16_t)pCpu->Param1.parval;
     770        disp = (int32_t)(uint16_t)pCpu->Param1.uValue;
    771771    }
    772772    else
    773773    if (pCpu->Param1.fUse & DISUSE_IMMEDIATE32_REL)
    774774    {
    775         disp = (int32_t)pCpu->Param1.parval;
     775        disp = (int32_t)pCpu->Param1.uValue;
    776776    }
    777777    else
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