VirtualBox

Changeset 41734 in vbox for trunk/src


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

DISCPUSTATE: s/prefix/fPrefix/ and a couple of forgotten opcode uses.

Location:
trunk/src/VBox
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/PC/BIOS-new/MakeDebianBiosAssembly.cpp

    r41675 r41734  
    833833     *        modrm.reg != 0. Those encodings should be invalid AFAICT. */
    834834
    835     if (   (   pCpuState->opcode  == 0x8f            /* group 1a */
    836             || pCpuState->opcode  == 0xc7            /* group 11 */
    837             || pCpuState->opcode  == 0xc6            /* group 11 - not verified */
     835    if (   (   pCpuState->bOpCode  == 0x8f            /* group 1a */
     836            || pCpuState->bOpCode  == 0xc7            /* group 11 */
     837            || pCpuState->bOpCode  == 0xc6            /* group 11 - not verified */
    838838           )
    839839        && pCpuState->ModRM.Bits.Reg != 0)
    … …  
    841841    /** @todo "TEST Eb,Ib" (f6 0f 08) ends up with no mnemonic as well as
    842842     *        wrong length (2 instead of 3)! */
    843     else if (   pCpuState->opcode == 0xf6
     843    else if (   pCpuState->bOpCode == 0xf6
    844844             && pb[1] == 0x0f
    845845             && pb[2] == 0x08
    … …  
    847847        fDifferent = true;
    848848    /** @todo "INSB Yb,DX" (6c) ends up with no mnemonic here. */
    849     else if (pCpuState->opcode == 0x6c && RT_C_IS_SPACE(*pszBuf))
     849    else if (pCpuState->bOpCode == 0x6c && RT_C_IS_SPACE(*pszBuf))
    850850        fDifferent = true;
    851851    /*

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

    r41733 r41734  
    304304        pCpu->opmode        = enmCpuMode;
    305305    }
    306     pCpu->prefix            = DISPREFIX_NONE;
     306    pCpu->fPrefix           = DISPREFIX_NONE;
    307307    pCpu->idxSegPrefix      = DISSELREG_DS;
    308308    pCpu->uInstrAddr        = uInstrAddr;
    … …  
    346346                /** Last prefix byte (for SSE2 extension tables); don't include the REX prefix */
    347347                pCpu->bLastPrefix = opcode;
    348                 pCpu->prefix &= ~DISPREFIX_REX;
     348                pCpu->fPrefix &= ~DISPREFIX_REX;
    349349            }
    350350
    … …  
    363363                    || pCpu->idxSegPrefix >= DISSELREG_FS)
    364364                {
    365                     pCpu->prefix    |= DISPREFIX_SEG;
     365                    pCpu->fPrefix   |= DISPREFIX_SEG;
    366366                }
    367367                iByte += sizeof(uint8_t);
    … …  
    370370            // lock prefix byte
    371371            case OP_LOCK:
    372                 pCpu->prefix |= DISPREFIX_LOCK;
     372                pCpu->fPrefix |= DISPREFIX_LOCK;
    373373                iByte       += sizeof(uint8_t);
    374374                continue;   //fetch the next byte
    … …  
    376376            // address size override prefix byte
    377377            case OP_ADDRSIZE:
    378                 pCpu->prefix |= DISPREFIX_ADDRSIZE;
     378                pCpu->fPrefix |= DISPREFIX_ADDRSIZE;
    379379                if (pCpu->mode == DISCPUMODE_16BIT)
    380380                    pCpu->addrmode = DISCPUMODE_32BIT;
    … …  
    390390            // operand size override prefix byte
    391391            case OP_OPSIZE:
    392                 pCpu->prefix |= DISPREFIX_OPSIZE;
     392                pCpu->fPrefix |= DISPREFIX_OPSIZE;
    393393                if (pCpu->mode == DISCPUMODE_16BIT)
    394394                    pCpu->opmode = DISCPUMODE_32BIT;
    … …  
    401401            // rep and repne are not really prefixes, but we'll treat them as such
    402402            case OP_REPE:
    403                 pCpu->prefix |= DISPREFIX_REP;
     403                pCpu->fPrefix |= DISPREFIX_REP;
    404404                iByte       += sizeof(uint8_t);
    405405                continue;   //fetch the next byte
    406406
    407407            case OP_REPNE:
    408                 pCpu->prefix |= DISPREFIX_REPNE;
     408                pCpu->fPrefix |= DISPREFIX_REPNE;
    409409                iByte       += sizeof(uint8_t);
    410410                continue;   //fetch the next byte
    … …  
    413413                Assert(pCpu->mode == DISCPUMODE_64BIT);
    414414                /* REX prefix byte */
    415                 pCpu->prefix    |= DISPREFIX_REX;
     415                pCpu->fPrefix   |= DISPREFIX_REX;
    416416                pCpu->fRexPrefix = DISPREFIX_REX_OP_2_FLAGS(paOneByteMap[codebyte].param1);
    417417                iByte           += sizeof(uint8_t);
    … …  
    438438        *pcbInstr = iByte;
    439439
    440     if (pCpu->prefix & DISPREFIX_LOCK)
     440    if (pCpu->fPrefix & DISPREFIX_LOCK)
    441441        disValidateLockSequence(pCpu);
    442442
    … …  
    482482        else
    483483        if (    (pOp->optype & DISOPTYPE_DEFAULT_64_OP_SIZE)
    484             &&  !(pCpu->prefix & DISPREFIX_OPSIZE))
     484            &&  !(pCpu->fPrefix & DISPREFIX_OPSIZE))
    485485            pCpu->opmode = DISCPUMODE_64BIT;
    486486    }
    … …  
    561561        else
    562562        if (    (fpop->optype & DISOPTYPE_DEFAULT_64_OP_SIZE)
    563             &&  !(pCpu->prefix & DISPREFIX_OPSIZE))
     563            &&  !(pCpu->fPrefix & DISPREFIX_OPSIZE))
    564564            pCpu->opmode = DISCPUMODE_64BIT;
    565565    }
    … …  
    662662    pCpu->SIB.Bits.Scale = SIB_SCALE(SIB);
    663663
    664     if (pCpu->prefix & DISPREFIX_REX)
     664    if (pCpu->fPrefix & DISPREFIX_REX)
    665665    {
    666666        /* REX.B extends the Base field if not scaled index + disp32 */
    … …  
    695695    pCpu->SIB.Bits.Scale = SIB_SCALE(SIB);
    696696
    697     if (pCpu->prefix & DISPREFIX_REX)
     697    if (pCpu->fPrefix & DISPREFIX_REX)
    698698    {
    699699        /* REX.B extends the Base field. */
    … …  
    739739                if (    pCpu->pCurInstr->opcode == OP_MOV_CR
    740740                    &&  pCpu->opmode == DISCPUMODE_32BIT
    741                     &&  (pCpu->prefix & DISPREFIX_LOCK))
     741                    &&  (pCpu->fPrefix & DISPREFIX_LOCK))
    742742                {
    743                     pCpu->prefix &= ~DISPREFIX_LOCK;
     743                    pCpu->fPrefix &= ~DISPREFIX_LOCK;
    744744                    pParam->base.reg_ctrl = DISCREG_CR8;
    745745                }
    … …  
    10801080        pCpu->ModRM.Bits.Mod = 3;
    10811081
    1082     if (pCpu->prefix & DISPREFIX_REX)
     1082    if (pCpu->fPrefix & DISPREFIX_REX)
    10831083    {
    10841084        Assert(pCpu->mode == DISCPUMODE_64BIT);
    … …  
    11261126        pCpu->ModRM.Bits.Mod = 3;
    11271127
    1128     if (pCpu->prefix & DISPREFIX_REX)
     1128    if (pCpu->fPrefix & DISPREFIX_REX)
    11291129    {
    11301130        Assert(pCpu->mode == DISCPUMODE_64BIT);
    … …  
    15701570            if (    (pOp->optype & DISOPTYPE_REXB_EXTENDS_OPREG)
    15711571                &&  pParam == &pCpu->param1             /* ugly assumption that it only applies to the first parameter */
    1572                 &&  (pCpu->prefix & DISPREFIX_REX)
     1572                &&  (pCpu->fPrefix & DISPREFIX_REX)
    15731573                &&  (pCpu->fRexPrefix & DISPREFIX_REX_FLAGS))
    15741574                pParam->base.reg_gen += 8;
    … …  
    16141614            if (    (pOp->optype & DISOPTYPE_REXB_EXTENDS_OPREG)
    16151615                &&  pParam == &pCpu->param1             /* ugly assumption that it only applies to the first parameter */
    1616                 &&  (pCpu->prefix & DISPREFIX_REX)
     1616                &&  (pCpu->fPrefix & DISPREFIX_REX)
    16171617                &&  (pCpu->fRexPrefix & DISPREFIX_REX_FLAGS))
    16181618                pParam->base.reg_gen += 8;              /* least significant byte of R8-R15 */
    … …  
    17601760
    17611761                /* Cancel prefix changes. */
    1762                 pCpu->prefix &= ~DISPREFIX_OPSIZE;
     1762                pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
    17631763                pCpu->opmode  = pCpu->mode;
    17641764            }
    … …  
    17721772
    17731773                /* Cancel prefix changes. */
    1774                 pCpu->prefix &= ~DISPREFIX_REPNE;
     1774                pCpu->fPrefix &= ~DISPREFIX_REPNE;
    17751775            }
    17761776            break;
    … …  
    17831783
    17841784                /* Cancel prefix changes. */
    1785                 pCpu->prefix &= ~DISPREFIX_REP;
     1785                pCpu->fPrefix &= ~DISPREFIX_REP;
    17861786            }
    17871787            break;
    … …  
    18271827
    18281828                /* Cancel prefix changes. */
    1829                 pCpu->prefix &= ~DISPREFIX_OPSIZE;
     1829                pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
    18301830                pCpu->opmode  = pCpu->mode;
    18311831            }
    … …  
    18441844
    18451845                /* Cancel prefix changes. */
    1846                 pCpu->prefix &= ~DISPREFIX_REPNE;
     1846                pCpu->fPrefix &= ~DISPREFIX_REPNE;
    18471847            }
    18481848        }
    … …  
    18781878
    18791879            /* Cancel prefix changes. */
    1880             pCpu->prefix &= ~DISPREFIX_OPSIZE;
     1880            pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
    18811881            pCpu->opmode  = pCpu->mode;
    18821882        }
    … …  
    18951895    NOREF(pParam);
    18961896
    1897     if (pCpu->prefix & DISPREFIX_REP)
     1897    if (pCpu->fPrefix & DISPREFIX_REP)
    18981898    {
    18991899        pOp = &g_aMapX86_NopPause[1]; /* PAUSE */
    1900         pCpu->prefix &= ~DISPREFIX_REP;
     1900        pCpu->fPrefix &= ~DISPREFIX_REP;
    19011901    }
    19021902    else
    … …  
    21852185    reg   = MODRM_REG(modrm);
    21862186
    2187     if (pCpu->prefix & DISPREFIX_OPSIZE)
     2187    if (pCpu->fPrefix & DISPREFIX_OPSIZE)
    21882188        reg += 8;   //2nd table
    21892189
    … …  
    22062206    modrm = disReadByte(pCpu, uCodePtr);
    22072207    reg   = MODRM_REG(modrm);
    2208     if (pCpu->prefix & DISPREFIX_OPSIZE)
     2208    if (pCpu->fPrefix & DISPREFIX_OPSIZE)
    22092209        reg += 8;   //2nd table
    22102210
    … …  
    22282228    modrm = disReadByte(pCpu, uCodePtr);
    22292229    reg   = MODRM_REG(modrm);
    2230     if (pCpu->prefix & DISPREFIX_OPSIZE)
     2230    if (pCpu->fPrefix & DISPREFIX_OPSIZE)
    22312231        reg += 8;   //2nd table
    22322232
    … …  
    23302330    {
    23312331    case OP_PARM_b:
    2332         Assert(idx < (pCpu->prefix & DISPREFIX_REX ? 16U : 8U));
     2332        Assert(idx < (pCpu->fPrefix & DISPREFIX_REX ? 16U : 8U));
    23332333
    23342334        /* AH, BH, CH & DH map to DIL, SIL, EBL & SPL when a rex prefix is present. */
    23352335        /* Intel® 64 and IA-32 Architectures Software Developer’s Manual: 3.4.1.1 */
    2336         if (    (pCpu->prefix & DISPREFIX_REX)
     2336        if (    (pCpu->fPrefix & DISPREFIX_REX)
    23372337            &&  idx >= DISGREG_AH
    23382338            &&  idx <= DISGREG_BH)
    … …  
    23462346
    23472347    case OP_PARM_w:
    2348         Assert(idx < (pCpu->prefix & DISPREFIX_REX ? 16U : 8U));
     2348        Assert(idx < (pCpu->fPrefix & DISPREFIX_REX ? 16U : 8U));
    23492349
    23502350        pParam->fUse |= DISUSE_REG_GEN16;
    … …  
    23532353
    23542354    case OP_PARM_d:
    2355         Assert(idx < (pCpu->prefix & DISPREFIX_REX ? 16U : 8U));
     2355        Assert(idx < (pCpu->fPrefix & DISPREFIX_REX ? 16U : 8U));
    23562356
    23572357        pParam->fUse |= DISUSE_REG_GEN32;
    … …  
    26182618static void disValidateLockSequence(PDISCPUSTATE pCpu)
    26192619{
    2620     Assert(pCpu->prefix & DISPREFIX_LOCK);
     2620    Assert(pCpu->fPrefix & DISPREFIX_LOCK);
    26212621
    26222622    /*

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

    r41733 r41734  
    392392    if (    pOp->opcode == OP_INVALID
    393393        ||  (   pOp->opcode == OP_ILLUD2
    394              && (pCpu->prefix & DISPREFIX_LOCK)))
     394             && (pCpu->fPrefix & DISPREFIX_LOCK)))
    395395    {
    396396
    … …  
    401401         * Prefixes
    402402         */
    403         if (pCpu->prefix & DISPREFIX_LOCK)
     403        if (pCpu->fPrefix & DISPREFIX_LOCK)
    404404            PUT_SZ("lock ");
    405         if(pCpu->prefix & DISPREFIX_REP)
     405        if(pCpu->fPrefix & DISPREFIX_REP)
    406406            PUT_SZ("rep ");
    407         else if(pCpu->prefix & DISPREFIX_REPNE)
     407        else if(pCpu->fPrefix & DISPREFIX_REPNE)
    408408            PUT_SZ("repne ");
    409409
    … …  
    604604#define PUT_SEGMENT_OVERRIDE() \
    605605        do { \
    606             if (pCpu->prefix & DISPREFIX_SEG) \
     606            if (pCpu->fPrefix & DISPREFIX_SEG) \
    607607                PUT_STR(s_szSegPrefix[pCpu->idxSegPrefix], 3); \
    608608        } while (0)
    … …  
    612612         * Segment prefixing for instructions that doesn't do memory access.
    613613         */
    614         if (    (pCpu->prefix & DISPREFIX_SEG)
     614        if (    (pCpu->fPrefix & DISPREFIX_SEG)
    615615            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.fUse)
    616616            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.fUse)
    … …  
    12911291    {
    12921292        /* no effective address which it may apply to. */
    1293         Assert((pCpu->prefix & DISPREFIX_SEG) || pCpu->mode == DISCPUMODE_64BIT);
     1293        Assert((pCpu->fPrefix & DISPREFIX_SEG) || pCpu->mode == DISCPUMODE_64BIT);
    12941294        if (    !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.fUse)
    12951295            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.fUse)
    … …  
    13011301    if (fPrefixes & DISPREFIX_ADDRSIZE)
    13021302    {
    1303         Assert(pCpu->prefix & DISPREFIX_ADDRSIZE);
     1303        Assert(pCpu->fPrefix & DISPREFIX_ADDRSIZE);
    13041304        if (    pCpu->pCurInstr->param3 == OP_PARM_NONE
    13051305            &&  pCpu->pCurInstr->param2 == OP_PARM_NONE

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

    r41732 r41734  
    259259DISDECL(DISSELREG) DISDetectSegReg(PDISCPUSTATE pCpu, PDISOPPARAM pParam)
    260260{
    261     if (pCpu->prefix & DISPREFIX_SEG)
     261    if (pCpu->fPrefix & DISPREFIX_SEG)
    262262        /* Use specified SEG: prefix. */
    263263        return (DISSELREG)pCpu->idxSegPrefix;
    … …  
    280280DISDECL(uint8_t) DISQuerySegPrefixByte(PDISCPUSTATE pCpu)
    281281{
    282     Assert(pCpu->prefix & DISPREFIX_SEG);
     282    Assert(pCpu->fPrefix & DISPREFIX_SEG);
    283283    switch (pCpu->idxSegPrefix)
    284284    {

  • trunk/src/VBox/Runtime/testcase/tstLdrDisasmTest.cpp

    r41675 r41734  
    107107    int rc = DISInstrWithReader(CodeIndex, DISCPUMODE_32BIT, DisasmTest1ReadCode, 0, pCpu, &cb);
    108108    *pcb = cb;
    109     MY_PRINTF(("DISCoreOneEx -> rc=%d cb=%d  Cpu: opcode=%#x pCurInstr=%p (42=%d)\n", \
    110                rc, cb, pCpu->opcode, pCpu->pCurInstr, 42)); \
     109    MY_PRINTF(("DISCoreOneEx -> rc=%d cb=%d  Cpu: bOpCode=%#x pCurInstr=%p (42=%d)\n", \
     110               rc, cb, pCpu->bOpCode, pCpu->pCurInstr, 42)); \
    111111    return rc;
    112112}

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

    r41732 r41734  
    789789        case OP_LMSW:       return "Lmsw";
    790790        case OP_SMSW:       return "Smsw";
    791         case OP_CMPXCHG:    return pDis->prefix & DISPREFIX_LOCK ? "Lock CmpXchg"   : "CmpXchg";
    792         case OP_CMPXCHG8B:  return pDis->prefix & DISPREFIX_LOCK ? "Lock CmpXchg8b" : "CmpXchg8b";
     791        case OP_CMPXCHG:    return pDis->fPrefix & DISPREFIX_LOCK ? "Lock CmpXchg"   : "CmpXchg";
     792        case OP_CMPXCHG8B:  return pDis->fPrefix & DISPREFIX_LOCK ? "Lock CmpXchg8b" : "CmpXchg8b";
    793793
    794794        default:
    … …  
    16521652
    16531653    /* Don't support any but these three prefix bytes. */
    1654     if ((pDis->prefix & ~(DISPREFIX_ADDRSIZE|DISPREFIX_OPSIZE|DISPREFIX_REP|DISPREFIX_REX)))
     1654    if ((pDis->fPrefix & ~(DISPREFIX_ADDRSIZE|DISPREFIX_OPSIZE|DISPREFIX_REP|DISPREFIX_REX)))
    16551655        return VERR_EM_INTERPRETER;
    16561656
    … …  
    16931693    offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
    16941694
    1695     if (!(pDis->prefix & DISPREFIX_REP))
     1695    if (!(pDis->fPrefix & DISPREFIX_REP))
    16961696    {
    16971697        LogFlow(("emInterpretStosWD dest=%04X:%RGv (%RGv) cbSize=%d\n", pRegFrame->es, GCOffset, GCDest, cbSize));
    … …  
    18481848    LogFlow(("%s %RGv rax=%RX64 %RX64\n", emGetMnemonic(pDis), GCPtrPar1, pRegFrame->rax, valpar));
    18491849
    1850     if (pDis->prefix & DISPREFIX_LOCK)
     1850    if (pDis->fPrefix & DISPREFIX_LOCK)
    18511851        eflags = EMEmulateLockCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.cb);
    18521852    else
    … …  
    19011901    LogFlow(("%s %RGv=%08x eax=%08x\n", emGetMnemonic(pDis), pvParam1, pRegFrame->eax));
    19021902
    1903     if (pDis->prefix & DISPREFIX_LOCK)
     1903    if (pDis->fPrefix & DISPREFIX_LOCK)
    19041904        eflags = EMEmulateLockCmpXchg8b(pvParam1, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx);
    19051905    else
    … …  
    19701970            LogFlow(("XAdd %RGv=%p reg=%08llx\n", GCPtrPar1, pvParam1, *(uint64_t *)pvParamReg2));
    19711971
    1972             if (pDis->prefix & DISPREFIX_LOCK)
     1972            if (pDis->fPrefix & DISPREFIX_LOCK)
    19731973                eflags = EMEmulateLockXAdd(pvParam1, pvParamReg2, cbParamReg2);
    19741974            else
    … …  
    26542654    AssertRCReturn(rc, VERR_EM_INTERPRETER);
    26552655
    2656     if (!(pDis->prefix & DISPREFIX_OPSIZE))
     2656    if (!(pDis->fPrefix & DISPREFIX_OPSIZE))
    26572657        dtr32.uAddr &= 0xffffff; /* 16 bits operand size */
    26582658
    … …  
    30303030    /* Note: The Intel manual claims there's a REX version of RDMSR that's slightly
    30313031             different, so we play safe by completely disassembling the instruction. */
    3032     Assert(!(pDis->prefix & DISPREFIX_REX));
     3032    Assert(!(pDis->fPrefix & DISPREFIX_REX));
    30333033    NOREF(pDis); NOREF(pvFault); NOREF(pcbSize);
    30343034    return EMInterpretRdmsr(pVM, pVCpu, pRegFrame);
    … …  
    31043104
    31053105#ifdef IN_RC
    3106     if (    (pDis->prefix & (DISPREFIX_REPNE | DISPREFIX_REP))
    3107         ||  (   (pDis->prefix & DISPREFIX_LOCK)
     3106    if (    (pDis->fPrefix & (DISPREFIX_REPNE | DISPREFIX_REP))
     3107        ||  (   (pDis->fPrefix & DISPREFIX_LOCK)
    31083108             && pDis->pCurInstr->opcode != OP_CMPXCHG
    31093109             && pDis->pCurInstr->opcode != OP_CMPXCHG8B
    … …  
    31163116       )
    31173117#else
    3118     if (    (pDis->prefix & DISPREFIX_REPNE)
    3119         ||  (   (pDis->prefix & DISPREFIX_REP)
     3118    if (    (pDis->fPrefix & DISPREFIX_REPNE)
     3119        ||  (   (pDis->fPrefix & DISPREFIX_REP)
    31203120             && pDis->pCurInstr->opcode != OP_STOSWD
    31213121            )
    3122         ||  (   (pDis->prefix & DISPREFIX_LOCK)
     3122        ||  (   (pDis->fPrefix & DISPREFIX_LOCK)
    31233123             && pDis->pCurInstr->opcode != OP_OR
    31243124             && pDis->pCurInstr->opcode != OP_AND
    … …  
    32283228# define INTERPRET_CASE_EX_LOCK_PARAM3(opcode, Instr, InstrFn, pfnEmulate, pfnEmulateLock) \
    32293229        case opcode:\
    3230             if (pDis->prefix & DISPREFIX_LOCK) \
     3230            if (pDis->fPrefix & DISPREFIX_LOCK) \
    32313231                rc = emInterpretLock##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulateLock); \
    32323232            else \

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

    r41727 r41734  
    670670     * We do not support segment prefixes or REPNE.
    671671     */
    672     if (pCpu->prefix & (DISPREFIX_SEG | DISPREFIX_REPNE))
     672    if (pCpu->fPrefix & (DISPREFIX_SEG | DISPREFIX_REPNE))
    673673        return VINF_IOM_R3_MMIO_READ_WRITE; /** @todo -> interpret whatever. */
    674674
    … …  
    679679     */
    680680    uint32_t cTransfers = 1;
    681     if (pCpu->prefix & DISPREFIX_REP)
     681    if (pCpu->fPrefix & DISPREFIX_REP)
    682682    {
    683683#ifndef IN_RC
    … …  
    767767#endif
    768768            /* Update ecx. */
    769             if (pCpu->prefix & DISPREFIX_REP)
     769            if (pCpu->fPrefix & DISPREFIX_REP)
    770770                pRegFrame->ecx = cTransfers;
    771771        }
    … …  
    875875
    876876        /* Update ecx on exit. */
    877         if (pCpu->prefix & DISPREFIX_REP)
     877        if (pCpu->fPrefix & DISPREFIX_REP)
    878878            pRegFrame->ecx = cTransfers;
    879879    }
    … …  
    928928     * We do not support segment prefixes or REPNE..
    929929     */
    930     if (pCpu->prefix & (DISPREFIX_SEG | DISPREFIX_REPNE))
     930    if (pCpu->fPrefix & (DISPREFIX_SEG | DISPREFIX_REPNE))
    931931        return VINF_IOM_R3_MMIO_READ_WRITE; /** @todo -> REM instead of HC */
    932932
    … …  
    936936    uint64_t const fAddrMask = iomDisModeToMask((DISCPUMODE)pCpu->addrmode);
    937937    RTGCUINTREG cTransfers = 1;
    938     if (pCpu->prefix & DISPREFIX_REP)
     938    if (pCpu->fPrefix & DISPREFIX_REP)
    939939    {
    940940#ifndef IN_RC
    … …  
    983983                pRegFrame->rdi = ((pRegFrame->rdi + (cTransfers << SIZE_2_SHIFT(cb))) & fAddrMask)
    984984                               | (pRegFrame->rdi & ~fAddrMask);
    985                 if (pCpu->prefix & DISPREFIX_REP)
     985                if (pCpu->fPrefix & DISPREFIX_REP)
    986986                    pRegFrame->rcx &= ~fAddrMask;
    987987            }
    … …  
    998998                pRegFrame->rdi = ((pRegFrame->rdi - (cTransfers << SIZE_2_SHIFT(cb))) & fAddrMask)
    999999                               | (pRegFrame->rdi & ~fAddrMask);
    1000                 if (pCpu->prefix & DISPREFIX_REP)
     1000                if (pCpu->fPrefix & DISPREFIX_REP)
    10011001                    pRegFrame->rcx &= ~fAddrMask;
    10021002            }
    … …  
    10251025
    10261026        /* Update rcx on exit. */
    1027         if (pCpu->prefix & DISPREFIX_REP)
     1027        if (pCpu->fPrefix & DISPREFIX_REP)
    10281028            pRegFrame->rcx = (cTransfers & fAddrMask)
    10291029                           | (pRegFrame->rcx & ~fAddrMask);
    … …  
    10621062     * We do not support segment prefixes or REP*.
    10631063     */
    1064     if (pCpu->prefix & (DISPREFIX_SEG | DISPREFIX_REP | DISPREFIX_REPNE))
     1064    if (pCpu->fPrefix & (DISPREFIX_SEG | DISPREFIX_REP | DISPREFIX_REPNE))
    10651065        return VINF_IOM_R3_MMIO_READ_WRITE; /** @todo -> REM instead of HC */
    10661066
    … …  
    21562156    }
    21572157
    2158     return IOMInterpretINSEx(pVM, pRegFrame, Port, pCpu->prefix, (DISCPUMODE)pCpu->addrmode, cb);
     2158    return IOMInterpretINSEx(pVM, pRegFrame, Port, pCpu->fPrefix, (DISCPUMODE)pCpu->addrmode, cb);
    21592159}
    21602160
    … …  
    23252325    }
    23262326
    2327     return IOMInterpretOUTSEx(pVM, pRegFrame, Port, pCpu->prefix, (DISCPUMODE)pCpu->addrmode, cb);
     2327    return IOMInterpretOUTSEx(pVM, pRegFrame, Port, pCpu->fPrefix, (DISCPUMODE)pCpu->addrmode, cb);
    23282328}
    23292329

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

    r41733 r41734  
    108108            if (     RT_SUCCESS(rc)
    109109                &&   pDis->mode == DISCPUMODE_32BIT  /** @todo why does this matter? */
    110                 &&  !(pDis->prefix & (DISPREFIX_REPNE | DISPREFIX_REP | DISPREFIX_SEG)))
     110                &&  !(pDis->fPrefix & (DISPREFIX_REPNE | DISPREFIX_REP | DISPREFIX_SEG)))
    111111            {
    112112                switch (pDis->bOpCode)

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

    r41732 r41734  
    793793        case OP_MOVSWD:
    794794        case OP_STOSWD:
    795             if (    pDis->prefix == (DISPREFIX_REP|DISPREFIX_REX)
     795            if (    pDis->fPrefix == (DISPREFIX_REP|DISPREFIX_REX)
    796796                &&  pRegFrame->rcx >= 0x40
    797797               )
    … …  
    11551155         * Simple instructions, no REP prefix.
    11561156         */
    1157         if (!(pDis->prefix & (DISPREFIX_REP | DISPREFIX_REPNE)))
     1157        if (!(pDis->fPrefix & (DISPREFIX_REP | DISPREFIX_REPNE)))
    11581158        {
    11591159            rc = pgmPoolAccessHandlerSimple(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault, &fReused);
    … …  
    12041204
    12051205            if (    pDis->mode == DISCPUMODE_32BIT
    1206                 &&  pDis->prefix == DISPREFIX_REP
     1206                &&  pDis->fPrefix == DISPREFIX_REP
    12071207                &&  pRegFrame->ecx <= 0x20
    12081208                &&  pRegFrame->ecx * 4 <= PAGE_SIZE - ((uintptr_t)pvFault & PAGE_OFFSET_MASK)
    … …  
    12161216            else
    12171217            if (    pDis->mode == DISCPUMODE_64BIT
    1218                 &&  pDis->prefix == (DISPREFIX_REP | DISPREFIX_REX)
     1218                &&  pDis->fPrefix == (DISPREFIX_REP | DISPREFIX_REX)
    12191219                &&  pRegFrame->rcx <= 0x20
    12201220                &&  pRegFrame->rcx * 8 <= PAGE_SIZE - ((uintptr_t)pvFault & PAGE_OFFSET_MASK)
    … …  
    12381238        STAM_COUNTER_INC(&pPool->CTX_MID_Z(StatMonitor,RepPrefix));
    12391239        Log4(("pgmPoolAccessHandler: eax=%#x ecx=%#x edi=%#x esi=%#x rip=%RGv opcode=%d prefix=%#x\n",
    1240               pRegFrame->eax, pRegFrame->ecx, pRegFrame->edi, pRegFrame->esi, (RTGCPTR)pRegFrame->rip, pDis->pCurInstr->opcode, pDis->prefix));
     1240              pRegFrame->eax, pRegFrame->ecx, pRegFrame->edi, pRegFrame->esi, (RTGCPTR)pRegFrame->rip, pDis->pCurInstr->opcode, pDis->fPrefix));
    12411241        fNotReusedNotForking = true;
    12421242    }

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

    r41732 r41734  
    24182418                    Log2(("IOMInterpretOUTSEx %RGv %x size=%d\n", (RTGCPTR)pCtx->rip, IoExitInfo.n.u16Port, uIOSize));
    24192419                    STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIOStringWrite);
    2420                     rc = IOMInterpretOUTSEx(pVM, CPUMCTX2CORE(pCtx), IoExitInfo.n.u16Port, pDis->prefix, (DISCPUMODE)pDis->addrmode, uIOSize);
     2420                    rc = IOMInterpretOUTSEx(pVM, CPUMCTX2CORE(pCtx), IoExitInfo.n.u16Port, pDis->fPrefix, (DISCPUMODE)pDis->addrmode, uIOSize);
    24212421                }
    24222422                else
    … …  
    24242424                    Log2(("IOMInterpretINSEx  %RGv %x size=%d\n", (RTGCPTR)pCtx->rip, IoExitInfo.n.u16Port, uIOSize));
    24252425                    STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIOStringRead);
    2426                     rc = IOMInterpretINSEx(pVM, CPUMCTX2CORE(pCtx), IoExitInfo.n.u16Port, pDis->prefix, (DISCPUMODE)pDis->addrmode, uIOSize);
     2426                    rc = IOMInterpretINSEx(pVM, CPUMCTX2CORE(pCtx), IoExitInfo.n.u16Port, pDis->fPrefix, (DISCPUMODE)pDis->addrmode, uIOSize);
    24272427                }
    24282428            }

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

    r41732 r41734  
    35853585                        X86EFLAGS eflags;
    35863586
    3587                         if (pDis->prefix & DISPREFIX_OPSIZE)
     3587                        if (pDis->fPrefix & DISPREFIX_OPSIZE)
    35883588                        {
    35893589                            cbParm = 4;
    … …  
    36273627                        X86EFLAGS eflags;
    36283628
    3629                         if (pDis->prefix & DISPREFIX_OPSIZE)
     3629                        if (pDis->fPrefix & DISPREFIX_OPSIZE)
    36303630                        {
    36313631                            cbParm = 4;
    … …  
    36693669                        uint16_t  aIretFrame[3];
    36703670
    3671                         if (pDis->prefix & (DISPREFIX_OPSIZE | DISPREFIX_ADDRSIZE))
     3671                        if (pDis->fPrefix & (DISPREFIX_OPSIZE | DISPREFIX_ADDRSIZE))
    36723672                        {
    36733673                            rc = VERR_EM_INTERPRETER;
    … …  
    43214321                    Log2(("IOMInterpretOUTSEx %RGv %x size=%d\n", (RTGCPTR)pCtx->rip, uPort, cbSize));
    43224322                    STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIOStringWrite);
    4323                     rc = IOMInterpretOUTSEx(pVM, CPUMCTX2CORE(pCtx), uPort, pDis->prefix, (DISCPUMODE)pDis->addrmode, cbSize);
     4323                    rc = IOMInterpretOUTSEx(pVM, CPUMCTX2CORE(pCtx), uPort, pDis->fPrefix, (DISCPUMODE)pDis->addrmode, cbSize);
    43244324                }
    43254325                else
    … …  
    43274327                    Log2(("IOMInterpretINSEx  %RGv %x size=%d\n", (RTGCPTR)pCtx->rip, uPort, cbSize));
    43284328                    STAM_COUNTER_INC(&pVCpu->hwaccm.s.StatExitIOStringRead);
    4329                     rc = IOMInterpretINSEx(pVM, CPUMCTX2CORE(pCtx), uPort, pDis->prefix, (DISCPUMODE)pDis->addrmode, cbSize);
     4329                    rc = IOMInterpretINSEx(pVM, CPUMCTX2CORE(pCtx), uPort, pDis->fPrefix, (DISCPUMODE)pDis->addrmode, cbSize);
    43304330                }
    43314331            }

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

    r41732 r41734  
    307307        rcStrict = VINF_EM_RAW_EMULATE_INSTR;
    308308
    309         if (!(Cpu.prefix & (DISPREFIX_REP | DISPREFIX_REPNE)))
     309        if (!(Cpu.fPrefix & (DISPREFIX_REP | DISPREFIX_REPNE)))
    310310        {
    311311            switch (Cpu.pCurInstr->opcode)
    … …  
    326326            }
    327327        }
    328         else if (Cpu.prefix & DISPREFIX_REP)
     328        else if (Cpu.fPrefix & DISPREFIX_REP)
    329329        {
    330330            switch (Cpu.pCurInstr->opcode)

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

    r41732 r41734  
    428428        VBOXSTRICTRC rcStrict = VINF_EM_RAW_EMULATE_INSTR;
    429429
    430         if (!(Cpu.prefix & (DISPREFIX_REP | DISPREFIX_REPNE)))
     430        if (!(Cpu.fPrefix & (DISPREFIX_REP | DISPREFIX_REPNE)))
    431431        {
    432432            switch (Cpu.pCurInstr->opcode)
    … …  
    447447            }
    448448        }
    449         else if (Cpu.prefix & DISPREFIX_REP)
     449        else if (Cpu.fPrefix & DISPREFIX_REP)
    450450        {
    451451            switch (Cpu.pCurInstr->opcode)

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

    r41732 r41734  
    16541654         */
    16551655        Log(("patmRecompileCallback: jump to code we've recompiled before %RRv!\n", pCurInstrGC));
    1656         return patmPatchGenRelJump(pVM, pPatch, pCurInstrGC, OP_JMP, !!(pCpu->prefix & DISPREFIX_OPSIZE));
     1656        return patmPatchGenRelJump(pVM, pPatch, pCurInstrGC, OP_JMP, !!(pCpu->fPrefix & DISPREFIX_OPSIZE));
    16571657    }
    16581658
    … …  
    17131713        }
    17141714        else
    1715             rc = patmPatchGenRelJump(pVM, pPatch, pTargetGC, pCpu->pCurInstr->opcode, !!(pCpu->prefix & DISPREFIX_OPSIZE));
     1715            rc = patmPatchGenRelJump(pVM, pPatch, pTargetGC, pCpu->pCurInstr->opcode, !!(pCpu->fPrefix & DISPREFIX_OPSIZE));
    17161716
    17171717        if (RT_SUCCESS(rc))
    … …  
    18551855            fGenerateJmpBack = false;
    18561856
    1857         rc = patmPatchGenPopf(pVM, pPatch, pCurInstrGC + pCpu->cbInstr, !!(pCpu->prefix & DISPREFIX_OPSIZE), fGenerateJmpBack);
     1857        rc = patmPatchGenPopf(pVM, pPatch, pCurInstrGC + pCpu->cbInstr, !!(pCpu->fPrefix & DISPREFIX_OPSIZE), fGenerateJmpBack);
    18581858        if (RT_SUCCESS(rc))
    18591859        {
    … …  
    18731873
    18741874    case OP_PUSHF:
    1875         rc = patmPatchGenPushf(pVM, pPatch, !!(pCpu->prefix & DISPREFIX_OPSIZE));
     1875        rc = patmPatchGenPushf(pVM, pPatch, !!(pCpu->fPrefix & DISPREFIX_OPSIZE));
    18761876        if (RT_SUCCESS(rc))
    18771877            rc = VWRN_CONTINUE_RECOMPILE;
    … …  
    18901890    case OP_IRET:
    18911891        Log(("IRET at %RRv\n", pCurInstrGC));
    1892         rc = patmPatchGenIret(pVM, pPatch, pCurInstrGC, !!(pCpu->prefix & DISPREFIX_OPSIZE));
     1892        rc = patmPatchGenIret(pVM, pPatch, pCurInstrGC, !!(pCpu->fPrefix & DISPREFIX_OPSIZE));
    18931893        if (RT_SUCCESS(rc))
    18941894        {

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

    r41732 r41734  
    702702        offset = 0;
    703703        /* include prefix byte to make sure we don't use the incorrect selector register. */
    704         if (pCpu->prefix & DISPREFIX_SEG)
     704        if (pCpu->fPrefix & DISPREFIX_SEG)
    705705            pPB[offset++] = DISQuerySegPrefixByte(pCpu);
    706706        pPB[offset++] = 0xFF;              // push r/m32
    707707        pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, 6 /* group 5 */, pCpu->ModRM.Bits.Rm);
    708708        i = 2;  /* standard offset of modrm bytes */
    709         if (pCpu->prefix & DISPREFIX_OPSIZE)
     709        if (pCpu->fPrefix & DISPREFIX_OPSIZE)
    710710            i++;    //skip operand prefix
    711         if (pCpu->prefix & DISPREFIX_SEG)
     711        if (pCpu->fPrefix & DISPREFIX_SEG)
    712712            i++;    //skip segment prefix
    713713
    … …  
    798798    offset = 0;
    799799    /* include prefix byte to make sure we don't use the incorrect selector register. */
    800     if (pCpu->prefix & DISPREFIX_SEG)
     800    if (pCpu->fPrefix & DISPREFIX_SEG)
    801801        pPB[offset++] = DISQuerySegPrefixByte(pCpu);
    802802
    … …  
    804804    pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, 6 /* group 5 */, pCpu->ModRM.Bits.Rm);
    805805    i = 2;  /* standard offset of modrm bytes */
    806     if (pCpu->prefix & DISPREFIX_OPSIZE)
     806    if (pCpu->fPrefix & DISPREFIX_OPSIZE)
    807807        i++;    //skip operand prefix
    808     if (pCpu->prefix & DISPREFIX_SEG)
     808    if (pCpu->fPrefix & DISPREFIX_SEG)
    809809        i++;    //skip segment prefix
    810810
    … …  
    12771277    PATCHGEN_PROLOG_NODEF(pVM, pPatch);
    12781278    offset = 0;
    1279     if (pCpu->prefix & DISPREFIX_OPSIZE)
     1279    if (pCpu->fPrefix & DISPREFIX_OPSIZE)
    12801280        pPB[offset++] = 0x66;       /* size override -> 16 bits push */
    12811281    pPB[offset++] = 0x16;
    … …  
    12901290    PATCHGEN_PROLOG_NODEF(pVM, pPatch);
    12911291    offset = 0;
    1292     if (pCpu->prefix & DISPREFIX_OPSIZE)
     1292    if (pCpu->fPrefix & DISPREFIX_OPSIZE)
    12931293        pPB[offset++] = 0x66; /* size override -> 16 bits pop */
    12941294    pPB[offset++] = 0x58 + pCpu->param1.base.reg_gen;
    … …  
    13211321
    13221322    /** @todo segment prefix (untested) */
    1323     Assert(pCpu->prefix == DISPREFIX_NONE || pCpu->prefix == DISPREFIX_OPSIZE);
     1323    Assert(pCpu->fPrefix == DISPREFIX_NONE || pCpu->fPrefix == DISPREFIX_OPSIZE);
    13241324
    13251325    PATCHGEN_PROLOG(pVM, pPatch);
    … …  
    13301330        // 8B 15 [32 bits addr]   mov edx, CPUMCTX.tr/ldtr
    13311331
    1332         if (pCpu->prefix == DISPREFIX_OPSIZE)
     1332        if (pCpu->fPrefix == DISPREFIX_OPSIZE)
    13331333            pPB[offset++] = 0x66;
    13341334
    … …  
    13611361        pPB[offset++] = 0x52;              // push      edx
    13621362
    1363         if (pCpu->prefix == DISPREFIX_SEG)
     1363        if (pCpu->fPrefix == DISPREFIX_SEG)
    13641364        {
    13651365            pPB[offset++] = DISQuerySegPrefixByte(pCpu);
    … …  
    13701370
    13711371        i = 3;  /* standard offset of modrm bytes */
    1372         if (pCpu->prefix == DISPREFIX_OPSIZE)
     1372        if (pCpu->fPrefix == DISPREFIX_OPSIZE)
    13731373            i++;    //skip operand prefix
    1374         if (pCpu->prefix == DISPREFIX_SEG)
     1374        if (pCpu->fPrefix == DISPREFIX_SEG)
    13751375            i++;    //skip segment prefix
    13761376
    … …  
    14211421
    14221422    /* @todo segment prefix (untested) */
    1423     Assert(pCpu->prefix == DISPREFIX_NONE);
     1423    Assert(pCpu->fPrefix == DISPREFIX_NONE);
    14241424
    14251425    // sgdt %Ms
    … …  
    14561456    pPB[offset++] = 0x52;              // push      edx
    14571457
    1458     if (pCpu->prefix == DISPREFIX_SEG)
     1458    if (pCpu->fPrefix == DISPREFIX_SEG)
    14591459    {
    14601460        pPB[offset++] = DISQuerySegPrefixByte(pCpu);
    … …  
    14651465
    14661466    i = 3;  /* standard offset of modrm bytes */
    1467     if (pCpu->prefix == DISPREFIX_OPSIZE)
     1467    if (pCpu->fPrefix == DISPREFIX_OPSIZE)
    14681468        i++;    //skip operand prefix
    1469     if (pCpu->prefix == DISPREFIX_SEG)
     1469    if (pCpu->fPrefix == DISPREFIX_SEG)
    14701470        i++;    //skip segment prefix
    14711471    rc = patmPatchReadBytes(pVM, &pPB[offset], (RTRCPTR)((RTGCUINTPTR32)pCurInstrGC + i), pCpu->cbInstr - i);

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

    r41732 r41734  
    542542         * Speed up dtrace and don't entrust invalid lock sequences to the recompiler.
    543543         */
    544         else if (Cpu.prefix & DISPREFIX_LOCK)
     544        else if (Cpu.fPrefix & DISPREFIX_LOCK)
    545545        {
    546546            Log(("TRPMGCTrap06Handler: pc=%08x op=%d\n", pRegFrame->eip, Cpu.pCurInstr->opcode));
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