VirtualBox

Changeset 41678 in vbox


Ignore:
Timestamp:
Jun 13, 2012 9:37:47 AM (12 years ago)
Author:
vboxsync
Message:

OP_PARAMETER::flags -> fUse.

Location:
trunk
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/dis.h

    r41676 r41678  
    393393{
    394394    uint64_t        parval;
    395     uint64_t        flags;
     395    /** A combination of DISUSE_XXX. */
     396    uint64_t        fUse;
    396397    union
    397398    {

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

    r41676 r41678  
    616616    if (ppszSIBIndexReg[index])
    617617    {
    618          pParam->flags |= DISUSE_INDEX | regtype;
     618         pParam->fUse |= DISUSE_INDEX | regtype;
    619619         pParam->index.reg_gen = index;
    620620
    621621         if (scale != 0)
    622622         {
    623              pParam->flags |= DISUSE_SCALE;
     623             pParam->fUse |= DISUSE_SCALE;
    624624             pParam->scale  = (1<<scale);
    625625         }
    … …  
    631631        if (pCpu->addrmode == DISCPUMODE_32BIT)
    632632        {
    633             pParam->flags |= DISUSE_DISPLACEMENT32;
     633            pParam->fUse |= DISUSE_DISPLACEMENT32;
    634634            pParam->uDisp.i32 = pCpu->i32SibDisp;
    635635        }
    636636        else
    637637        {   /* sign-extend to 64 bits */
    638             pParam->flags |= DISUSE_DISPLACEMENT64;
     638            pParam->fUse |= DISUSE_DISPLACEMENT64;
    639639            pParam->uDisp.i64 = pCpu->i32SibDisp;
    640640        }
    … …  
    642642    else
    643643    {
    644         pParam->flags |= DISUSE_BASE | regtype;
     644        pParam->fUse |= DISUSE_BASE | regtype;
    645645        pParam->base.reg_gen = base;
    646646    }
    … …  
    735735            {
    736736            case OP_PARM_C: //control register
    737                 pParam->flags |= DISUSE_REG_CR;
     737                pParam->fUse |= DISUSE_REG_CR;
    738738
    739739                if (    pCpu->pCurInstr->opcode == OP_MOV_CR
    … …  
    749749
    750750            case OP_PARM_D: //debug register
    751                 pParam->flags |= DISUSE_REG_DBG;
     751                pParam->fUse |= DISUSE_REG_DBG;
    752752                pParam->base.reg_dbg = reg;
    753753                return 0;
    … …  
    755755            case OP_PARM_P: //MMX register
    756756                reg &= 7;   /* REX.R has no effect here */
    757                 pParam->flags |= DISUSE_REG_MMX;
     757                pParam->fUse |= DISUSE_REG_MMX;
    758758                pParam->base.reg_mmx = reg;
    759759                return 0;
    … …  
    762762                reg &= 7;   /* REX.R has no effect here */
    763763                disasmModRMSReg(pCpu, pOp, reg, pParam);
    764                 pParam->flags |= DISUSE_REG_SEG;
     764                pParam->fUse |= DISUSE_REG_SEG;
    765765                return 0;
    766766
    767767            case OP_PARM_T: //test register
    768768                reg &= 7;   /* REX.R has no effect here */
    769                 pParam->flags |= DISUSE_REG_TEST;
     769                pParam->fUse |= DISUSE_REG_TEST;
    770770                pParam->base.reg_test = reg;
    771771                return 0;
    … …  
    778778
    779779            case OP_PARM_V: //XMM register
    780                 pParam->flags |= DISUSE_REG_XMM;
     780                pParam->fUse |= DISUSE_REG_XMM;
    781781                pParam->base.reg_xmm = reg;
    782782                return 0;
    … …  
    807807                if (pCpu->mode != DISCPUMODE_64BIT)
    808808                {
    809                     pParam->flags |= DISUSE_DISPLACEMENT32;
     809                    pParam->fUse |= DISUSE_DISPLACEMENT32;
    810810                    pParam->uDisp.i32 = pCpu->i32SibDisp;
    811811                }
    812812                else
    813813                {
    814                     pParam->flags |= DISUSE_RIPDISPLACEMENT32;
     814                    pParam->fUse |= DISUSE_RIPDISPLACEMENT32;
    815815                    pParam->uDisp.i32 = pCpu->i32SibDisp;
    816816                }
    … …  
    818818            else
    819819            {   //register address
    820                 pParam->flags |= DISUSE_BASE;
     820                pParam->fUse |= DISUSE_BASE;
    821821                disasmModRMReg(pCpu, pOp, rm, pParam, 1);
    822822            }
    … …  
    829829            else
    830830            {
    831                 pParam->flags |= DISUSE_BASE;
     831                pParam->fUse |= DISUSE_BASE;
    832832                disasmModRMReg(pCpu, pOp, rm, pParam, 1);
    833833            }
    834834            pParam->uDisp.i8 = pCpu->i32SibDisp;
    835             pParam->flags |= DISUSE_DISPLACEMENT8;
     835            pParam->fUse |= DISUSE_DISPLACEMENT8;
    836836            break;
    837837
    … …  
    842842            else
    843843            {
    844                 pParam->flags |= DISUSE_BASE;
     844                pParam->fUse |= DISUSE_BASE;
    845845                disasmModRMReg(pCpu, pOp, rm, pParam, 1);
    846846            }
    847847            pParam->uDisp.i32 = pCpu->i32SibDisp;
    848             pParam->flags |= DISUSE_DISPLACEMENT32;
     848            pParam->fUse |= DISUSE_DISPLACEMENT32;
    849849            break;
    850850
    … …  
    862862            {//16 bits displacement
    863863                pParam->uDisp.i16 = pCpu->i32SibDisp;
    864                 pParam->flags |= DISUSE_DISPLACEMENT16;
     864                pParam->fUse |= DISUSE_DISPLACEMENT16;
    865865            }
    866866            else
    867867            {
    868                 pParam->flags |= DISUSE_BASE;
     868                pParam->fUse |= DISUSE_BASE;
    869869                disasmModRMReg16(pCpu, pOp, rm, pParam);
    870870            }
    … …  
    874874            disasmModRMReg16(pCpu, pOp, rm, pParam);
    875875            pParam->uDisp.i8 = pCpu->i32SibDisp;
    876             pParam->flags |= DISUSE_BASE | DISUSE_DISPLACEMENT8;
     876            pParam->fUse |= DISUSE_BASE | DISUSE_DISPLACEMENT8;
    877877            break;
    878878
    … …  
    880880            disasmModRMReg16(pCpu, pOp, rm, pParam);
    881881            pParam->uDisp.i16 = pCpu->i32SibDisp;
    882             pParam->flags |= DISUSE_BASE | DISUSE_DISPLACEMENT16;
     882            pParam->fUse |= DISUSE_BASE | DISUSE_DISPLACEMENT16;
    883883            break;
    884884
    … …  
    11651165    NOREF(pOp);
    11661166    pParam->parval = DISReadByte(pCpu, uCodePtr);
    1167     pParam->flags |= DISUSE_IMMEDIATE8;
     1167    pParam->fUse |= DISUSE_IMMEDIATE8;
    11681168    pParam->cb     = sizeof(uint8_t);
    11691169    return sizeof(uint8_t);
    … …  
    11841184    {
    11851185        pParam->parval = (uint32_t)(int8_t)DISReadByte(pCpu, uCodePtr);
    1186         pParam->flags |= DISUSE_IMMEDIATE32_SX8;
     1186        pParam->fUse |= DISUSE_IMMEDIATE32_SX8;
    11871187        pParam->cb     = sizeof(uint32_t);
    11881188    }
    … …  
    11911191    {
    11921192        pParam->parval = (uint64_t)(int8_t)DISReadByte(pCpu, uCodePtr);
    1193         pParam->flags |= DISUSE_IMMEDIATE64_SX8;
     1193        pParam->fUse |= DISUSE_IMMEDIATE64_SX8;
    11941194        pParam->cb     = sizeof(uint64_t);
    11951195    }
    … …  
    11971197    {
    11981198        pParam->parval = (uint16_t)(int8_t)DISReadByte(pCpu, uCodePtr);
    1199         pParam->flags |= DISUSE_IMMEDIATE16_SX8;
     1199        pParam->fUse |= DISUSE_IMMEDIATE16_SX8;
    12001200        pParam->cb     = sizeof(uint16_t);
    12011201    }
    … …  
    12151215    NOREF(pOp);
    12161216    pParam->parval = DISReadWord(pCpu, uCodePtr);
    1217     pParam->flags |= DISUSE_IMMEDIATE16;
     1217    pParam->fUse |= DISUSE_IMMEDIATE16;
    12181218    pParam->cb     = sizeof(uint16_t);
    12191219    return sizeof(uint16_t);
    … …  
    12321232    NOREF(pOp);
    12331233    pParam->parval = DISReadDWord(pCpu, uCodePtr);
    1234     pParam->flags |= DISUSE_IMMEDIATE32;
     1234    pParam->fUse |= DISUSE_IMMEDIATE32;
    12351235    pParam->cb     = sizeof(uint32_t);
    12361236    return sizeof(uint32_t);
    … …  
    12491249    NOREF(pOp);
    12501250    pParam->parval = DISReadQWord(pCpu, uCodePtr);
    1251     pParam->flags |= DISUSE_IMMEDIATE64;
     1251    pParam->fUse |= DISUSE_IMMEDIATE64;
    12521252    pParam->cb     = sizeof(uint64_t);
    12531253    return sizeof(uint64_t);
    … …  
    12681268    {
    12691269        pParam->parval = DISReadDWord(pCpu, uCodePtr);
    1270         pParam->flags |= DISUSE_IMMEDIATE32;
     1270        pParam->fUse |= DISUSE_IMMEDIATE32;
    12711271        pParam->cb     = sizeof(uint32_t);
    12721272        return sizeof(uint32_t);
    … …  
    12761276    {
    12771277        pParam->parval = DISReadQWord(pCpu, uCodePtr);
    1278         pParam->flags |= DISUSE_IMMEDIATE64;
     1278        pParam->fUse |= DISUSE_IMMEDIATE64;
    12791279        pParam->cb     = sizeof(uint64_t);
    12801280        return sizeof(uint64_t);
    … …  
    12821282
    12831283    pParam->parval = DISReadWord(pCpu, uCodePtr);
    1284     pParam->flags |= DISUSE_IMMEDIATE16;
     1284    pParam->fUse |= DISUSE_IMMEDIATE16;
    12851285    pParam->cb     = sizeof(uint16_t);
    12861286    return sizeof(uint16_t);
    … …  
    13061306    {
    13071307        pParam->parval = DISReadWord(pCpu, uCodePtr);
    1308         pParam->flags |= DISUSE_IMMEDIATE16;
     1308        pParam->fUse |= DISUSE_IMMEDIATE16;
    13091309        pParam->cb     = sizeof(uint16_t);
    13101310        return sizeof(uint16_t);
    … …  
    13151315    {
    13161316        pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, uCodePtr);
    1317         pParam->flags |= DISUSE_IMMEDIATE64;
     1317        pParam->fUse |= DISUSE_IMMEDIATE64;
    13181318        pParam->cb     = sizeof(uint64_t);
    13191319    }
    … …  
    13211321    {
    13221322        pParam->parval = DISReadDWord(pCpu, uCodePtr);
    1323         pParam->flags |= DISUSE_IMMEDIATE32;
     1323        pParam->fUse |= DISUSE_IMMEDIATE32;
    13241324        pParam->cb     = sizeof(uint32_t);
    13251325    }
    … …  
    13441344    NOREF(pOp);
    13451345    pParam->parval = DISReadByte(pCpu, uCodePtr);
    1346     pParam->flags |= DISUSE_IMMEDIATE8_REL;
     1346    pParam->fUse |= DISUSE_IMMEDIATE8_REL;
    13471347    pParam->cb     = sizeof(uint8_t);
    13481348    return sizeof(char);
    … …  
    13651365    {
    13661366        pParam->parval = DISReadDWord(pCpu, uCodePtr);
    1367         pParam->flags |= DISUSE_IMMEDIATE32_REL;
     1367        pParam->fUse |= DISUSE_IMMEDIATE32_REL;
    13681368        pParam->cb     = sizeof(int32_t);
    13691369        return sizeof(int32_t);
    … …  
    13741374        /* 32 bits relative immediate sign extended to 64 bits. */
    13751375        pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, uCodePtr);
    1376         pParam->flags |= DISUSE_IMMEDIATE64_REL;
     1376        pParam->fUse |= DISUSE_IMMEDIATE64_REL;
    13771377        pParam->cb     = sizeof(int64_t);
    13781378        return sizeof(int32_t);
    … …  
    13801380
    13811381    pParam->parval = DISReadWord(pCpu, uCodePtr);
    1382     pParam->flags |= DISUSE_IMMEDIATE16_REL;
     1382    pParam->fUse |= DISUSE_IMMEDIATE16_REL;
    13831383    pParam->cb     = sizeof(int16_t);
    13841384    return sizeof(int16_t);
    … …  
    14061406            pParam->parval = DISReadDWord(pCpu, uCodePtr);
    14071407            *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, uCodePtr+sizeof(uint32_t));
    1408             pParam->flags  |= DISUSE_IMMEDIATE_ADDR_16_32;
     1408            pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
    14091409            pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
    14101410            return sizeof(uint32_t) + sizeof(uint16_t);
    … …  
    14181418         */
    14191419        pParam->uDisp.i32 = DISReadDWord(pCpu, uCodePtr);
    1420         pParam->flags |= DISUSE_DISPLACEMENT32;
     1420        pParam->fUse |= DISUSE_DISPLACEMENT32;
    14211421        pParam->cb     = sizeof(uint32_t);
    14221422        return sizeof(uint32_t);
    … …  
    14331433         */
    14341434        pParam->uDisp.i64 = DISReadQWord(pCpu, uCodePtr);
    1435         pParam->flags |= DISUSE_DISPLACEMENT64;
     1435        pParam->fUse |= DISUSE_DISPLACEMENT64;
    14361436        pParam->cb     = sizeof(uint64_t);
    14371437        return sizeof(uint64_t);
    … …  
    14411441        /* far 16:16 pointer */
    14421442        pParam->parval = DISReadDWord(pCpu, uCodePtr);
    1443         pParam->flags |= DISUSE_IMMEDIATE_ADDR_16_16;
     1443        pParam->fUse |= DISUSE_IMMEDIATE_ADDR_16_16;
    14441444        pParam->cb     = 2*sizeof(uint16_t);
    14451445        return sizeof(uint32_t);
    … …  
    14531453     */
    14541454    pParam->uDisp.i16 = DISReadWord(pCpu, uCodePtr);
    1455     pParam->flags |= DISUSE_DISPLACEMENT16;
     1455    pParam->fUse |= DISUSE_DISPLACEMENT16;
    14561456    pParam->cb     = sizeof(uint16_t);
    14571457    return sizeof(uint16_t);
    … …  
    15021502        pParam->parval = DISReadDWord(pCpu, uCodePtr);
    15031503        *((uint32_t*)&pParam->parval+1) = DISReadWord(pCpu, uCodePtr+sizeof(uint32_t));
    1504         pParam->flags  |= DISUSE_IMMEDIATE_ADDR_16_32;
     1504        pParam->fUse   |= DISUSE_IMMEDIATE_ADDR_16_32;
    15051505        pParam->cb     = sizeof(uint16_t) + sizeof(uint32_t);
    15061506        return sizeof(uint32_t) + sizeof(uint16_t);
    … …  
    15091509    // far 16:16 pointer
    15101510    pParam->parval = DISReadDWord(pCpu, uCodePtr);
    1511     pParam->flags |= DISUSE_IMMEDIATE_ADDR_16_16;
     1511    pParam->fUse |= DISUSE_IMMEDIATE_ADDR_16_16;
    15121512    pParam->cb     = 2*sizeof(uint16_t);
    15131513    return sizeof(uint32_t);
    … …  
    15601560            /* Use 32-bit registers. */
    15611561            pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN32_START;
    1562             pParam->flags |= DISUSE_REG_GEN32;
     1562            pParam->fUse |= DISUSE_REG_GEN32;
    15631563            pParam->cb     = 4;
    15641564        }
    … …  
    15741574                pParam->base.reg_gen += 8;
    15751575
    1576             pParam->flags |= DISUSE_REG_GEN64;
     1576            pParam->fUse |= DISUSE_REG_GEN64;
    15771577            pParam->cb     = 8;
    15781578        }
    … …  
    15811581            /* Use 16-bit registers. */
    15821582            pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN32_START;
    1583             pParam->flags |= DISUSE_REG_GEN16;
     1583            pParam->fUse |= DISUSE_REG_GEN16;
    15841584            pParam->cb     = 2;
    15851585            pParam->param = pParam->param - OP_PARM_REG_GEN32_START + OP_PARM_REG_GEN16_START;
    … …  
    15911591        /* Segment ES..GS registers. */
    15921592        pParam->base.reg_seg = (DIS_SELREG)(pParam->param - OP_PARM_REG_SEG_START);
    1593         pParam->flags |= DISUSE_REG_SEG;
     1593        pParam->fUse |= DISUSE_REG_SEG;
    15941594        pParam->cb     = 2;
    15951595    }
    … …  
    15991599        /* 16-bit AX..DI registers. */
    16001600        pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN16_START;
    1601         pParam->flags |= DISUSE_REG_GEN16;
     1601        pParam->fUse |= DISUSE_REG_GEN16;
    16021602        pParam->cb     = 2;
    16031603    }
    … …  
    16071607        /* 8-bit AL..DL, AH..DH registers. */
    16081608        pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN8_START;
    1609         pParam->flags |= DISUSE_REG_GEN8;
     1609        pParam->fUse |= DISUSE_REG_GEN8;
    16101610        pParam->cb     = 1;
    16111611
    … …  
    16241624        /* FPU registers. */
    16251625        pParam->base.reg_fp = pParam->param - OP_PARM_REG_FP_START;
    1626         pParam->flags |= DISUSE_REG_FP;
     1626        pParam->fUse |= DISUSE_REG_FP;
    16271627        pParam->cb     = 10;
    16281628    }
    … …  
    16391639    NOREF(uCodePtr);
    16401640
    1641     pParam->flags |= DISUSE_POINTER_DS_BASED;
     1641    pParam->fUse |= DISUSE_POINTER_DS_BASED;
    16421642    if (pCpu->addrmode == DISCPUMODE_32BIT)
    16431643    {
    16441644        pParam->base.reg_gen = USE_REG_ESI;
    1645         pParam->flags |= DISUSE_REG_GEN32;
     1645        pParam->fUse |= DISUSE_REG_GEN32;
    16461646    }
    16471647    else
    … …  
    16491649    {
    16501650        pParam->base.reg_gen = USE_REG_RSI;
    1651         pParam->flags |= DISUSE_REG_GEN64;
     1651        pParam->fUse |= DISUSE_REG_GEN64;
    16521652    }
    16531653    else
    16541654    {
    16551655        pParam->base.reg_gen = USE_REG_SI;
    1656         pParam->flags |= DISUSE_REG_GEN16;
     1656        pParam->fUse |= DISUSE_REG_GEN16;
    16571657    }
    16581658    return 0;   //no additional opcode bytes
    … …  
    16641664    NOREF(uCodePtr); NOREF(pOp);
    16651665
    1666     pParam->flags |= DISUSE_POINTER_DS_BASED;
     1666    pParam->fUse |= DISUSE_POINTER_DS_BASED;
    16671667    if (pCpu->addrmode == DISCPUMODE_32BIT)
    16681668    {
    16691669        pParam->base.reg_gen = USE_REG_ESI;
    1670         pParam->flags |= DISUSE_REG_GEN32;
     1670        pParam->fUse |= DISUSE_REG_GEN32;
    16711671    }
    16721672    else
    … …  
    16741674    {
    16751675        pParam->base.reg_gen = USE_REG_RSI;
    1676         pParam->flags |= DISUSE_REG_GEN64;
     1676        pParam->fUse |= DISUSE_REG_GEN64;
    16771677    }
    16781678    else
    16791679    {
    16801680        pParam->base.reg_gen = USE_REG_SI;
    1681         pParam->flags |= DISUSE_REG_GEN16;
     1681        pParam->fUse |= DISUSE_REG_GEN16;
    16821682    }
    16831683    return 0;   //no additional opcode bytes
    … …  
    16891689    NOREF(uCodePtr);
    16901690
    1691     pParam->flags |= DISUSE_POINTER_ES_BASED;
     1691    pParam->fUse |= DISUSE_POINTER_ES_BASED;
    16921692    if (pCpu->addrmode == DISCPUMODE_32BIT)
    16931693    {
    16941694        pParam->base.reg_gen = USE_REG_EDI;
    1695         pParam->flags |= DISUSE_REG_GEN32;
     1695        pParam->fUse |= DISUSE_REG_GEN32;
    16961696    }
    16971697    else
    … …  
    16991699    {
    17001700        pParam->base.reg_gen = USE_REG_RDI;
    1701         pParam->flags |= DISUSE_REG_GEN64;
     1701        pParam->fUse |= DISUSE_REG_GEN64;
    17021702    }
    17031703    else
    17041704    {
    17051705        pParam->base.reg_gen = USE_REG_DI;
    1706         pParam->flags |= DISUSE_REG_GEN16;
     1706        pParam->fUse |= DISUSE_REG_GEN16;
    17071707    }
    17081708    return 0;   //no additional opcode bytes
    … …  
    17141714    NOREF(uCodePtr); NOREF(pOp);
    17151715
    1716     pParam->flags |= DISUSE_POINTER_ES_BASED;
     1716    pParam->fUse |= DISUSE_POINTER_ES_BASED;
    17171717    if (pCpu->addrmode == DISCPUMODE_32BIT)
    17181718    {
    17191719        pParam->base.reg_gen = USE_REG_EDI;
    1720         pParam->flags |= DISUSE_REG_GEN32;
     1720        pParam->fUse |= DISUSE_REG_GEN32;
    17211721    }
    17221722    else
    … …  
    17241724    {
    17251725        pParam->base.reg_gen = USE_REG_RDI;
    1726         pParam->flags |= DISUSE_REG_GEN64;
     1726        pParam->fUse |= DISUSE_REG_GEN64;
    17271727    }
    17281728    else
    17291729    {
    17301730        pParam->base.reg_gen = USE_REG_DI;
    1731         pParam->flags |= DISUSE_REG_GEN16;
     1731        pParam->fUse |= DISUSE_REG_GEN16;
    17321732    }
    17331733    return 0;   //no additional opcode bytes
    … …  
    23412341        }
    23422342
    2343         pParam->flags |= DISUSE_REG_GEN8;
     2343        pParam->fUse |= DISUSE_REG_GEN8;
    23442344        pParam->base.reg_gen = idx;
    23452345        break;
    … …  
    23482348        Assert(idx < (pCpu->prefix & DISPREFIX_REX) ? 16 : 8);
    23492349
    2350         pParam->flags |= DISUSE_REG_GEN16;
     2350        pParam->fUse |= DISUSE_REG_GEN16;
    23512351        pParam->base.reg_gen = idx;
    23522352        break;
    … …  
    23552355        Assert(idx < (pCpu->prefix & DISPREFIX_REX) ? 16 : 8);
    23562356
    2357         pParam->flags |= DISUSE_REG_GEN32;
     2357        pParam->fUse |= DISUSE_REG_GEN32;
    23582358        pParam->base.reg_gen = idx;
    23592359        break;
    23602360
    23612361    case OP_PARM_q:
    2362         pParam->flags |= DISUSE_REG_GEN64;
     2362        pParam->fUse |= DISUSE_REG_GEN64;
    23632363        pParam->base.reg_gen = idx;
    23642364        break;
    … …  
    23752375{
    23762376    NOREF(pCpu); NOREF(pOp);
    2377     pParam->flags |= DISUSE_REG_GEN16;
     2377    pParam->fUse |= DISUSE_REG_GEN16;
    23782378    pParam->base.reg_gen = BaseModRMReg16[idx];
    23792379    if (idx < 4)
    23802380    {
    2381         pParam->flags |= DISUSE_INDEX;
     2381        pParam->fUse |= DISUSE_INDEX;
    23822382        pParam->index.reg_gen = IndexModRMReg16[idx];
    23832383    }
    … …  
    23952395    }
    23962396
    2397     pParam->flags |= DISUSE_REG_SEG;
     2397    pParam->fUse |= DISUSE_REG_SEG;
    23982398    pParam->base.reg_seg = (DIS_SELREG)idx;
    23992399}
    … …  
    26552655        case OP_XCHG:
    26562656        case OP_XOR:
    2657             if (pCpu->param1.flags & (DISUSE_BASE | DISUSE_INDEX | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT8 | DISUSE_RIPDISPLACEMENT32))
     2657            if (pCpu->param1.fUse & (DISUSE_BASE | DISUSE_INDEX | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32
     2658                                     | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT8 | DISUSE_RIPDISPLACEMENT32))
    26582659                return;
    26592660            break;

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

    r41676 r41678  
    9393static const char *disasmFormatYasmBaseReg(PCDISCPUSTATE pCpu, PCOP_PARAMETER pParam, size_t *pcchReg)
    9494{
    95     switch (pParam->flags & (  DISUSE_REG_GEN8 | DISUSE_REG_GEN16 | DISUSE_REG_GEN32 | DISUSE_REG_GEN64
    96                              | DISUSE_REG_FP   | DISUSE_REG_MMX   | DISUSE_REG_XMM   | DISUSE_REG_CR
    97                              | DISUSE_REG_DBG  | DISUSE_REG_SEG   | DISUSE_REG_TEST))
     95    switch (pParam->fUse & (  DISUSE_REG_GEN8 | DISUSE_REG_GEN16 | DISUSE_REG_GEN32 | DISUSE_REG_GEN64
     96                            | DISUSE_REG_FP   | DISUSE_REG_MMX   | DISUSE_REG_XMM   | DISUSE_REG_CR
     97                            | DISUSE_REG_DBG  | DISUSE_REG_SEG   | DISUSE_REG_TEST))
    9898
    9999    {
    … …  
    187187
    188188        default:
    189             AssertMsgFailed(("%#x\n", pParam->flags));
     189            AssertMsgFailed(("%#x\n", pParam->fUse));
    190190            *pcchReg = 3;
    191191            return "r??";
    … …  
    231231
    232232        default:
    233             AssertMsgFailed(("%#x %#x\n", pParam->flags, pCpu->addrmode));
     233            AssertMsgFailed(("%#x %#x\n", pParam->fUse, pCpu->addrmode));
    234234            *pcchReg = 3;
    235235            return "r??";
    … …  
    591591                        break; \
    592592                    case OP_PARM_p: break; /* see PUT_FAR */ \
    593                     case OP_PARM_s: if (pParam->flags & DISUSE_REG_FP) PUT_SZ("tword "); break; /* ?? */ \
     593                    case OP_PARM_s: if (pParam->fUse & DISUSE_REG_FP) PUT_SZ("tword "); break; /* ?? */ \
    594594                    case OP_PARM_z: break; \
    595595                    case OP_PARM_NONE: \
    596596                        if (    OP_PARM_VTYPE(pParam->param) == OP_PARM_M \
    597                             &&  ((pParam->flags & DISUSE_REG_FP) || pOp->opcode == OP_FLD)) \
     597                            &&  ((pParam->fUse & DISUSE_REG_FP) || pOp->opcode == OP_FLD)) \
    598598                            PUT_SZ("tword "); \
    599599                        break; \
    … …  
    613613         */
    614614        if (    (pCpu->prefix & DISPREFIX_SEG)
    615             &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.flags)
    616             &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.flags)
    617             &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param3.flags))
     615            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.fUse)
     616            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.fUse)
     617            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param3.fUse))
    618618        {
    619619            PUT_STR(s_szSegPrefix[pCpu->enmPrefixSeg], 2);
    … …  
    647647                    {
    648648                        pszFmt += RT_C_IS_ALPHA(pszFmt[0]) ? RT_C_IS_ALPHA(pszFmt[1]) ? 2 : 1 : 0;
    649                         Assert(!(pParam->flags & (DISUSE_INDEX | DISUSE_SCALE) /* No SIB here... */));
    650                         Assert(!(pParam->flags & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32)));
     649                        Assert(!(pParam->fUse & (DISUSE_INDEX | DISUSE_SCALE) /* No SIB here... */));
     650                        Assert(!(pParam->fUse & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32)));
    651651
    652652                        size_t cchReg;
    … …  
    668668
    669669                        PUT_FAR();
    670                         if (DISUSE_IS_EFFECTIVE_ADDR(pParam->flags))
     670                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse))
    671671                        {
    672672                            /* Work around mov seg,[mem16]  and mov [mem16],seg as these always make a 16-bit mem
    … …  
    680680                        }
    681681                        if (    (fFlags & DIS_FMT_FLAGS_STRICT)
    682                             &&  (pParam->flags & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32)))
     682                            &&  (pParam->fUse & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32)))
    683683                        {
    684                             if (   (pParam->flags & DISUSE_DISPLACEMENT8)
     684                            if (   (pParam->fUse & DISUSE_DISPLACEMENT8)
    685685                                && !pParam->uDisp.i8)
    686686                                PUT_SZ("byte ");
    687                             else if (   (pParam->flags & DISUSE_DISPLACEMENT16)
     687                            else if (   (pParam->fUse & DISUSE_DISPLACEMENT16)
    688688                                     && (int8_t)pParam->uDisp.i16 == (int16_t)pParam->uDisp.i16)
    689689                                PUT_SZ("word ");
    690                             else if (   (pParam->flags & DISUSE_DISPLACEMENT32)
     690                            else if (   (pParam->fUse & DISUSE_DISPLACEMENT32)
    691691                                     && (int16_t)pParam->uDisp.i32 == (int32_t)pParam->uDisp.i32) //??
    692692                                PUT_SZ("dword ");
    693                             else if (   (pParam->flags & DISUSE_DISPLACEMENT64)
     693                            else if (   (pParam->fUse & DISUSE_DISPLACEMENT64)
    694694                                     && (pCpu->SIB.Bits.Base != 5 || pCpu->ModRM.Bits.Mod != 0)
    695695                                     && (int32_t)pParam->uDisp.i64 == (int64_t)pParam->uDisp.i64) //??
    696696                                PUT_SZ("qword ");
    697697                        }
    698                         if (DISUSE_IS_EFFECTIVE_ADDR(pParam->flags))
     698                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse))
    699699                            PUT_SEGMENT_OVERRIDE();
    700700
    701                         bool fBase =  (pParam->flags & DISUSE_BASE) /* When exactly is DISUSE_BASE supposed to be set? disasmModRMReg doesn't set it. */
    702                                    || (   (pParam->flags & (DISUSE_REG_GEN8 | DISUSE_REG_GEN16 | DISUSE_REG_GEN32 | DISUSE_REG_GEN64))
    703                                        && !DISUSE_IS_EFFECTIVE_ADDR(pParam->flags));
     701                        bool fBase =  (pParam->fUse & DISUSE_BASE) /* When exactly is DISUSE_BASE supposed to be set? disasmModRMReg doesn't set it. */
     702                                   || (   (pParam->fUse & (DISUSE_REG_GEN8 | DISUSE_REG_GEN16 | DISUSE_REG_GEN32 | DISUSE_REG_GEN64))
     703                                       && !DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse));
    704704                        if (fBase)
    705705                        {
    … …  
    709709                        }
    710710
    711                         if (pParam->flags & DISUSE_INDEX)
     711                        if (pParam->fUse & DISUSE_INDEX)
    712712                        {
    713713                            if (fBase)
    … …  
    718718                            PUT_STR(pszReg, cchReg);
    719719
    720                             if (pParam->flags & DISUSE_SCALE)
     720                            if (pParam->fUse & DISUSE_SCALE)
    721721                            {
    722722                                PUT_C('*');
    … …  
    725725                        }
    726726                        else
    727                             Assert(!(pParam->flags & DISUSE_SCALE));
    728 
    729                         if (pParam->flags & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32))
     727                            Assert(!(pParam->fUse & DISUSE_SCALE));
     728
     729                        if (pParam->fUse & (DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_RIPDISPLACEMENT32))
    730730                        {
    731731                            int64_t off2;
    732                             if (pParam->flags & DISUSE_DISPLACEMENT8)
     732                            if (pParam->fUse & DISUSE_DISPLACEMENT8)
    733733                                off2 = pParam->uDisp.i8;
    734                             else if (pParam->flags & DISUSE_DISPLACEMENT16)
     734                            else if (pParam->fUse & DISUSE_DISPLACEMENT16)
    735735                                off2 = pParam->uDisp.i16;
    736                             else if (pParam->flags & (DISUSE_DISPLACEMENT32 | DISUSE_RIPDISPLACEMENT32))
     736                            else if (pParam->fUse & (DISUSE_DISPLACEMENT32 | DISUSE_RIPDISPLACEMENT32))
    737737                                off2 = pParam->uDisp.i32;
    738                             else if (pParam->flags & DISUSE_DISPLACEMENT64)
     738                            else if (pParam->fUse & DISUSE_DISPLACEMENT64)
    739739                                off2 = pParam->uDisp.i64;
    740740                            else
    … …  
    744744                            }
    745745
    746                             if (fBase || (pParam->flags & DISUSE_INDEX))
     746                            if (fBase || (pParam->fUse & DISUSE_INDEX))
    747747                            {
    748748                                PUT_C(off2 >= 0 ? '+' : '-');
    … …  
    750750                                    off2 = -off2;
    751751                            }
    752                             if (pParam->flags & DISUSE_DISPLACEMENT8)
     752                            if (pParam->fUse & DISUSE_DISPLACEMENT8)
    753753                                PUT_NUM_8( off2);
    754                             else if (pParam->flags & DISUSE_DISPLACEMENT16)
     754                            else if (pParam->fUse & DISUSE_DISPLACEMENT16)
    755755                                PUT_NUM_16(off2);
    756                             else if (pParam->flags & DISUSE_DISPLACEMENT32)
     756                            else if (pParam->fUse & DISUSE_DISPLACEMENT32)
    757757                                PUT_NUM_32(off2);
    758                             else if (pParam->flags & DISUSE_DISPLACEMENT64)
     758                            else if (pParam->fUse & DISUSE_DISPLACEMENT64)
    759759                                PUT_NUM_64(off2);
    760760                            else
    … …  
    765765                        }
    766766
    767                         if (DISUSE_IS_EFFECTIVE_ADDR(pParam->flags))
     767                        if (DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse))
    768768                            PUT_C(']');
    769769                        break;
    … …  
    776776                    case 'I': /* Immediate data (ParseImmByte, ParseImmByteSX, ParseImmV, ParseImmUshort, ParseImmZ). */
    777777                        Assert(*pszFmt == 'b' || *pszFmt == 'v' || *pszFmt == 'w' || *pszFmt == 'z'); pszFmt++;
    778                         switch (pParam->flags & (  DISUSE_IMMEDIATE8 | DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE64
    779                                                  | DISUSE_IMMEDIATE16_SX8 | DISUSE_IMMEDIATE32_SX8 | DISUSE_IMMEDIATE64_SX8))
     778                        switch (pParam->fUse & (  DISUSE_IMMEDIATE8 | DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE64
     779                                                | DISUSE_IMMEDIATE16_SX8 | DISUSE_IMMEDIATE32_SX8 | DISUSE_IMMEDIATE64_SX8))
    780780                        {
    781781                            case DISUSE_IMMEDIATE8:
    … …  
    862862                            fFlags &= ~DIS_FMT_FLAGS_RELATIVE_BRANCH;
    863863
    864                         if (pParam->flags & DISUSE_IMMEDIATE8_REL)
     864                        if (pParam->fUse & DISUSE_IMMEDIATE8_REL)
    865865                        {
    866866                            if (fPrefix)
    … …  
    872872                                PUT_NUM_S8(offDisplacement);
    873873                        }
    874                         else if (pParam->flags & DISUSE_IMMEDIATE16_REL)
     874                        else if (pParam->fUse & DISUSE_IMMEDIATE16_REL)
    875875                        {
    876876                            if (fPrefix)
    … …  
    887887                                PUT_SZ("near ");
    888888                            offDisplacement = (int32_t)pParam->parval;
    889                             Assert(pParam->flags & (DISUSE_IMMEDIATE32_REL|DISUSE_IMMEDIATE64_REL));
     889                            Assert(pParam->fUse & (DISUSE_IMMEDIATE32_REL|DISUSE_IMMEDIATE64_REL));
    890890                            Assert(*pszFmt == 'v'); pszFmt++;
    891891
    … …  
    938938                        PUT_SEGMENT_OVERRIDE();
    939939                        int rc = VERR_SYMBOL_NOT_FOUND;
    940                         switch (pParam->flags & (DISUSE_IMMEDIATE_ADDR_16_16 | DISUSE_IMMEDIATE_ADDR_16_32 | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT16))
     940                        switch (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_16 | DISUSE_IMMEDIATE_ADDR_16_32 | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT16))
    941941                        {
    942942                            case DISUSE_IMMEDIATE_ADDR_16_16:
    … …  
    10021002                        PUT_SEGMENT_OVERRIDE();
    10031003                        int rc = VERR_SYMBOL_NOT_FOUND;
    1004                         switch (pParam->flags & (DISUSE_IMMEDIATE_ADDR_16_16 | DISUSE_IMMEDIATE_ADDR_16_32 | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT16))
     1004                        switch (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_16 | DISUSE_IMMEDIATE_ADDR_16_32 | DISUSE_DISPLACEMENT64 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT16))
    10051005                        {
    10061006                            case DISUSE_IMMEDIATE_ADDR_16_16:
    … …  
    10661066                        PUT_SIZE_OVERRIDE();
    10671067                        PUT_C('[');
    1068                         if (pParam->flags & DISUSE_POINTER_DS_BASED)
     1068                        if (pParam->fUse & DISUSE_POINTER_DS_BASED)
    10691069                            PUT_SZ("ds:");
    10701070                        else
    … …  
    12811281        /* no effective address which it may apply to. */
    12821282        Assert((pCpu->prefix & DISPREFIX_SEG) || pCpu->mode == DISCPUMODE_64BIT);
    1283         if (    !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.flags)
    1284             &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.flags)
    1285             &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param3.flags))
     1283        if (    !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.fUse)
     1284            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.fUse)
     1285            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param3.fUse))
    12861286            return true;
    12871287    }

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

    r41676 r41678  
    268268    {
    269269        /* Guess segment register by parameter type. */
    270         if (pParam->flags & (DISUSE_REG_GEN32|DISUSE_REG_GEN64|DISUSE_REG_GEN16))
     270        if (pParam->fUse & (DISUSE_REG_GEN32|DISUSE_REG_GEN64|DISUSE_REG_GEN16))
    271271        {
    272272            AssertCompile(USE_REG_ESP == USE_REG_RSP);
    … …  
    509509    memset(pParamVal, 0, sizeof(*pParamVal));
    510510
    511     if (DISUSE_IS_EFFECTIVE_ADDR(pParam->flags))
     511    if (DISUSE_IS_EFFECTIVE_ADDR(pParam->fUse))
    512512    {
    513513        // Effective address
    … …  
    515515        pParamVal->size = pParam->cb;
    516516
    517         if (pParam->flags & DISUSE_BASE)
    518         {
    519             if (pParam->flags & DISUSE_REG_GEN8)
     517        if (pParam->fUse & DISUSE_BASE)
     518        {
     519            if (pParam->fUse & DISUSE_REG_GEN8)
    520520            {
    521521                pParamVal->flags |= PARAM_VAL8;
    … …  
    523523            }
    524524            else
    525             if (pParam->flags & DISUSE_REG_GEN16)
     525            if (pParam->fUse & DISUSE_REG_GEN16)
    526526            {
    527527                pParamVal->flags |= PARAM_VAL16;
    … …  
    529529            }
    530530            else
    531             if (pParam->flags & DISUSE_REG_GEN32)
     531            if (pParam->fUse & DISUSE_REG_GEN32)
    532532            {
    533533                pParamVal->flags |= PARAM_VAL32;
    … …  
    535535            }
    536536            else
    537             if (pParam->flags & DISUSE_REG_GEN64)
     537            if (pParam->fUse & DISUSE_REG_GEN64)
    538538            {
    539539                pParamVal->flags |= PARAM_VAL64;
    … …  
    547547        }
    548548        // Note that scale implies index (SIB byte)
    549         if (pParam->flags & DISUSE_INDEX)
    550         {
    551             if (pParam->flags & DISUSE_REG_GEN16)
     549        if (pParam->fUse & DISUSE_INDEX)
     550        {
     551            if (pParam->fUse & DISUSE_REG_GEN16)
    552552            {
    553553                uint16_t val16;
    … …  
    556556                if (RT_FAILURE(DISFetchReg16(pCtx, pParam->index.reg_gen, &val16))) return VERR_INVALID_PARAMETER;
    557557
    558                 Assert(!(pParam->flags & DISUSE_SCALE));   /* shouldn't be possible in 16 bits mode */
     558                Assert(!(pParam->fUse & DISUSE_SCALE));   /* shouldn't be possible in 16 bits mode */
    559559
    560560                pParamVal->val.val16 += val16;
    561561            }
    562562            else
    563             if (pParam->flags & DISUSE_REG_GEN32)
     563            if (pParam->fUse & DISUSE_REG_GEN32)
    564564            {
    565565                uint32_t val32;
    … …  
    568568                if (RT_FAILURE(DISFetchReg32(pCtx, pParam->index.reg_gen, &val32))) return VERR_INVALID_PARAMETER;
    569569
    570                 if (pParam->flags & DISUSE_SCALE)
     570                if (pParam->fUse & DISUSE_SCALE)
    571571                    val32 *= pParam->scale;
    572572
    … …  
    574574            }
    575575            else
    576             if (pParam->flags & DISUSE_REG_GEN64)
     576            if (pParam->fUse & DISUSE_REG_GEN64)
    577577            {
    578578                uint64_t val64;
    … …  
    581581                if (RT_FAILURE(DISFetchReg64(pCtx, pParam->index.reg_gen, &val64))) return VERR_INVALID_PARAMETER;
    582582
    583                 if (pParam->flags & DISUSE_SCALE)
     583                if (pParam->fUse & DISUSE_SCALE)
    584584                    val64 *= pParam->scale;
    585585
    … …  
    590590        }
    591591
    592         if (pParam->flags & DISUSE_DISPLACEMENT8)
     592        if (pParam->fUse & DISUSE_DISPLACEMENT8)
    593593        {
    594594            if (pCpu->mode == DISCPUMODE_32BIT)
    … …  
    601601        }
    602602        else
    603         if (pParam->flags & DISUSE_DISPLACEMENT16)
     603        if (pParam->fUse & DISUSE_DISPLACEMENT16)
    604604        {
    605605            if (pCpu->mode == DISCPUMODE_32BIT)
    … …  
    612612        }
    613613        else
    614         if (pParam->flags & DISUSE_DISPLACEMENT32)
     614        if (pParam->fUse & DISUSE_DISPLACEMENT32)
    615615        {
    616616            if (pCpu->mode == DISCPUMODE_32BIT)
    … …  
    620620        }
    621621        else
    622         if (pParam->flags & DISUSE_DISPLACEMENT64)
     622        if (pParam->fUse & DISUSE_DISPLACEMENT64)
    623623        {
    624624            Assert(pCpu->mode == DISCPUMODE_64BIT);
    … …  
    626626        }
    627627        else
    628         if (pParam->flags & DISUSE_RIPDISPLACEMENT32)
     628        if (pParam->fUse & DISUSE_RIPDISPLACEMENT32)
    629629        {
    630630            Assert(pCpu->mode == DISCPUMODE_64BIT);
    … …  
    635635    }
    636636
    637     if (pParam->flags & (DISUSE_REG_GEN8|DISUSE_REG_GEN16|DISUSE_REG_GEN32|DISUSE_REG_GEN64|DISUSE_REG_FP|DISUSE_REG_MMX|DISUSE_REG_XMM|DISUSE_REG_CR|DISUSE_REG_DBG|DISUSE_REG_SEG|DISUSE_REG_TEST))
     637    if (pParam->fUse & (DISUSE_REG_GEN8|DISUSE_REG_GEN16|DISUSE_REG_GEN32|DISUSE_REG_GEN64|DISUSE_REG_FP|DISUSE_REG_MMX|DISUSE_REG_XMM|DISUSE_REG_CR|DISUSE_REG_DBG|DISUSE_REG_SEG|DISUSE_REG_TEST))
    638638    {
    639639        if (parmtype == PARAM_DEST)
    … …  
    648648        pParamVal->type = PARMTYPE_IMMEDIATE;
    649649
    650         if (pParam->flags & DISUSE_REG_GEN8)
     650        if (pParam->fUse & DISUSE_REG_GEN8)
    651651        {
    652652            pParamVal->flags |= PARAM_VAL8;
    … …  
    655655        }
    656656        else
    657         if (pParam->flags & DISUSE_REG_GEN16)
     657        if (pParam->fUse & DISUSE_REG_GEN16)
    658658        {
    659659            pParamVal->flags |= PARAM_VAL16;
    … …  
    662662        }
    663663        else
    664         if (pParam->flags & DISUSE_REG_GEN32)
     664        if (pParam->fUse & DISUSE_REG_GEN32)
    665665        {
    666666            pParamVal->flags |= PARAM_VAL32;
    … …  
    669669        }
    670670        else
    671         if (pParam->flags & DISUSE_REG_GEN64)
     671        if (pParam->fUse & DISUSE_REG_GEN64)
    672672        {
    673673            pParamVal->flags |= PARAM_VAL64;
    … …  
    680680            pParamVal->type = PARMTYPE_REGISTER;
    681681        }
    682         Assert(!(pParam->flags & DISUSE_IMMEDIATE));
     682        Assert(!(pParam->fUse & DISUSE_IMMEDIATE));
    683683        return VINF_SUCCESS;
    684684    }
    685685
    686     if (pParam->flags & DISUSE_IMMEDIATE)
     686    if (pParam->fUse & DISUSE_IMMEDIATE)
    687687    {
    688688        pParamVal->type = PARMTYPE_IMMEDIATE;
    689         if (pParam->flags & (DISUSE_IMMEDIATE8|DISUSE_IMMEDIATE8_REL))
     689        if (pParam->fUse & (DISUSE_IMMEDIATE8|DISUSE_IMMEDIATE8_REL))
    690690        {
    691691            pParamVal->flags |= PARAM_VAL8;
    … …  
    702702        }
    703703        else
    704         if (pParam->flags & (DISUSE_IMMEDIATE16|DISUSE_IMMEDIATE16_REL|DISUSE_IMMEDIATE_ADDR_0_16|DISUSE_IMMEDIATE16_SX8))
     704        if (pParam->fUse & (DISUSE_IMMEDIATE16|DISUSE_IMMEDIATE16_REL|DISUSE_IMMEDIATE_ADDR_0_16|DISUSE_IMMEDIATE16_SX8))
    705705        {
    706706            pParamVal->flags |= PARAM_VAL16;
    707707            pParamVal->size   = sizeof(uint16_t);
    708708            pParamVal->val.val16 = (uint16_t)pParam->parval;
    709             AssertMsg(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & DISUSE_IMMEDIATE16_SX8)), ("pParamVal->size %d vs %d EIP=%RX32\n", pParamVal->size, pParam->cb, pCtx->eip) );
    710         }
    711         else
    712         if (pParam->flags & (DISUSE_IMMEDIATE32|DISUSE_IMMEDIATE32_REL|DISUSE_IMMEDIATE_ADDR_0_32|DISUSE_IMMEDIATE32_SX8))
     709            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) );
     710        }
     711        else
     712        if (pParam->fUse & (DISUSE_IMMEDIATE32|DISUSE_IMMEDIATE32_REL|DISUSE_IMMEDIATE_ADDR_0_32|DISUSE_IMMEDIATE32_SX8))
    713713        {
    714714            pParamVal->flags |= PARAM_VAL32;
    715715            pParamVal->size   = sizeof(uint32_t);
    716716            pParamVal->val.val32 = (uint32_t)pParam->parval;
    717             Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & DISUSE_IMMEDIATE32_SX8)) );
    718         }
    719         else
    720         if (pParam->flags & (DISUSE_IMMEDIATE64 | DISUSE_IMMEDIATE64_REL | DISUSE_IMMEDIATE64_SX8))
     717            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->fUse & DISUSE_IMMEDIATE32_SX8)) );
     718        }
     719        else
     720        if (pParam->fUse & (DISUSE_IMMEDIATE64 | DISUSE_IMMEDIATE64_REL | DISUSE_IMMEDIATE64_SX8))
    721721        {
    722722            pParamVal->flags |= PARAM_VAL64;
    723723            pParamVal->size   = sizeof(uint64_t);
    724724            pParamVal->val.val64 = pParam->parval;
    725             Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->flags & DISUSE_IMMEDIATE64_SX8)) );
    726         }
    727         else
    728         if (pParam->flags & (DISUSE_IMMEDIATE_ADDR_16_16))
     725            Assert(pParamVal->size == pParam->cb || ((pParam->cb == 1) && (pParam->fUse & DISUSE_IMMEDIATE64_SX8)) );
     726        }
     727        else
     728        if (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_16))
    729729        {
    730730            pParamVal->flags |= PARAM_VALFARPTR16;
    … …  
    735735        }
    736736        else
    737         if (pParam->flags & (DISUSE_IMMEDIATE_ADDR_16_32))
     737        if (pParam->fUse & (DISUSE_IMMEDIATE_ADDR_16_32))
    738738        {
    739739            pParamVal->flags |= PARAM_VALFARPTR32;
    … …  
    767767{
    768768    NOREF(pCpu);
    769     if (pParam->flags & (DISUSE_REG_GEN8|DISUSE_REG_GEN16|DISUSE_REG_GEN32|DISUSE_REG_FP|DISUSE_REG_MMX|DISUSE_REG_XMM|DISUSE_REG_CR|DISUSE_REG_DBG|DISUSE_REG_SEG|DISUSE_REG_TEST))
     769    if (pParam->fUse & (DISUSE_REG_GEN8|DISUSE_REG_GEN16|DISUSE_REG_GEN32|DISUSE_REG_FP|DISUSE_REG_MMX|DISUSE_REG_XMM|DISUSE_REG_CR|DISUSE_REG_DBG|DISUSE_REG_SEG|DISUSE_REG_TEST))
    770770    {
    771         if (pParam->flags & DISUSE_REG_GEN8)
     771        if (pParam->fUse & DISUSE_REG_GEN8)
    772772        {
    773773            uint8_t *pu8Reg;
    … …  
    780780        }
    781781        else
    782         if (pParam->flags & DISUSE_REG_GEN16)
     782        if (pParam->fUse & DISUSE_REG_GEN16)
    783783        {
    784784            uint16_t *pu16Reg;
    … …  
    791791        }
    792792        else
    793         if (pParam->flags & DISUSE_REG_GEN32)
     793        if (pParam->fUse & DISUSE_REG_GEN32)
    794794        {
    795795            uint32_t *pu32Reg;
    … …  
    802802        }
    803803        else
    804         if (pParam->flags & DISUSE_REG_GEN64)
     804        if (pParam->fUse & DISUSE_REG_GEN64)
    805805        {
    806806            uint64_t *pu64Reg;

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

    r41676 r41678  
    10491049                /* pop [esp+xx] uses esp after the actual pop! */
    10501050                AssertCompile(USE_REG_ESP == USE_REG_SP);
    1051                 if (    (pDis->param1.flags & DISUSE_BASE)
    1052                     &&  (pDis->param1.flags & (DISUSE_REG_GEN16|DISUSE_REG_GEN32))
     1051                if (    (pDis->param1.fUse & DISUSE_BASE)
     1052                    &&  (pDis->param1.fUse & (DISUSE_REG_GEN16|DISUSE_REG_GEN32))
    10531053                    &&  pDis->param1.base.reg_gen == USE_REG_ESP
    10541054                   )
    … …  
    15361536            {
    15371537            case PARMTYPE_IMMEDIATE:
    1538                 if(!(param1.flags & (PARAM_VAL32|PARAM_VAL64)))
     1538                if(!(param1.flags  & (PARAM_VAL32|PARAM_VAL64)))
    15391539                    return VERR_EM_INTERPRETER;
    15401540                /* fallthru */
    … …  
    20622062    case PARMTYPE_IMMEDIATE:
    20632063    case PARMTYPE_ADDRESS:
    2064         if(!(param1.flags & (PARAM_VAL32|PARAM_VAL64)))
     2064        if(!(param1.flags  & (PARAM_VAL32|PARAM_VAL64)))
    20652065            return VERR_EM_INTERPRETER;
    20662066        addr = (RTGCPTR)param1.val.val64;
    … …  
    23972397    case PARMTYPE_IMMEDIATE:
    23982398    case PARMTYPE_ADDRESS:
    2399         if(!(param1.flags & PARAM_VAL16))
     2399        if(!(param1.flags  & PARAM_VAL16))
    24002400            return VERR_EM_INTERPRETER;
    24012401        val = param1.val.val32;
    … …  
    24682468{
    24692469    NOREF(pvFault); NOREF(pcbSize);
    2470     if ((pDis->param1.flags == DISUSE_REG_GEN32 || pDis->param1.flags == DISUSE_REG_GEN64) && pDis->param2.flags == DISUSE_REG_CR)
     2470    if ((pDis->param1.fUse == DISUSE_REG_GEN32 || pDis->param1.fUse == DISUSE_REG_GEN64) && pDis->param2.fUse == DISUSE_REG_CR)
    24712471        return EMInterpretCRxRead(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_gen, pDis->param2.base.reg_ctrl);
    24722472
    2473     if (pDis->param1.flags == DISUSE_REG_CR && (pDis->param2.flags == DISUSE_REG_GEN32 || pDis->param2.flags == DISUSE_REG_GEN64))
     2473    if (pDis->param1.fUse == DISUSE_REG_CR && (pDis->param2.fUse == DISUSE_REG_GEN32 || pDis->param2.fUse == DISUSE_REG_GEN64))
    24742474        return EMInterpretCRxWrite(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_ctrl, pDis->param2.base.reg_gen);
    24752475
    … …  
    25582558    NOREF(pvFault); NOREF(pcbSize);
    25592559
    2560     if((pDis->param1.flags == DISUSE_REG_GEN32 || pDis->param1.flags == DISUSE_REG_GEN64) && pDis->param2.flags == DISUSE_REG_DBG)
     2560    if((pDis->param1.fUse == DISUSE_REG_GEN32 || pDis->param1.fUse == DISUSE_REG_GEN64) && pDis->param2.fUse == DISUSE_REG_DBG)
    25612561    {
    25622562        rc = EMInterpretDRxRead(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_gen, pDis->param2.base.reg_dbg);
    25632563    }
    25642564    else
    2565     if(pDis->param1.flags == DISUSE_REG_DBG && (pDis->param2.flags == DISUSE_REG_GEN32 || pDis->param2.flags == DISUSE_REG_GEN64))
     2565    if(pDis->param1.fUse == DISUSE_REG_DBG && (pDis->param2.fUse == DISUSE_REG_GEN32 || pDis->param2.fUse == DISUSE_REG_GEN64))
    25662566    {
    25672567        rc = EMInterpretDRxWrite(pVM, pVCpu, pRegFrame, pDis->param1.base.reg_dbg, pDis->param2.base.reg_gen);
    … …  
    25932593
    25942594    case PARMTYPE_IMMEDIATE:
    2595         if(!(param1.flags & PARAM_VAL16))
     2595        if(!(param1.flags  & PARAM_VAL16))
    25962596            return VERR_EM_INTERPRETER;
    25972597        sel = (RTSEL)param1.val.val16;

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

    r41676 r41678  
    6868{
    6969    NOREF(pCpu);
    70     if (pParam->flags & (DISUSE_BASE | DISUSE_INDEX | DISUSE_SCALE | DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32))
     70    if (pParam->fUse & (DISUSE_BASE | DISUSE_INDEX | DISUSE_SCALE | DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32))
    7171    {
    7272        *pcbSize  = 0;
    … …  
    7676
    7777    /* divide and conquer */
    78     if (pParam->flags & (DISUSE_REG_GEN64 | DISUSE_REG_GEN32 | DISUSE_REG_GEN16 | DISUSE_REG_GEN8))
    79     {
    80         if (pParam->flags & DISUSE_REG_GEN32)
     78    if (pParam->fUse & (DISUSE_REG_GEN64 | DISUSE_REG_GEN32 | DISUSE_REG_GEN16 | DISUSE_REG_GEN8))
     79    {
     80        if (pParam->fUse & DISUSE_REG_GEN32)
    8181        {
    8282            *pcbSize  = 4;
    … …  
    8585        }
    8686
    87         if (pParam->flags & DISUSE_REG_GEN16)
     87        if (pParam->fUse & DISUSE_REG_GEN16)
    8888        {
    8989            *pcbSize  = 2;
    … …  
    9292        }
    9393
    94         if (pParam->flags & DISUSE_REG_GEN8)
     94        if (pParam->fUse & DISUSE_REG_GEN8)
    9595        {
    9696            *pcbSize  = 1;
    … …  
    9999        }
    100100
    101         Assert(pParam->flags & DISUSE_REG_GEN64);
     101        Assert(pParam->fUse & DISUSE_REG_GEN64);
    102102        *pcbSize  = 8;
    103103        DISFetchReg64(pRegFrame, pParam->base.reg_gen, pu64Data);
    … …  
    106106    else
    107107    {
    108         if (pParam->flags & (DISUSE_IMMEDIATE64 | DISUSE_IMMEDIATE64_SX8))
     108        if (pParam->fUse & (DISUSE_IMMEDIATE64 | DISUSE_IMMEDIATE64_SX8))
    109109        {
    110110            *pcbSize  = 8;
    … …  
    113113        }
    114114
    115         if (pParam->flags & (DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE32_SX8))
     115        if (pParam->fUse & (DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE32_SX8))
    116116        {
    117117            *pcbSize  = 4;
    … …  
    120120        }
    121121
    122         if (pParam->flags & (DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE16_SX8))
     122        if (pParam->fUse & (DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE16_SX8))
    123123        {
    124124            *pcbSize  = 2;
    … …  
    127127        }
    128128
    129         if (pParam->flags & DISUSE_IMMEDIATE8)
     129        if (pParam->fUse & DISUSE_IMMEDIATE8)
    130130        {
    131131            *pcbSize  = 1;
    … …  
    134134        }
    135135
    136         if (pParam->flags & DISUSE_REG_SEG)
     136        if (pParam->fUse & DISUSE_REG_SEG)
    137137        {
    138138            *pcbSize  = 2;
    … …  
    162162{
    163163    NOREF(pCpu);
    164     if (pParam->flags & (DISUSE_BASE | DISUSE_INDEX | DISUSE_SCALE | DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_IMMEDIATE8 | DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE32_SX8 | DISUSE_IMMEDIATE16_SX8))
     164    if (pParam->fUse & (DISUSE_BASE | DISUSE_INDEX | DISUSE_SCALE | DISUSE_DISPLACEMENT8 | DISUSE_DISPLACEMENT16 | DISUSE_DISPLACEMENT32 | DISUSE_DISPLACEMENT64 | DISUSE_IMMEDIATE8 | DISUSE_IMMEDIATE16 | DISUSE_IMMEDIATE32 | DISUSE_IMMEDIATE32_SX8 | DISUSE_IMMEDIATE16_SX8))
    165165    {
    166166        return false;
    167167    }
    168168
    169     if (pParam->flags & DISUSE_REG_GEN32)
     169    if (pParam->fUse & DISUSE_REG_GEN32)
    170170    {
    171171        DISWriteReg32(pRegFrame, pParam->base.reg_gen, (uint32_t)u64Data);
    … …  
    173173    }
    174174
    175     if (pParam->flags & DISUSE_REG_GEN64)
     175    if (pParam->fUse & DISUSE_REG_GEN64)
    176176    {
    177177        DISWriteReg64(pRegFrame, pParam->base.reg_gen, u64Data);
    … …  
    179179    }
    180180
    181     if (pParam->flags & DISUSE_REG_GEN16)
     181    if (pParam->fUse & DISUSE_REG_GEN16)
    182182    {
    183183        DISWriteReg16(pRegFrame, pParam->base.reg_gen, (uint16_t)u64Data);
    … …  
    185185    }
    186186
    187     if (pParam->flags & DISUSE_REG_GEN8)
     187    if (pParam->fUse & DISUSE_REG_GEN8)
    188188    {
    189189        DISWriteReg8(pRegFrame, pParam->base.reg_gen, (uint8_t)u64Data);
    … …  
    191191    }
    192192
    193     if (pParam->flags & DISUSE_REG_SEG)
     193    if (pParam->fUse & DISUSE_REG_SEG)
    194194    {
    195195        DISWriteRegSeg(pRegFrame, pParam->base.reg_seg, (RTSEL)u64Data);

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

    r41676 r41678  
    15351535        {
    15361536            STAM_PROFILE_START(&pVM->iom.s.StatRZInstMov, b);
    1537             AssertMsg(uErrorCode == UINT32_MAX || DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.flags) == !!(uErrorCode & X86_TRAP_PF_RW), ("flags1=%#llx/%RTbool flags2=%#llx/%RTbool ErrCd=%#x\n", pDis->param1.flags, DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.flags), pDis->param2.flags, DISUSE_IS_EFFECTIVE_ADDR(pDis->param2.flags), uErrorCode));
     1537            AssertMsg(uErrorCode == UINT32_MAX || DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.fUse) == !!(uErrorCode & X86_TRAP_PF_RW), ("flags1=%#llx/%RTbool flags2=%#llx/%RTbool ErrCd=%#x\n", pDis->param1.fUse, DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.fUse), pDis->param2.fUse, DISUSE_IS_EFFECTIVE_ADDR(pDis->param2.fUse), uErrorCode));
    15381538            if (uErrorCode != UINT32_MAX    /* EPT+MMIO optimization */
    15391539                ? uErrorCode & X86_TRAP_PF_RW
    1540                 : DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.flags))
     1540                : DISUSE_IS_EFFECTIVE_ADDR(pDis->param1.fUse))
    15411541                rc = iomInterpretMOVxXWrite(pVM, pCtxCore, pDis, pRange, GCPhysFault);
    15421542            else

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

    r41676 r41678  
    761761#endif
    762762
    763     LogFlow(("Reused instr %RGv %d at %RGv param1.flags=%x param1.reg=%d\n", pRegFrame->rip, pDis->pCurInstr->opcode, pvFault, pDis->param1.flags,  pDis->param1.base.reg_gen));
     763    LogFlow(("Reused instr %RGv %d at %RGv param1.fUse=%llx param1.reg=%d\n", pRegFrame->rip, pDis->pCurInstr->opcode, pvFault, pDis->param1.fUse,  pDis->param1.base.reg_gen));
    764764
    765765    /* Non-supervisor mode write means it's used for something else. */
    … …  
    804804            return false;
    805805    }
    806     if (    (    (pDis->param1.flags & DISUSE_REG_GEN32)
    807              ||  (pDis->param1.flags & DISUSE_REG_GEN64))
     806    if (    (    (pDis->param1.fUse & DISUSE_REG_GEN32)
     807             ||  (pDis->param1.fUse & DISUSE_REG_GEN64))
    808808        &&  (pDis->param1.base.reg_gen == USE_REG_ESP))
    809809    {

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

    r41676 r41678  
    800800    {
    801801    case OP_INT:
    802         Assert(pCpu->param1.flags & DISUSE_IMMEDIATE8);
     802        Assert(pCpu->param1.fUse & DISUSE_IMMEDIATE8);
    803803        if (pCpu->param1.parval == 3)
    804804        {
    … …  
    10971097                     * Any register is allowed as long as source and destination are identical.
    10981098                     */
    1099                     if (    cpu.param1.flags != DISUSE_REG_GEN32
     1099                    if (    cpu.param1.fUse != DISUSE_REG_GEN32
    11001100                        ||  (   cpu.param2.flags != DISUSE_REG_GEN32
    11011101                             && (   !(cpu.param2.flags & DISUSE_REG_GEN32)
    … …  
    11151115                {
    11161116                    if (    (pCurInstrGC & 0x3) != 0
    1117                         ||  cpu.param1.flags != DISUSE_REG_GEN32
     1117                        ||  cpu.param1.fUse != DISUSE_REG_GEN32
    11181118                        ||  cpu.param1.base.reg_gen32 != USE_REG_EBP
    11191119                       )
    … …  
    11411141                {
    11421142                    if (    (pCurInstrGC & 0x3) != 0
    1143                         ||  cpu.param1.flags != DISUSE_REG_GEN32
     1143                        ||  cpu.param1.fUse != DISUSE_REG_GEN32
    11441144                        ||  cpu.param1.base.reg_gen32 != USE_REG_ESP
    11451145                       )
    … …  
    13281328        // For our first attempt, we'll handle only simple relative jumps and calls (immediate offset coded in instruction)
    13291329        if (    ((cpu.pCurInstr->optype & DISOPTYPE_CONTROLFLOW) && (OP_PARM_VTYPE(cpu.pCurInstr->param1) == OP_PARM_J))
    1330             ||  (cpu.pCurInstr->opcode == OP_CALL && cpu.param1.flags == DISUSE_DISPLACEMENT32))  /* simple indirect call (call dword ptr [address]) */
     1330            ||  (cpu.pCurInstr->opcode == OP_CALL && cpu.param1.fUse == DISUSE_DISPLACEMENT32))  /* simple indirect call (call dword ptr [address]) */
    13311331        {
    13321332            /* We need to parse 'call dword ptr [address]' type of calls to catch cpuid instructions in some recent Linux distributions (e.g. OpenSuse 10.3) */
    13331333            if (    cpu.pCurInstr->opcode == OP_CALL
    1334                 &&  cpu.param1.flags == DISUSE_DISPLACEMENT32)
     1334                &&  cpu.param1.fUse == DISUSE_DISPLACEMENT32)
    13351335            {
    13361336                addr = 0;
    … …  
    13421342            if (addr == 0)
    13431343            {
    1344                 Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.flags));
     1344                Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.fUse));
    13451345                rc = VINF_SUCCESS;
    13461346                break;
    … …  
    13991399        else
    14001400        if (    cpu.pCurInstr->opcode == OP_JMP
    1401             &&  (cpu.param1.flags & (DISUSE_DISPLACEMENT32|DISUSE_INDEX|DISUSE_SCALE)) == (DISUSE_DISPLACEMENT32|DISUSE_INDEX|DISUSE_SCALE)
     1401            &&  (cpu.param1.fUse & (DISUSE_DISPLACEMENT32|DISUSE_INDEX|DISUSE_SCALE)) == (DISUSE_DISPLACEMENT32|DISUSE_INDEX|DISUSE_SCALE)
    14021402           )
    14031403        {

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

    r41676 r41678  
    990990
    991991            case OP_MOV_CR:
    992                 if (Cpu.param1.flags & DISUSE_REG_GEN32)
     992                if (Cpu.param1.fUse & DISUSE_REG_GEN32)
    993993                {
    994994                    //read
    995                     Assert(Cpu.param2.flags & DISUSE_REG_CR);
     995                    Assert(Cpu.param2.fUse & DISUSE_REG_CR);
    996996                    Assert(Cpu.param2.base.reg_ctrl <= USE_REG_CR4);
    997997                    STAM_COUNTER_INC(&pStats->StatMovReadCR[Cpu.param2.base.reg_ctrl]);
    … …  
    10001000                {
    10011001                    //write
    1002                     Assert(Cpu.param1.flags & DISUSE_REG_CR);
     1002                    Assert(Cpu.param1.fUse & DISUSE_REG_CR);
    10031003                    Assert(Cpu.param1.base.reg_ctrl <= USE_REG_CR4);
    10041004                    STAM_COUNTER_INC(&pStats->StatMovWriteCR[Cpu.param1.base.reg_ctrl]);
    … …  
    11001100
    11011101                        if (    Cpu.pCurInstr->opcode == OP_MOV_CR
    1102                             &&  Cpu.param1.flags == DISUSE_REG_CR /* write */
     1102                            &&  Cpu.param1.fUse == DISUSE_REG_CR /* write */
    11031103                           )
    11041104                        {

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

    r41676 r41678  
    18331833        pPatch->cbOp     = cbOp;
    18341834
    1835         if (pDis->param1.flags == DISUSE_DISPLACEMENT32)
     1835        if (pDis->param1.fUse == DISUSE_DISPLACEMENT32)
    18361836        {
    18371837            /* write. */
    1838             if (pDis->param2.flags == DISUSE_REG_GEN32)
     1838            if (pDis->param2.fUse == DISUSE_REG_GEN32)
    18391839            {
    18401840                pPatch->enmType     = HWACCMTPRINSTR_WRITE_REG;
    … …  
    18431843            else
    18441844            {
    1845                 Assert(pDis->param2.flags == DISUSE_IMMEDIATE32);
     1845                Assert(pDis->param2.fUse == DISUSE_IMMEDIATE32);
    18461846                pPatch->enmType     = HWACCMTPRINSTR_WRITE_IMM;
    18471847                pPatch->uSrcOperand = pDis->param2.parval;
    … …  
    18601860
    18611861            /* read */
    1862             Assert(pDis->param1.flags == DISUSE_REG_GEN32);
     1862            Assert(pDis->param1.fUse == DISUSE_REG_GEN32);
    18631863
    18641864            /* Found:
    … …  
    18721872            if (    rc == VINF_SUCCESS
    18731873                &&  pDis->pCurInstr->opcode == OP_SHR
    1874                 &&  pDis->param1.flags == DISUSE_REG_GEN32
     1874                &&  pDis->param1.fUse == DISUSE_REG_GEN32
    18751875                &&  pDis->param1.base.reg_gen == uMmioReg
    1876                 &&  pDis->param2.flags == DISUSE_IMMEDIATE8
     1876                &&  pDis->param2.fUse == DISUSE_IMMEDIATE8
    18771877                &&  pDis->param2.parval == 4
    18781878                &&  oldcbOp + cbOp < sizeof(pVM->hwaccm.s.aPatches[idx].aOpcode))
    … …  
    20082008        pPatch->enmType = HWACCMTPRINSTR_JUMP_REPLACEMENT;
    20092009
    2010         if (pDis->param1.flags == DISUSE_DISPLACEMENT32)
     2010        if (pDis->param1.fUse == DISUSE_DISPLACEMENT32)
    20112011        {
    20122012            /*
    … …  
    20282028                *
    20292029                */
    2030             bool fUsesEax = (pDis->param2.flags == DISUSE_REG_GEN32 && pDis->param2.base.reg_gen == USE_REG_EAX);
     2030            bool fUsesEax = (pDis->param2.fUse == DISUSE_REG_GEN32 && pDis->param2.base.reg_gen == USE_REG_EAX);
    20312031
    20322032            aPatch[off++] = 0x51;    /* push ecx */
    … …  
    20362036            aPatch[off++] = 0x31;    /* xor edx, edx */
    20372037            aPatch[off++] = 0xD2;
    2038             if (pDis->param2.flags == DISUSE_REG_GEN32)
     2038            if (pDis->param2.fUse == DISUSE_REG_GEN32)
    20392039            {
    20402040                if (!fUsesEax)
    … …  
    20462046            else
    20472047            {
    2048                 Assert(pDis->param2.flags == DISUSE_IMMEDIATE32);
     2048                Assert(pDis->param2.fUse == DISUSE_IMMEDIATE32);
    20492049                aPatch[off++] = 0xB8;    /* mov eax, immediate */
    20502050                *(uint32_t *)&aPatch[off] = pDis->param2.parval;
    … …  
    20792079                *
    20802080                */
    2081             Assert(pDis->param1.flags == DISUSE_REG_GEN32);
     2081            Assert(pDis->param1.fUse == DISUSE_REG_GEN32);
    20822082
    20832083            if (pDis->param1.base.reg_gen != USE_REG_ECX)

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

    r41676 r41678  
    77
    88/*
    9  * Copyright (C) 2006-2007 Oracle Corporation
     9 * Copyright (C) 2006-2012 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    17011701        if (pTargetGC == 0)
    17021702        {
    1703             Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.flags));
     1703            Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.fUse));
    17041704            return VERR_PATCHING_REFUSED;
    17051705        }
    … …  
    17481748        {
    17491749            /* mov ss, src? */
    1750             if (    (pCpu->param1.flags & DISUSE_REG_SEG)
     1750            if (    (pCpu->param1.fUse & DISUSE_REG_SEG)
    17511751                &&  (pCpu->param1.base.reg_seg == DIS_SELREG_SS))
    17521752            {
    … …  
    17571757#if 0 /* necessary for Haiku */
    17581758            else
    1759             if (    (pCpu->param2.flags & DISUSE_REG_SEG)
     1759            if (    (pCpu->param2.fUse & DISUSE_REG_SEG)
    17601760                &&  (pCpu->param2.base.reg_seg == USE_REG_SS)
    1761                 &&  (pCpu->param1.flags & (DISUSE_REG_GEN32|DISUSE_REG_GEN16)))     /** @todo memory operand must in theory be handled too */
     1761                &&  (pCpu->param1.fUse & (DISUSE_REG_GEN32|DISUSE_REG_GEN16)))     /** @todo memory operand must in theory be handled too */
    17621762            {
    17631763                /* mov GPR, ss */
    … …  
    22432243            if (pTargetGC == 0)
    22442244            {
    2245                 Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.flags));
     2245                Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.fUse));
    22462246                rc = VERR_PATCHING_REFUSED;
    22472247                break;
    … …  
    24622462            if (addr == 0)
    24632463            {
    2464                 Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.flags));
     2464                Log(("We don't support far jumps here!! (%08X)\n", cpu.param1.fUse));
    24652465                rc = VERR_PATCHING_REFUSED;
    24662466                break;
    … …  
    35883588    if (pTargetGC == 0)
    35893589    {
    3590         Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.flags));
     3590        Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.fUse));
    35913591        rc = VERR_PATCHING_REFUSED;
    35923592        goto failure;
    … …  
    36803680        goto failure;
    36813681
    3682     if (pCpu->param2.flags != DISUSE_DISPLACEMENT32)
     3682    if (pCpu->param2.fUse != DISUSE_DISPLACEMENT32)
    36833683        goto failure;
    36843684
    … …  
    37593759    if (opsize > MAX_INSTR_SIZE)
    37603760        return VERR_PATCHING_REFUSED;
    3761     if (cpu.param2.flags != DISUSE_DISPLACEMENT32)
     3761    if (cpu.param2.fUse != DISUSE_DISPLACEMENT32)
    37623762        return VERR_PATCHING_REFUSED;
    37633763
    … …  
    39213921    case OP_JMP:
    39223922        Assert(pPatch->flags & PATMFL_JUMP_CONFLICT);
    3923         Assert(pCpu->param1.flags & DISUSE_IMMEDIATE32_REL);
    3924         if (!(pCpu->param1.flags & DISUSE_IMMEDIATE32_REL))
     3923        Assert(pCpu->param1.fUse & DISUSE_IMMEDIATE32_REL);
     3924        if (!(pCpu->param1.fUse & DISUSE_IMMEDIATE32_REL))
    39253925            goto failure;
    39263926
    … …  
    52065206        && (pConflictPatch->flags & PATMFL_CODE32)
    52075207        && (cpu.pCurInstr->opcode == OP_JMP || (cpu.pCurInstr->optype & DISOPTYPE_COND_CONTROLFLOW))
    5208         && (cpu.param1.flags & DISUSE_IMMEDIATE32_REL))
     5208        && (cpu.param1.fUse & DISUSE_IMMEDIATE32_REL))
    52095209    {
    52105210        /* Hint patches must be enabled first. */

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

    r41676 r41678  
    11631163        // mov DRx, GPR
    11641164        pPB[0] = 0x89;      //mov disp32, GPR
    1165         Assert(pCpu->param1.flags & DISUSE_REG_DBG);
    1166         Assert(pCpu->param2.flags & DISUSE_REG_GEN32);
     1165        Assert(pCpu->param1.fUse & DISUSE_REG_DBG);
     1166        Assert(pCpu->param2.fUse & DISUSE_REG_GEN32);
    11671167
    11681168        dbgreg = pCpu->param1.base.reg_dbg;
    … …  
    11721172    {
    11731173        // mov GPR, DRx
    1174         Assert(pCpu->param1.flags & DISUSE_REG_GEN32);
    1175         Assert(pCpu->param2.flags & DISUSE_REG_DBG);
     1174        Assert(pCpu->param1.fUse & DISUSE_REG_GEN32);
     1175        Assert(pCpu->param2.fUse & DISUSE_REG_DBG);
    11761176
    11771177        pPB[0] = 0x8B;      // mov GPR, disp32
    … …  
    12151215        ctrlreg = pCpu->param1.base.reg_ctrl;
    12161216        reg     = pCpu->param2.base.reg_gen;
    1217         Assert(pCpu->param1.flags & DISUSE_REG_CR);
    1218         Assert(pCpu->param2.flags & DISUSE_REG_GEN32);
     1217        Assert(pCpu->param1.fUse & DISUSE_REG_CR);
     1218        Assert(pCpu->param2.fUse & DISUSE_REG_GEN32);
    12191219    }
    12201220    else
    12211221    {
    12221222        // mov GPR, DRx
    1223         Assert(pCpu->param1.flags & DISUSE_REG_GEN32);
    1224         Assert(pCpu->param2.flags & DISUSE_REG_CR);
     1223        Assert(pCpu->param1.fUse & DISUSE_REG_GEN32);
     1224        Assert(pCpu->param2.fUse & DISUSE_REG_CR);
    12251225
    12261226        pPB[0]  = 0x8B;      // mov GPR, disp32
    … …  
    13241324    PATCHGEN_PROLOG(pVM, pPatch);
    13251325
    1326     if (pCpu->param1.flags == DISUSE_REG_GEN32 || pCpu->param1.flags == DISUSE_REG_GEN16)
     1326    if (pCpu->param1.fUse == DISUSE_REG_GEN32 || pCpu->param1.fUse == DISUSE_REG_GEN16)
    13271327    {
    13281328        /* Register operand */

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

    r41676 r41678  
    738738             * Little hack to make the code below not fail
    739739             */
    740             pCpu->param1.flags  = DISUSE_IMMEDIATE8;
     740            pCpu->param1.fUse  = DISUSE_IMMEDIATE8;
    741741            pCpu->param1.parval = 3;
    742742            /* fallthru */
    743743        case OP_INT:
    744744        {
    745             Assert(pCpu->param1.flags & DISUSE_IMMEDIATE8);
     745            Assert(pCpu->param1.fUse & DISUSE_IMMEDIATE8);
    746746            Assert(!(PATMIsPatchGCAddr(pVM, PC)));
    747747            if (pCpu->param1.parval == 3)
    … …  
    840840             * Little hack to make the code below not fail
    841841             */
    842             pCpu->param1.flags  = DISUSE_IMMEDIATE8;
     842            pCpu->param1.fUse  = DISUSE_IMMEDIATE8;
    843843            pCpu->param1.parval = 3;
    844844            /* fall thru */
    845845        case OP_INT:
    846846        {
    847             Assert(pCpu->param1.flags & DISUSE_IMMEDIATE8);
     847            Assert(pCpu->param1.fUse & DISUSE_IMMEDIATE8);
    848848            rc = TRPMForwardTrap(pVCpu, pRegFrame, (uint32_t)pCpu->param1.parval, pCpu->opsize, TRPM_TRAP_NO_ERRORCODE, TRPM_SOFTWARE_INT, 0xd);
    849849            if (RT_SUCCESS(rc) && rc != VINF_EM_RAW_GUEST_TRAP)

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

    r41676 r41678  
    251251{
    252252    uint32_t disp;
    253     if (pCpu->param1.flags & DISUSE_IMMEDIATE8_REL)
     253    if (pCpu->param1.fUse & DISUSE_IMMEDIATE8_REL)
    254254    {
    255255        disp = (int32_t)(char)pCpu->param1.parval;
    256256    }
    257257    else
    258     if (pCpu->param1.flags & DISUSE_IMMEDIATE16_REL)
     258    if (pCpu->param1.fUse & DISUSE_IMMEDIATE16_REL)
    259259    {
    260260        disp = (int32_t)(uint16_t)pCpu->param1.parval;
    261261    }
    262262    else
    263     if (pCpu->param1.flags & DISUSE_IMMEDIATE32_REL)
     263    if (pCpu->param1.fUse & DISUSE_IMMEDIATE32_REL)
    264264    {
    265265        disp = (int32_t)pCpu->param1.parval;
    … …  
    267267    else
    268268    {
    269         Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.flags));
     269        Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.fUse));
    270270        return 0;
    271271    }

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

    r41676 r41678  
    761761{
    762762    uint32_t disp;
    763     if (pCpu->param1.flags & DISUSE_IMMEDIATE8_REL)
     763    if (pCpu->param1.fUse & DISUSE_IMMEDIATE8_REL)
    764764    {
    765765        disp = (int32_t)(char)pCpu->param1.parval;
    766766    }
    767767    else
    768     if (pCpu->param1.flags & DISUSE_IMMEDIATE16_REL)
     768    if (pCpu->param1.fUse & DISUSE_IMMEDIATE16_REL)
    769769    {
    770770        disp = (int32_t)(uint16_t)pCpu->param1.parval;
    771771    }
    772772    else
    773     if (pCpu->param1.flags & DISUSE_IMMEDIATE32_REL)
     773    if (pCpu->param1.fUse & DISUSE_IMMEDIATE32_REL)
    774774    {
    775775        disp = (int32_t)pCpu->param1.parval;
    … …  
    777777    else
    778778    {
    779         Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.flags));
     779        Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.fUse));
    780780        return 0;
    781781    }
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