VirtualBox

Changeset 41675 in vbox


Ignore:
Timestamp:
Jun 12, 2012 8:27:37 PM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
78482
Message:

DIS: The start of the scoping exercise... Fixed PREFIX_ADDRSIZE that I just busted in the previous commit.

Location:
trunk
Files:
34 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/include/VBox/dis.h

    r41674 r41675  
    2424 */
    2525
    26 #ifndef ___VBox_disasm_h
    27 #define ___VBox_disasm_h
     26#ifndef ___VBox_dis_h
     27#define ___VBox_dis_h
    2828
    2929#include <VBox/cdefs.h>
    … …  
    4040typedef enum DISCPUMODE
    4141{
    42     CPUMODE_INVALID = 0,
    43     CPUMODE_16BIT,
    44     CPUMODE_32BIT,
    45     CPUMODE_64BIT,
     42    DISCPUMODE_INVALID = 0,
     43    DISCPUMODE_16BIT,
     44    DISCPUMODE_32BIT,
     45    DISCPUMODE_64BIT,
    4646    /** hack forcing the size of the enum to 32-bits. */
    47     CPUMODE_MAKE_32BIT_HACK = 0x7fffffff
     47    DISCPUMODE_MAKE_32BIT_HACK = 0x7fffffff
    4848} DISCPUMODE;
    4949
    … …  
    5151 * @{
    5252 */
    53 #define PREFIX_NONE                     0
     53#define DISPREFIX_NONE                  UINT8_C(0x00)
    5454/** non-default address size. */
    55 #define PREFIX_ADDRSIZE                 UINT8_C(0x00)
     55#define DISPREFIX_ADDRSIZE              UINT8_C(0x01)
    5656/** non-default operand size. */
    57 #define PREFIX_OPSIZE                   UINT8_C(0x01)
     57#define DISPREFIX_OPSIZE                UINT8_C(0x02)
    5858/** lock prefix. */
    59 #define PREFIX_LOCK                     UINT8_C(0x02)
     59#define DISPREFIX_LOCK                  UINT8_C(0x04)
    6060/** segment prefix. */
    61 #define PREFIX_SEG                      UINT8_C(0x04)
     61#define DISPREFIX_SEG                   UINT8_C(0x08)
    6262/** rep(e) prefix (not a prefix, but we'll treat is as one). */
    63 #define PREFIX_REP                      UINT8_C(0x08)
     63#define DISPREFIX_REP                   UINT8_C(0x10)
    6464/** rep(e) prefix (not a prefix, but we'll treat is as one). */
    65 #define PREFIX_REPNE                    UINT8_C(0x10)
     65#define DISPREFIX_REPNE                 UINT8_C(0x20)
    6666/** REX prefix (64 bits) */
    67 #define PREFIX_REX                      UINT8_C(0x20)
     67#define DISPREFIX_REX                   UINT8_C(0x40)
    6868/** @} */
    6969

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

    r41674 r41675  
    968968            unsigned    cbInstr;
    969969            DISCPUSTATE CpuState;
    970             int rc = DISInstrWithReader(uFlatAddr, fIs16Bit ? CPUMODE_16BIT : CPUMODE_32BIT,
     970            int rc = DISInstrWithReader(uFlatAddr, fIs16Bit ? DISCPUMODE_16BIT : DISCPUMODE_32BIT,
    971971                                        disReadOpcodeBytes, NULL, &CpuState, &cbInstr);
    972972            if (   RT_SUCCESS(rc)

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

    r41674 r41675  
    216216 *                          accessed without faulting.  (Consider
    217217 *                          DISInstrWithReader if this isn't the case.)
    218  * @param   enmCpuMode      The CPU mode. CPUMODE_32BIT, CPUMODE_16BIT, or CPUMODE_64BIT.
     218 * @param   enmCpuMode      The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
    219219 * @param   pfnReadBytes    Callback for reading instruction bytes.
    220220 * @param   pvUser          User argument for the instruction reader. (Ends up in apvUserData[0].)
    … …  
    238238 * @param   uInstrAddr      Address of the instruction to decode. What this means
    239239 *                          is left to the pfnReadBytes function.
    240  * @param   enmCpuMode      The CPU mode. CPUMODE_32BIT, CPUMODE_16BIT, or CPUMODE_64BIT.
     240 * @param   enmCpuMode      The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
    241241 * @param   pfnReadBytes    Callback for reading instruction bytes.
    242242 * @param   pvUser          User argument for the instruction reader. (Ends up in apvUserData[0].)
    … …  
    259259 * @param   uInstrAddr      Address of the instruction to decode. What this means
    260260 *                          is left to the pfnReadBytes function.
    261  * @param   enmCpuMode      The CPU mode. CPUMODE_32BIT, CPUMODE_16BIT, or CPUMODE_64BIT.
     261 * @param   enmCpuMode      The CPU mode. DISCPUMODE_32BIT, DISCPUMODE_16BIT, or DISCPUMODE_64BIT.
    262262 * @param   pfnReadBytes    Callback for reading instruction bytes.
    263263 * @param   fFilter         Instruction type filter.
    … …  
    284284
    285285    pCpu->mode              = enmCpuMode;
    286     if (enmCpuMode == CPUMODE_64BIT)
     286    if (enmCpuMode == DISCPUMODE_64BIT)
    287287    {
    288288        paOneByteMap        = g_aOneByteMapX64;
    289         pCpu->addrmode      = CPUMODE_64BIT;
    290         pCpu->opmode        = CPUMODE_32BIT;
     289        pCpu->addrmode      = DISCPUMODE_64BIT;
     290        pCpu->opmode        = DISCPUMODE_32BIT;
    291291    }
    292292    else
    … …  
    296296        pCpu->opmode        = enmCpuMode;
    297297    }
    298     pCpu->prefix            = PREFIX_NONE;
     298    pCpu->prefix            = DISPREFIX_NONE;
    299299    pCpu->enmPrefixSeg      = DIS_SELREG_DS;
    300300    pCpu->uInstrAddr        = uInstrAddr;
    … …  
    338338                /** Last prefix byte (for SSE2 extension tables); don't include the REX prefix */
    339339                pCpu->lastprefix = opcode;
    340                 pCpu->prefix &= ~PREFIX_REX;
     340                pCpu->prefix &= ~DISPREFIX_REX;
    341341            }
    342342
    … …  
    352352                pCpu->enmPrefixSeg = (DIS_SELREG)(paOneByteMap[codebyte].param1 - OP_PARM_REG_SEG_START);
    353353                /* Segment prefixes for CS, DS, ES and SS are ignored in long mode. */
    354                 if (   pCpu->mode != CPUMODE_64BIT
     354                if (   pCpu->mode != DISCPUMODE_64BIT
    355355                    || pCpu->enmPrefixSeg >= DIS_SELREG_FS)
    356356                {
    357                     pCpu->prefix    |= PREFIX_SEG;
     357                    pCpu->prefix    |= DISPREFIX_SEG;
    358358                }
    359359                iByte += sizeof(uint8_t);
    … …  
    362362            // lock prefix byte
    363363            case OP_LOCK:
    364                 pCpu->prefix |= PREFIX_LOCK;
     364                pCpu->prefix |= DISPREFIX_LOCK;
    365365                iByte       += sizeof(uint8_t);
    366366                continue;   //fetch the next byte
    … …  
    368368            // address size override prefix byte
    369369            case OP_ADDRSIZE:
    370                 pCpu->prefix |= PREFIX_ADDRSIZE;
    371                 if (pCpu->mode == CPUMODE_16BIT)
    372                     pCpu->addrmode = CPUMODE_32BIT;
     370                pCpu->prefix |= DISPREFIX_ADDRSIZE;
     371                if (pCpu->mode == DISCPUMODE_16BIT)
     372                    pCpu->addrmode = DISCPUMODE_32BIT;
    373373                else
    374                 if (pCpu->mode == CPUMODE_32BIT)
    375                     pCpu->addrmode = CPUMODE_16BIT;
     374                if (pCpu->mode == DISCPUMODE_32BIT)
     375                    pCpu->addrmode = DISCPUMODE_16BIT;
    376376                else
    377                     pCpu->addrmode = CPUMODE_32BIT;     /* 64 bits */
     377                    pCpu->addrmode = DISCPUMODE_32BIT;     /* 64 bits */
    378378
    379379                iByte        += sizeof(uint8_t);
    … …  
    382382            // operand size override prefix byte
    383383            case OP_OPSIZE:
    384                 pCpu->prefix |= PREFIX_OPSIZE;
    385                 if (pCpu->mode == CPUMODE_16BIT)
    386                     pCpu->opmode = CPUMODE_32BIT;
     384                pCpu->prefix |= DISPREFIX_OPSIZE;
     385                if (pCpu->mode == DISCPUMODE_16BIT)
     386                    pCpu->opmode = DISCPUMODE_32BIT;
    387387                else
    388                     pCpu->opmode = CPUMODE_16BIT;  /* for 32 and 64 bits mode (there is no 32 bits operand size override prefix) */
     388                    pCpu->opmode = DISCPUMODE_16BIT;  /* for 32 and 64 bits mode (there is no 32 bits operand size override prefix) */
    389389
    390390                iByte        += sizeof(uint8_t);
    … …  
    393393            // rep and repne are not really prefixes, but we'll treat them as such
    394394            case OP_REPE:
    395                 pCpu->prefix |= PREFIX_REP;
     395                pCpu->prefix |= DISPREFIX_REP;
    396396                iByte       += sizeof(uint8_t);
    397397                continue;   //fetch the next byte
    398398
    399399            case OP_REPNE:
    400                 pCpu->prefix |= PREFIX_REPNE;
     400                pCpu->prefix |= DISPREFIX_REPNE;
    401401                iByte       += sizeof(uint8_t);
    402402                continue;   //fetch the next byte
    403403
    404404            case OP_REX:
    405                 Assert(pCpu->mode == CPUMODE_64BIT);
     405                Assert(pCpu->mode == DISCPUMODE_64BIT);
    406406                /* REX prefix byte */
    407                 pCpu->prefix    |= PREFIX_REX;
     407                pCpu->prefix    |= DISPREFIX_REX;
    408408                pCpu->prefix_rex = PREFIX_REX_OP_2_FLAGS(paOneByteMap[codebyte].param1);
    409409                iByte           += sizeof(uint8_t);
    410410
    411411                if (pCpu->prefix_rex & PREFIX_REX_FLAGS_W)
    412                     pCpu->opmode = CPUMODE_64BIT;  /* overrides size prefix byte */
     412                    pCpu->opmode = DISCPUMODE_64BIT;  /* overrides size prefix byte */
    413413                continue;   //fetch the next byte
    414414            }
    … …  
    430430        *pcbInstr = iByte;
    431431
    432     if (pCpu->prefix & PREFIX_LOCK)
     432    if (pCpu->prefix & DISPREFIX_LOCK)
    433433        disValidateLockSequence(pCpu);
    434434
    … …  
    471471
    472472    /* Correct the operand size if the instruction is marked as forced or default 64 bits */
    473     if (pCpu->mode == CPUMODE_64BIT)
     473    if (pCpu->mode == DISCPUMODE_64BIT)
    474474    {
    475475        if (pOp->optype & OPTYPE_FORCED_64_OP_SIZE)
    476             pCpu->opmode = CPUMODE_64BIT;
     476            pCpu->opmode = DISCPUMODE_64BIT;
    477477        else
    478478        if (    (pOp->optype & OPTYPE_DEFAULT_64_OP_SIZE)
    479             &&  !(pCpu->prefix & PREFIX_OPSIZE))
    480             pCpu->opmode = CPUMODE_64BIT;
     479            &&  !(pCpu->prefix & DISPREFIX_OPSIZE))
     480            pCpu->opmode = DISCPUMODE_64BIT;
    481481    }
    482482    else
    … …  
    484484    {
    485485        /* Forced 32 bits operand size for certain instructions (mov crx, mov drx). */
    486         Assert(pCpu->mode != CPUMODE_64BIT);
    487         pCpu->opmode = CPUMODE_32BIT;
     486        Assert(pCpu->mode != DISCPUMODE_64BIT);
     487        pCpu->opmode = DISCPUMODE_32BIT;
    488488    }
    489489
    … …  
    549549
    550550    /* Correct the operand size if the instruction is marked as forced or default 64 bits */
    551     if (pCpu->mode == CPUMODE_64BIT)
     551    if (pCpu->mode == DISCPUMODE_64BIT)
    552552    {
    553553        /* Note: redundant, but just in case this ever changes */
    554554        if (fpop->optype & OPTYPE_FORCED_64_OP_SIZE)
    555             pCpu->opmode = CPUMODE_64BIT;
     555            pCpu->opmode = DISCPUMODE_64BIT;
    556556        else
    557557        if (    (fpop->optype & OPTYPE_DEFAULT_64_OP_SIZE)
    558             &&  !(pCpu->prefix & PREFIX_OPSIZE))
    559             pCpu->opmode = CPUMODE_64BIT;
     558            &&  !(pCpu->prefix & DISPREFIX_OPSIZE))
     559            pCpu->opmode = DISCPUMODE_64BIT;
    560560    }
    561561
    … …  
    601601    index = pCpu->SIB.Bits.Index;
    602602
    603     if (pCpu->addrmode == CPUMODE_32BIT)
     603    if (pCpu->addrmode == DISCPUMODE_32BIT)
    604604    {
    605605        ppszSIBIndexReg = szSIBIndexReg;
    … …  
    629629    {
    630630        // [scaled index] + disp32
    631         if (pCpu->addrmode == CPUMODE_32BIT)
     631        if (pCpu->addrmode == DISCPUMODE_32BIT)
    632632        {
    633633            pParam->flags |= USE_DISPLACEMENT32;
    … …  
    662662    pCpu->SIB.Bits.Scale = SIB_SCALE(SIB);
    663663
    664     if (pCpu->prefix & PREFIX_REX)
     664    if (pCpu->prefix & 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 & PREFIX_REX)
     697    if (pCpu->prefix & DISPREFIX_REX)
    698698    {
    699699        /* REX.B extends the Base field. */
    … …  
    738738
    739739                if (    pCpu->pCurInstr->opcode == OP_MOV_CR
    740                     &&  pCpu->opmode == CPUMODE_32BIT
    741                     &&  (pCpu->prefix & PREFIX_LOCK))
     740                    &&  pCpu->opmode == DISCPUMODE_32BIT
     741                    &&  (pCpu->prefix & DISPREFIX_LOCK))
    742742                {
    743                     pCpu->prefix &= ~PREFIX_LOCK;
     743                    pCpu->prefix &= ~DISPREFIX_LOCK;
    744744                    pParam->base.reg_ctrl = USE_REG_CR8;
    745745                }
    … …  
    787787    /* @todo bound */
    788788
    789     if (pCpu->addrmode != CPUMODE_16BIT)
    790     {
    791         Assert(pCpu->addrmode == CPUMODE_32BIT || pCpu->addrmode == CPUMODE_64BIT);
     789    if (pCpu->addrmode != DISCPUMODE_16BIT)
     790    {
     791        Assert(pCpu->addrmode == DISCPUMODE_32BIT || pCpu->addrmode == DISCPUMODE_64BIT);
    792792
    793793        /*
    … …  
    805805            {
    806806                /* 32 bits displacement */
    807                 if (pCpu->mode != CPUMODE_64BIT)
     807                if (pCpu->mode != DISCPUMODE_64BIT)
    808808                {
    809809                    pParam->flags |= USE_DISPLACEMENT32;
    … …  
    906906    *pSibInc = 0;
    907907
    908     if (pCpu->addrmode != CPUMODE_16BIT)
    909     {
    910         Assert(pCpu->addrmode == CPUMODE_32BIT || pCpu->addrmode == CPUMODE_64BIT);
     908    if (pCpu->addrmode != DISCPUMODE_16BIT)
     909    {
     910        Assert(pCpu->addrmode == DISCPUMODE_32BIT || pCpu->addrmode == DISCPUMODE_64BIT);
    911911
    912912        /*
    … …  
    989989    *pSibInc = 0;
    990990
    991     if (pCpu->addrmode != CPUMODE_16BIT)
    992     {
    993         Assert(pCpu->addrmode == CPUMODE_32BIT || pCpu->addrmode == CPUMODE_64BIT);
     991    if (pCpu->addrmode != DISCPUMODE_16BIT)
     992    {
     993        Assert(pCpu->addrmode == DISCPUMODE_32BIT || pCpu->addrmode == DISCPUMODE_64BIT);
    994994        /*
    995995         * Note: displacements in long mode are 8 or 32 bits and sign-extended to 64 bits
    … …  
    10801080        pCpu->ModRM.Bits.Mod = 3;
    10811081
    1082     if (pCpu->prefix & PREFIX_REX)
    1083     {
    1084         Assert(pCpu->mode == CPUMODE_64BIT);
     1082    if (pCpu->prefix & DISPREFIX_REX)
     1083    {
     1084        Assert(pCpu->mode == DISCPUMODE_64BIT);
    10851085
    10861086        /* REX.R extends the Reg field. */
    … …  
    11261126        pCpu->ModRM.Bits.Mod = 3;
    11271127
    1128     if (pCpu->prefix & PREFIX_REX)
    1129     {
    1130         Assert(pCpu->mode == CPUMODE_64BIT);
     1128    if (pCpu->prefix & DISPREFIX_REX)
     1129    {
     1130        Assert(pCpu->mode == DISCPUMODE_64BIT);
    11311131
    11321132        /* REX.R extends the Reg field. */
    … …  
    11811181{
    11821182    NOREF(pOp);
    1183     if (pCpu->opmode == CPUMODE_32BIT)
     1183    if (pCpu->opmode == DISCPUMODE_32BIT)
    11841184    {
    11851185        pParam->parval = (uint32_t)(int8_t)DISReadByte(pCpu, uCodePtr);
    … …  
    11881188    }
    11891189    else
    1190     if (pCpu->opmode == CPUMODE_64BIT)
     1190    if (pCpu->opmode == DISCPUMODE_64BIT)
    11911191    {
    11921192        pParam->parval = (uint64_t)(int8_t)DISReadByte(pCpu, uCodePtr);
    … …  
    12651265{
    12661266    NOREF(pOp);
    1267     if (pCpu->opmode == CPUMODE_32BIT)
     1267    if (pCpu->opmode == DISCPUMODE_32BIT)
    12681268    {
    12691269        pParam->parval = DISReadDWord(pCpu, uCodePtr);
    … …  
    12731273    }
    12741274
    1275     if (pCpu->opmode == CPUMODE_64BIT)
     1275    if (pCpu->opmode == DISCPUMODE_64BIT)
    12761276    {
    12771277        pParam->parval = DISReadQWord(pCpu, uCodePtr);
    … …  
    12911291{
    12921292    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
    1293     if (pCpu->opmode == CPUMODE_32BIT)
     1293    if (pCpu->opmode == DISCPUMODE_32BIT)
    12941294        return sizeof(uint32_t);
    1295     if (pCpu->opmode == CPUMODE_64BIT)
     1295    if (pCpu->opmode == DISCPUMODE_64BIT)
    12961296        return sizeof(uint64_t);
    12971297    return sizeof(uint16_t);
    … …  
    13031303    NOREF(pOp);
    13041304    /* Word for 16-bit operand-size or doubleword for 32 or 64-bit operand-size. */
    1305     if (pCpu->opmode == CPUMODE_16BIT)
     1305    if (pCpu->opmode == DISCPUMODE_16BIT)
    13061306    {
    13071307        pParam->parval = DISReadWord(pCpu, uCodePtr);
    … …  
    13121312
    13131313    /* 64 bits op mode means *sign* extend to 64 bits. */
    1314     if (pCpu->opmode == CPUMODE_64BIT)
     1314    if (pCpu->opmode == DISCPUMODE_64BIT)
    13151315    {
    13161316        pParam->parval = (uint64_t)(int32_t)DISReadDWord(pCpu, uCodePtr);
    … …  
    13321332    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
    13331333    /* Word for 16-bit operand-size or doubleword for 32 or 64-bit operand-size. */
    1334     if (pCpu->opmode == CPUMODE_16BIT)
     1334    if (pCpu->opmode == DISCPUMODE_16BIT)
    13351335        return sizeof(uint16_t);
    13361336    return sizeof(uint32_t);
    … …  
    13621362{
    13631363    NOREF(pOp);
    1364     if (pCpu->opmode == CPUMODE_32BIT)
     1364    if (pCpu->opmode == DISCPUMODE_32BIT)
    13651365    {
    13661366        pParam->parval = DISReadDWord(pCpu, uCodePtr);
    … …  
    13701370    }
    13711371
    1372     if (pCpu->opmode == CPUMODE_64BIT)
     1372    if (pCpu->opmode == DISCPUMODE_64BIT)
    13731373    {
    13741374        /* 32 bits relative immediate sign extended to 64 bits. */
    … …  
    13901390{
    13911391    NOREF(uCodePtr); NOREF(pOp); NOREF(pParam);
    1392     if (pCpu->opmode == CPUMODE_16BIT)
     1392    if (pCpu->opmode == DISCPUMODE_16BIT)
    13931393        return sizeof(int16_t);
    13941394    /* Both 32 & 64 bits mode use 32 bits relative immediates. */
    … …  
    13991399unsigned ParseImmAddr(RTUINTPTR uCodePtr, PCOPCODE pOp, POP_PARAMETER pParam, PDISCPUSTATE pCpu)
    14001400{
    1401     if (pCpu->addrmode == CPUMODE_32BIT)
     1401    if (pCpu->addrmode == DISCPUMODE_32BIT)
    14021402    {
    14031403        if (OP_PARM_VSUBTYPE(pParam->param) == OP_PARM_p)
    … …  
    14231423    }
    14241424
    1425     if (pCpu->addrmode == CPUMODE_64BIT)
     1425    if (pCpu->addrmode == DISCPUMODE_64BIT)
    14261426    {
    14271427        Assert(OP_PARM_VSUBTYPE(pParam->param) != OP_PARM_p);
    … …  
    14621462{
    14631463    NOREF(uCodePtr); NOREF(pOp);
    1464     if (pCpu->addrmode == CPUMODE_32BIT)
     1464    if (pCpu->addrmode == DISCPUMODE_32BIT)
    14651465    {
    14661466        if (OP_PARM_VSUBTYPE(pParam->param) == OP_PARM_p)
    … …  
    14731473        }
    14741474    }
    1475     if (pCpu->addrmode == CPUMODE_64BIT)
     1475    if (pCpu->addrmode == DISCPUMODE_64BIT)
    14761476    {
    14771477        Assert(OP_PARM_VSUBTYPE(pParam->param) != OP_PARM_p);
    … …  
    14951495{
    14961496    // immediate far pointers - only 16:16 or 16:32; determined by operand, *not* address size!
    1497     Assert(pCpu->opmode == CPUMODE_16BIT || pCpu->opmode == CPUMODE_32BIT);
     1497    Assert(pCpu->opmode == DISCPUMODE_16BIT || pCpu->opmode == DISCPUMODE_32BIT);
    14981498    Assert(OP_PARM_VSUBTYPE(pParam->param) == OP_PARM_p);
    1499     if (pCpu->opmode == CPUMODE_32BIT)
     1499    if (pCpu->opmode == DISCPUMODE_32BIT)
    15001500    {
    15011501        // far 16:32 pointer
    … …  
    15191519    NOREF(uCodePtr); NOREF(pOp);
    15201520    // immediate far pointers - only 16:16 or 16:32
    1521     Assert(pCpu->opmode == CPUMODE_16BIT || pCpu->opmode == CPUMODE_32BIT);
     1521    Assert(pCpu->opmode == DISCPUMODE_16BIT || pCpu->opmode == DISCPUMODE_32BIT);
    15221522    Assert(OP_PARM_VSUBTYPE(pParam->param) == OP_PARM_p);
    1523     if (pCpu->opmode == CPUMODE_32BIT)
     1523    if (pCpu->opmode == DISCPUMODE_32BIT)
    15241524    {
    15251525        // far 16:32 pointer
    … …  
    15561556    {
    15571557        /* 32-bit EAX..EDI registers. */
    1558         if (pCpu->opmode == CPUMODE_32BIT)
     1558        if (pCpu->opmode == DISCPUMODE_32BIT)
    15591559        {
    15601560            /* Use 32-bit registers. */
    … …  
    15641564        }
    15651565        else
    1566         if (pCpu->opmode == CPUMODE_64BIT)
     1566        if (pCpu->opmode == DISCPUMODE_64BIT)
    15671567        {
    15681568            /* Use 64-bit registers. */
    … …  
    15701570            if (    (pOp->optype & OPTYPE_REXB_EXTENDS_OPREG)
    15711571                &&  pParam == &pCpu->param1             /* ugly assumption that it only applies to the first parameter */
    1572                 &&  (pCpu->prefix & PREFIX_REX)
     1572                &&  (pCpu->prefix & DISPREFIX_REX)
    15731573                &&  (pCpu->prefix_rex & PREFIX_REX_FLAGS))
    15741574                pParam->base.reg_gen += 8;
    … …  
    16101610        pParam->cb     = 1;
    16111611
    1612         if (pCpu->opmode == CPUMODE_64BIT)
     1612        if (pCpu->opmode == DISCPUMODE_64BIT)
    16131613        {
    16141614            if (    (pOp->optype & OPTYPE_REXB_EXTENDS_OPREG)
    16151615                &&  pParam == &pCpu->param1             /* ugly assumption that it only applies to the first parameter */
    1616                 &&  (pCpu->prefix & PREFIX_REX)
     1616                &&  (pCpu->prefix & DISPREFIX_REX)
    16171617                &&  (pCpu->prefix_rex & PREFIX_REX_FLAGS))
    16181618                pParam->base.reg_gen += 8;              /* least significant byte of R8-R15 */
    … …  
    16401640
    16411641    pParam->flags |= USE_POINTER_DS_BASED;
    1642     if (pCpu->addrmode == CPUMODE_32BIT)
     1642    if (pCpu->addrmode == DISCPUMODE_32BIT)
    16431643    {
    16441644        pParam->base.reg_gen = USE_REG_ESI;
    … …  
    16461646    }
    16471647    else
    1648     if (pCpu->addrmode == CPUMODE_64BIT)
     1648    if (pCpu->addrmode == DISCPUMODE_64BIT)
    16491649    {
    16501650        pParam->base.reg_gen = USE_REG_RSI;
    … …  
    16651665
    16661666    pParam->flags |= USE_POINTER_DS_BASED;
    1667     if (pCpu->addrmode == CPUMODE_32BIT)
     1667    if (pCpu->addrmode == DISCPUMODE_32BIT)
    16681668    {
    16691669        pParam->base.reg_gen = USE_REG_ESI;
    … …  
    16711671    }
    16721672    else
    1673     if (pCpu->addrmode == CPUMODE_64BIT)
     1673    if (pCpu->addrmode == DISCPUMODE_64BIT)
    16741674    {
    16751675        pParam->base.reg_gen = USE_REG_RSI;
    … …  
    16901690
    16911691    pParam->flags |= USE_POINTER_ES_BASED;
    1692     if (pCpu->addrmode == CPUMODE_32BIT)
     1692    if (pCpu->addrmode == DISCPUMODE_32BIT)
    16931693    {
    16941694        pParam->base.reg_gen = USE_REG_EDI;
    … …  
    16961696    }
    16971697    else
    1698     if (pCpu->addrmode == CPUMODE_64BIT)
     1698    if (pCpu->addrmode == DISCPUMODE_64BIT)
    16991699    {
    17001700        pParam->base.reg_gen = USE_REG_RDI;
    … …  
    17151715
    17161716    pParam->flags |= USE_POINTER_ES_BASED;
    1717     if (pCpu->addrmode == CPUMODE_32BIT)
     1717    if (pCpu->addrmode == DISCPUMODE_32BIT)
    17181718    {
    17191719        pParam->base.reg_gen = USE_REG_EDI;
    … …  
    17211721    }
    17221722    else
    1723     if (pCpu->addrmode == CPUMODE_64BIT)
     1723    if (pCpu->addrmode == DISCPUMODE_64BIT)
    17241724    {
    17251725        pParam->base.reg_gen = USE_REG_RDI;
    … …  
    17601760
    17611761                /* Cancel prefix changes. */
    1762                 pCpu->prefix &= ~PREFIX_OPSIZE;
     1762                pCpu->prefix &= ~DISPREFIX_OPSIZE;
    17631763                pCpu->opmode  = pCpu->mode;
    17641764            }
    … …  
    17721772
    17731773                /* Cancel prefix changes. */
    1774                 pCpu->prefix &= ~PREFIX_REPNE;
     1774                pCpu->prefix &= ~DISPREFIX_REPNE;
    17751775            }
    17761776            break;
    … …  
    17831783
    17841784                /* Cancel prefix changes. */
    1785                 pCpu->prefix &= ~PREFIX_REP;
     1785                pCpu->prefix &= ~DISPREFIX_REP;
    17861786            }
    17871787            break;
    … …  
    18271827
    18281828                /* Cancel prefix changes. */
    1829                 pCpu->prefix &= ~PREFIX_OPSIZE;
     1829                pCpu->prefix &= ~DISPREFIX_OPSIZE;
    18301830                pCpu->opmode  = pCpu->mode;
    18311831            }
    … …  
    18441844
    18451845                /* Cancel prefix changes. */
    1846                 pCpu->prefix &= ~PREFIX_REPNE;
     1846                pCpu->prefix &= ~DISPREFIX_REPNE;
    18471847            }
    18481848        }
    … …  
    18781878
    18791879            /* Cancel prefix changes. */
    1880             pCpu->prefix &= ~PREFIX_OPSIZE;
     1880            pCpu->prefix &= ~DISPREFIX_OPSIZE;
    18811881            pCpu->opmode  = pCpu->mode;
    18821882        }
    … …  
    18951895    NOREF(pParam);
    18961896
    1897     if (pCpu->prefix & PREFIX_REP)
     1897    if (pCpu->prefix & DISPREFIX_REP)
    18981898    {
    18991899        pOp = &g_aMapX86_NopPause[1]; /* PAUSE */
    1900         pCpu->prefix &= ~PREFIX_REP;
     1900        pCpu->prefix &= ~DISPREFIX_REP;
    19011901    }
    19021902    else
    … …  
    21852185    reg   = MODRM_REG(modrm);
    21862186
    2187     if (pCpu->prefix & PREFIX_OPSIZE)
     2187    if (pCpu->prefix & DISPREFIX_OPSIZE)
    21882188        reg += 8;   //2nd table
    21892189
    … …  
    22062206    modrm = DISReadByte(pCpu, uCodePtr);
    22072207    reg   = MODRM_REG(modrm);
    2208     if (pCpu->prefix & PREFIX_OPSIZE)
     2208    if (pCpu->prefix & DISPREFIX_OPSIZE)
    22092209        reg += 8;   //2nd table
    22102210
    … …  
    22282228    modrm = DISReadByte(pCpu, uCodePtr);
    22292229    reg   = MODRM_REG(modrm);
    2230     if (pCpu->prefix & PREFIX_OPSIZE)
     2230    if (pCpu->prefix & DISPREFIX_OPSIZE)
    22312231        reg += 8;   //2nd table
    22322232
    … …  
    23062306    subtype = OP_PARM_VSUBTYPE(pParam->param);
    23072307    if (fRegAddr)
    2308         subtype = (pCpu->addrmode == CPUMODE_64BIT) ? OP_PARM_q : OP_PARM_d;
     2308        subtype = (pCpu->addrmode == DISCPUMODE_64BIT) ? OP_PARM_q : OP_PARM_d;
    23092309    else
    23102310    if (subtype == OP_PARM_v || subtype == OP_PARM_NONE)
    … …  
    23122312        switch(pCpu->opmode)
    23132313        {
    2314         case CPUMODE_32BIT:
     2314        case DISCPUMODE_32BIT:
    23152315            subtype = OP_PARM_d;
    23162316            break;
    2317         case CPUMODE_64BIT:
     2317        case DISCPUMODE_64BIT:
    23182318            subtype = OP_PARM_q;
    23192319            break;
    2320         case CPUMODE_16BIT:
     2320        case DISCPUMODE_16BIT:
    23212321            subtype = OP_PARM_w;
    23222322            break;
    … …  
    23302330    {
    23312331    case OP_PARM_b:
    2332         Assert(idx < (pCpu->prefix & PREFIX_REX) ? 16 : 8);
     2332        Assert(idx < (pCpu->prefix & DISPREFIX_REX) ? 16 : 8);
    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 & PREFIX_REX)
     2336        if (    (pCpu->prefix & DISPREFIX_REX)
    23372337            &&  idx >= USE_REG_AH
    23382338            &&  idx <= USE_REG_BH)
    … …  
    23462346
    23472347    case OP_PARM_w:
    2348         Assert(idx < (pCpu->prefix & PREFIX_REX) ? 16 : 8);
     2348        Assert(idx < (pCpu->prefix & DISPREFIX_REX) ? 16 : 8);
    23492349
    23502350        pParam->flags |= USE_REG_GEN16;
    … …  
    23532353
    23542354    case OP_PARM_d:
    2355         Assert(idx < (pCpu->prefix & PREFIX_REX) ? 16 : 8);
     2355        Assert(idx < (pCpu->prefix & DISPREFIX_REX) ? 16 : 8);
    23562356
    23572357        pParam->flags |= USE_REG_GEN32;
    … …  
    26182618void disValidateLockSequence(PDISCPUSTATE pCpu)
    26192619{
    2620     Assert(pCpu->prefix & PREFIX_LOCK);
     2620    Assert(pCpu->prefix & DISPREFIX_LOCK);
    26212621
    26222622    /*

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

    r41668 r41675  
    206206    switch (pCpu->addrmode)
    207207    {
    208         case CPUMODE_16BIT:
     208        case DISCPUMODE_16BIT:
    209209        {
    210210            Assert(pParam->index.reg_gen < RT_ELEMENTS(g_aszYasmRegGen16));
    … …  
    214214        }
    215215
    216         case CPUMODE_32BIT:
     216        case DISCPUMODE_32BIT:
    217217        {
    218218            Assert(pParam->index.reg_gen < RT_ELEMENTS(g_aszYasmRegGen32));
    … …  
    222222        }
    223223
    224         case CPUMODE_64BIT:
     224        case DISCPUMODE_64BIT:
    225225        {
    226226            Assert(pParam->index.reg_gen < RT_ELEMENTS(g_aszYasmRegGen64));
    … …  
    392392    if (    pOp->opcode == OP_INVALID
    393393        ||  (   pOp->opcode == OP_ILLUD2
    394              && (pCpu->prefix & PREFIX_LOCK)))
     394             && (pCpu->prefix & DISPREFIX_LOCK)))
    395395    {
    396396
    … …  
    401401         * Prefixes
    402402         */
    403         if (pCpu->prefix & PREFIX_LOCK)
     403        if (pCpu->prefix & DISPREFIX_LOCK)
    404404            PUT_SZ("lock ");
    405         if(pCpu->prefix & PREFIX_REP)
     405        if(pCpu->prefix & DISPREFIX_REP)
    406406            PUT_SZ("rep ");
    407         else if(pCpu->prefix & PREFIX_REPNE)
     407        else if(pCpu->prefix & DISPREFIX_REPNE)
    408408            PUT_SZ("repne ");
    409409
    … …  
    417417        {
    418418            case OP_JECXZ:
    419                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "jcxz %Jb" : pCpu->opmode == CPUMODE_32BIT ? "jecxz %Jb"   : "jrcxz %Jb";
     419                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "jcxz %Jb" : pCpu->opmode == DISCPUMODE_32BIT ? "jecxz %Jb"   : "jrcxz %Jb";
    420420                break;
    421421            case OP_PUSHF:
    422                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "pushfw"   : pCpu->opmode == CPUMODE_32BIT ? "pushfd"      : "pushfq";
     422                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "pushfw"   : pCpu->opmode == DISCPUMODE_32BIT ? "pushfd"      : "pushfq";
    423423                break;
    424424            case OP_POPF:
    425                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "popfw"    : pCpu->opmode == CPUMODE_32BIT ? "popfd"       : "popfq";
     425                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "popfw"    : pCpu->opmode == DISCPUMODE_32BIT ? "popfd"       : "popfq";
    426426                break;
    427427            case OP_PUSHA:
    428                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "pushaw"   : "pushad";
     428                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "pushaw"   : "pushad";
    429429                break;
    430430            case OP_POPA:
    431                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "popaw"    : "popad";
     431                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "popaw"    : "popad";
    432432                break;
    433433            case OP_INSB:
    … …  
    435435                break;
    436436            case OP_INSWD:
    437                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "insw"     : pCpu->opmode == CPUMODE_32BIT ? "insd"  : "insq";
     437                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "insw"     : pCpu->opmode == DISCPUMODE_32BIT ? "insd"  : "insq";
    438438                break;
    439439            case OP_OUTSB:
    … …  
    441441                break;
    442442            case OP_OUTSWD:
    443                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "outsw"    : pCpu->opmode == CPUMODE_32BIT ? "outsd" : "outsq";
     443                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "outsw"    : pCpu->opmode == DISCPUMODE_32BIT ? "outsd" : "outsq";
    444444                break;
    445445            case OP_MOVSB:
    … …  
    447447                break;
    448448            case OP_MOVSWD:
    449                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "movsw"    : pCpu->opmode == CPUMODE_32BIT ? "movsd" : "movsq";
     449                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "movsw"    : pCpu->opmode == DISCPUMODE_32BIT ? "movsd" : "movsq";
    450450                break;
    451451            case OP_CMPSB:
    … …  
    453453                break;
    454454            case OP_CMPWD:
    455                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "cmpsw"    : pCpu->opmode == CPUMODE_32BIT ? "cmpsd" : "cmpsq";
     455                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "cmpsw"    : pCpu->opmode == DISCPUMODE_32BIT ? "cmpsd" : "cmpsq";
    456456                break;
    457457            case OP_SCASB:
    … …  
    459459                break;
    460460            case OP_SCASWD:
    461                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "scasw"    : pCpu->opmode == CPUMODE_32BIT ? "scasd" : "scasq";
     461                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "scasw"    : pCpu->opmode == DISCPUMODE_32BIT ? "scasd" : "scasq";
    462462                break;
    463463            case OP_LODSB:
    … …  
    465465                break;
    466466            case OP_LODSWD:
    467                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "lodsw"    : pCpu->opmode == CPUMODE_32BIT ? "lodsd" : "lodsq";
     467                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "lodsw"    : pCpu->opmode == DISCPUMODE_32BIT ? "lodsd" : "lodsq";
    468468                break;
    469469            case OP_STOSB:
    … …  
    471471                break;
    472472            case OP_STOSWD:
    473                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "stosw"    : pCpu->opmode == CPUMODE_32BIT ? "stosd" : "stosq";
     473                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "stosw"    : pCpu->opmode == DISCPUMODE_32BIT ? "stosd" : "stosq";
    474474                break;
    475475            case OP_CBW:
    476                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "cbw"      : pCpu->opmode == CPUMODE_32BIT ? "cwde"  : "cdqe";
     476                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "cbw"      : pCpu->opmode == DISCPUMODE_32BIT ? "cwde"  : "cdqe";
    477477                break;
    478478            case OP_CWD:
    479                 pszFmt = pCpu->opmode == CPUMODE_16BIT ? "cwd"      : pCpu->opmode == CPUMODE_32BIT ? "cdq"   : "cqo";
     479                pszFmt = pCpu->opmode == DISCPUMODE_16BIT ? "cwd"      : pCpu->opmode == DISCPUMODE_32BIT ? "cdq"   : "cqo";
    480480                break;
    481481            case OP_SHL:
    … …  
    576576                        switch (pCpu->opmode) \
    577577                        { \
    578                             case CPUMODE_16BIT: PUT_SZ("word "); break; \
    579                             case CPUMODE_32BIT: PUT_SZ("dword "); break; \
    580                             case CPUMODE_64BIT: PUT_SZ("qword "); break; \
     578                            case DISCPUMODE_16BIT: PUT_SZ("word "); break; \
     579                            case DISCPUMODE_32BIT: PUT_SZ("dword "); break; \
     580                            case DISCPUMODE_64BIT: PUT_SZ("qword "); break; \
    581581                            default: break; \
    582582                        } \
    … …  
    604604#define PUT_SEGMENT_OVERRIDE() \
    605605        do { \
    606             if (pCpu->prefix & PREFIX_SEG) \
     606            if (pCpu->prefix & DISPREFIX_SEG) \
    607607                PUT_STR(s_szSegPrefix[pCpu->enmPrefixSeg], 3); \
    608608        } while (0)
    … …  
    612612         * Segment prefixing for instructions that doesn't do memory access.
    613613         */
    614         if (    (pCpu->prefix & PREFIX_SEG)
     614        if (    (pCpu->prefix & DISPREFIX_SEG)
    615615            &&  !DIS_IS_EFFECTIVE_ADDR(pCpu->param1.flags)
    616616            &&  !DIS_IS_EFFECTIVE_ADDR(pCpu->param2.flags)
    … …  
    812812
    813813                            case USE_IMMEDIATE32:
    814                                 if (    pCpu->opmode != (pCpu->mode == CPUMODE_16BIT ? CPUMODE_16BIT : CPUMODE_32BIT) /* not perfect */
     814                                if (    pCpu->opmode != (pCpu->mode == DISCPUMODE_16BIT ? DISCPUMODE_16BIT : DISCPUMODE_32BIT) /* not perfect */
    815815                                    ||  (   (fFlags & DIS_FMT_FLAGS_STRICT)
    816816                                         && (   (int8_t)pParam->parval == (int32_t)pParam->parval
    … …  
    897897
    898898                        RTUINTPTR uTrgAddr = pCpu->uInstrAddr + pCpu->opsize + offDisplacement;
    899                         if (pCpu->mode == CPUMODE_16BIT)
     899                        if (pCpu->mode == DISCPUMODE_16BIT)
    900900                            PUT_NUM_16(uTrgAddr);
    901                         else if (pCpu->mode == CPUMODE_32BIT)
     901                        else if (pCpu->mode == DISCPUMODE_32BIT)
    902902                            PUT_NUM_32(uTrgAddr);
    903903                        else
    … …  
    12021202     * Mod rm + SIB: Check for duplicate EBP encodings that yasm won't use for very good reasons.
    12031203     */
    1204     if (    pCpu->addrmode != CPUMODE_16BIT ///@todo correct?
     1204    if (    pCpu->addrmode != DISCPUMODE_16BIT ///@todo correct?
    12051205        &&  pCpu->ModRM.Bits.Rm == 4
    12061206        &&  pCpu->ModRM.Bits.Mod != 3)
    … …  
    12351235        {
    12361236            case 0xf0:
    1237                 f = PREFIX_LOCK;
     1237                f = DISPREFIX_LOCK;
    12381238                break;
    12391239
    12401240            case 0xf2:
    12411241            case 0xf3:
    1242                 f = PREFIX_REP; /* yes, both */
     1242                f = DISPREFIX_REP; /* yes, both */
    12431243                break;
    12441244
    … …  
    12491249            case 0x64:
    12501250            case 0x65:
    1251                 f = PREFIX_SEG;
     1251                f = DISPREFIX_SEG;
    12521252                break;
    12531253
    12541254            case 0x66:
    1255                 f = PREFIX_OPSIZE;
     1255                f = DISPREFIX_OPSIZE;
    12561256                break;
    12571257
    12581258            case 0x67:
    1259                 f = PREFIX_ADDRSIZE;
     1259                f = DISPREFIX_ADDRSIZE;
    12601260                break;
    12611261
    12621262            case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
    12631263            case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
    1264                 f = pCpu->mode == CPUMODE_64BIT ? PREFIX_REX : 0;
     1264                f = pCpu->mode == DISCPUMODE_64BIT ? DISPREFIX_REX : 0;
    12651265                break;
    12661266
    … …  
    12771277
    12781278    /* segment overrides are fun */
    1279     if (fPrefixes & PREFIX_SEG)
     1279    if (fPrefixes & DISPREFIX_SEG)
    12801280    {
    12811281        /* no effective address which it may apply to. */
    1282         Assert((pCpu->prefix & PREFIX_SEG) || pCpu->mode == CPUMODE_64BIT);
     1282        Assert((pCpu->prefix & DISPREFIX_SEG) || pCpu->mode == DISCPUMODE_64BIT);
    12831283        if (    !DIS_IS_EFFECTIVE_ADDR(pCpu->param1.flags)
    12841284            &&  !DIS_IS_EFFECTIVE_ADDR(pCpu->param2.flags)
    … …  
    12881288
    12891289    /* fixed register + addr override doesn't go down all that well. */
    1290     if (fPrefixes & PREFIX_ADDRSIZE)
    1291     {
    1292         Assert(pCpu->prefix & PREFIX_ADDRSIZE);
     1290    if (fPrefixes & DISPREFIX_ADDRSIZE)
     1291    {
     1292        Assert(pCpu->prefix & DISPREFIX_ADDRSIZE);
    12931293        if (    pCpu->pCurInstr->param3 == OP_PARM_NONE
    12941294            &&  pCpu->pCurInstr->param2 == OP_PARM_NONE
    … …  
    13351335
    13361336    /* All but the segment prefix is bad news. */
    1337     if (fPrefixes & ~PREFIX_SEG)
     1337    if (fPrefixes & ~DISPREFIX_SEG)
    13381338    {
    13391339        switch (pCpu->pCurInstr->opcode)
    … …  
    13441344                    &&  pCpu->pCurInstr->param1 <= OP_PARM_REG_SEG_END)
    13451345                    return true;
    1346                 if (    (fPrefixes & ~PREFIX_OPSIZE)
     1346                if (    (fPrefixes & ~DISPREFIX_OPSIZE)
    13471347                    &&  pCpu->pCurInstr->param1 >= OP_PARM_REG_GEN32_START
    13481348                    &&  pCpu->pCurInstr->param1 <= OP_PARM_REG_GEN32_END)
    … …  
    13541354            case OP_PUSHA:
    13551355            case OP_PUSHF:
    1356                 if (fPrefixes & ~PREFIX_OPSIZE)
     1356                if (fPrefixes & ~DISPREFIX_OPSIZE)
    13571357                    return true;
    13581358                break;
    … …  
    13611361
    13621362    /* Implicit 8-bit register instructions doesn't mix with operand size. */
    1363     if (    (fPrefixes & PREFIX_OPSIZE)
     1363    if (    (fPrefixes & DISPREFIX_OPSIZE)
    13641364        &&  (   (   pCpu->pCurInstr->param1 == OP_PARM_Gb /* r8 */
    13651365                 && pCpu->pCurInstr->param2 == OP_PARM_Eb /* r8/mem8 */)
    … …  
    15061506    if (    pCpu->pCurInstr->opcode == OP_MOVZX
    15071507        &&  pCpu->opcode == 0xB7
    1508         &&  (pCpu->mode == CPUMODE_16BIT) != !!(fPrefixes & PREFIX_OPSIZE))
     1508        &&  (pCpu->mode == DISCPUMODE_16BIT) != !!(fPrefixes & DISPREFIX_OPSIZE))
    15091509        return true;
    15101510

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

    r41668 r41675  
    210210        switch(pCpu->opmode)
    211211        {
    212         case CPUMODE_32BIT:
     212        case DISCPUMODE_32BIT:
    213213            subtype = OP_PARM_d;
    214214            break;
    215         case CPUMODE_64BIT:
     215        case DISCPUMODE_64BIT:
    216216            subtype = OP_PARM_q;
    217217            break;
    218         case CPUMODE_16BIT:
     218        case DISCPUMODE_16BIT:
    219219            subtype = OP_PARM_w;
    220220            break;
    … …  
    241241
    242242    case OP_PARM_p: /* far pointer */
    243         if (pCpu->addrmode == CPUMODE_32BIT)
     243        if (pCpu->addrmode == DISCPUMODE_32BIT)
    244244            return 6;   /* 16:32 */
    245245        else
    246         if (pCpu->addrmode == CPUMODE_64BIT)
     246        if (pCpu->addrmode == DISCPUMODE_64BIT)
    247247            return 12;  /* 16:64 */
    248248        else
    … …  
    260260DISDECL(DIS_SELREG) DISDetectSegReg(PDISCPUSTATE pCpu, POP_PARAMETER pParam)
    261261{
    262     if (pCpu->prefix & PREFIX_SEG)
     262    if (pCpu->prefix & DISPREFIX_SEG)
    263263    {
    264264        /* Use specified SEG: prefix. */
    … …  
    285285DISDECL(uint8_t) DISQuerySegPrefixByte(PDISCPUSTATE pCpu)
    286286{
    287     Assert(pCpu->prefix & PREFIX_SEG);
     287    Assert(pCpu->prefix & DISPREFIX_SEG);
    288288    switch(pCpu->enmPrefixSeg)
    289289    {
    … …  
    592592        if (pParam->flags & USE_DISPLACEMENT8)
    593593        {
    594             if (pCpu->mode == CPUMODE_32BIT)
     594            if (pCpu->mode == DISCPUMODE_32BIT)
    595595                pParamVal->val.val32 += (int32_t)pParam->uDisp.i8;
    596596            else
    597             if (pCpu->mode == CPUMODE_64BIT)
     597            if (pCpu->mode == DISCPUMODE_64BIT)
    598598                pParamVal->val.val64 += (int64_t)pParam->uDisp.i8;
    599599            else
    … …  
    603603        if (pParam->flags & USE_DISPLACEMENT16)
    604604        {
    605             if (pCpu->mode == CPUMODE_32BIT)
     605            if (pCpu->mode == DISCPUMODE_32BIT)
    606606                pParamVal->val.val32 += (int32_t)pParam->uDisp.i16;
    607607            else
    608             if (pCpu->mode == CPUMODE_64BIT)
     608            if (pCpu->mode == DISCPUMODE_64BIT)
    609609                pParamVal->val.val64 += (int64_t)pParam->uDisp.i16;
    610610            else
    … …  
    614614        if (pParam->flags & USE_DISPLACEMENT32)
    615615        {
    616             if (pCpu->mode == CPUMODE_32BIT)
     616            if (pCpu->mode == DISCPUMODE_32BIT)
    617617                pParamVal->val.val32 += pParam->uDisp.i32;
    618618            else
    … …  
    622622        if (pParam->flags & USE_DISPLACEMENT64)
    623623        {
    624             Assert(pCpu->mode == CPUMODE_64BIT);
     624            Assert(pCpu->mode == DISCPUMODE_64BIT);
    625625            pParamVal->val.val64 += pParam->uDisp.i64;
    626626        }
    … …  
    628628        if (pParam->flags & USE_RIPDISPLACEMENT32)
    629629        {
    630             Assert(pCpu->mode == CPUMODE_64BIT);
     630            Assert(pCpu->mode == DISCPUMODE_64BIT);
    631631            /* Relative to the RIP of the next instruction. */
    632632            pParamVal->val.val64 += pParam->uDisp.i32 + pCtx->rip + pCpu->opsize;

  • TabularUnified trunk/src/VBox/Disassembler/DisasmTest.cpp

    r41669 r41675  
    5050            char        szOutput[256];
    5151
    52             if (RT_SUCCESS(DISInstrToStr(pbInstr, CPUMODE_32BIT, &cpu, &cb, szOutput, sizeof(szOutput))))
     52            if (RT_SUCCESS(DISInstrToStr(pbInstr, DISCPUMODE_32BIT, &cpu, &cb, szOutput, sizeof(szOutput))))
    5353            {
    5454                printf("%s", szOutput);
    … …  
    7373            char        szOutput[256];
    7474
    75             if (RT_SUCCESS(DISInstrToStr(pbInstr, CPUMODE_64BIT, &cpu, &cb, szOutput, sizeof(szOutput))))
     75            if (RT_SUCCESS(DISInstrToStr(pbInstr, DISCPUMODE_64BIT, &cpu, &cb, szOutput, sizeof(szOutput))))
    7676                printf("%s", szOutput);
    7777            else

  • TabularUnified trunk/src/VBox/Disassembler/DisasmTestCore.cpp

    r41674 r41675  
    3939        unsigned    cb;
    4040        DISCPUSTATE cpu;
    41         if (DISInstr((void *)(uintptr_t)&DISInstr, CPUMODE_32BIT, &cpu, &cb))
     41        if (DISInstr((void *)(uintptr_t)&DISInstr, DISCPUMODE_32BIT, &cpu, &cb))
    4242            printf("ok %d\n", cpu.addrmode);
    4343        else

  • TabularUnified trunk/src/VBox/Disassembler/testcase/tstDisasm-2.cpp

    r41671 r41675  
    303303
    304304        case kAsmStyle_yasm:
    305             RTPrintf("    BITS %d\n", enmCpuMode == CPUMODE_16BIT ? 16 : enmCpuMode == CPUMODE_32BIT ? 32 : 64);
     305            RTPrintf("    BITS %d\n", enmCpuMode == DISCPUMODE_16BIT ? 16 : enmCpuMode == DISCPUMODE_32BIT ? 32 : 64);
    306306            pfnFormatter = MyDisasYasmFormatter;
    307307            break;
    … …  
    492492    UNDEFOPHANDLING enmUndefOp = kUndefOp_Fail;
    493493    bool fListing = true;
    494     DISCPUMODE enmCpuMode = CPUMODE_32BIT;
     494    DISCPUMODE enmCpuMode = DISCPUMODE_32BIT;
    495495    RTFOFF off = 0;
    496496    RTFOFF cbMax = _1G;
    … …  
    532532            case 'c':
    533533                if (ValueUnion.u32 == 16)
    534                     enmCpuMode = CPUMODE_16BIT;
     534                    enmCpuMode = DISCPUMODE_16BIT;
    535535                else if (ValueUnion.u32 == 32)
    536                     enmCpuMode = CPUMODE_32BIT;
     536                    enmCpuMode = DISCPUMODE_32BIT;
    537537                else if (ValueUnion.u32 == 64)
    538                     enmCpuMode = CPUMODE_64BIT;
     538                    enmCpuMode = DISCPUMODE_64BIT;
    539539                else
    540540                {

  • TabularUnified trunk/src/VBox/Runtime/testcase/tstLdr-2.cpp

    r41671 r41675  
    4747        char        szOutput[256];
    4848        uint32_t    cbInstr;
    49         if (RT_FAILURE(DISInstrToStr(pbCodeBlock + i, CPUMODE_32BIT, &Cpu, &cbInstr, szOutput, sizeof(szOutput))))
     49        if (RT_FAILURE(DISInstrToStr(pbCodeBlock + i, DISCPUMODE_32BIT, &Cpu, &cbInstr, szOutput, sizeof(szOutput))))
    5050            return false;
    5151

  • TabularUnified trunk/src/VBox/Runtime/testcase/tstLdr-3.cpp

    r41674 r41675  
    247247        memset(&Cpu, 0, sizeof(Cpu));
    248248#ifdef RT_ARCH_X86 /** @todo select according to the module type. */
    249         Cpu.mode = CPUMODE_32BIT;
     249        Cpu.mode = DISCPUMODE_32BIT;
    250250#else
    251         Cpu.mode = CPUMODE_64BIT;
     251        Cpu.mode = DISCPUMODE_64BIT;
    252252#endif
    253253        uint8_t *pbCode = (uint8_t *)g_pvBits + (NearSym.aSyms[0].Value - g_uLoadAddr);

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

    r41674 r41675  
    105105{
    106106    uint32_t cb;
    107     int rc = DISInstrWithReader(CodeIndex, CPUMODE_32BIT, DisasmTest1ReadCode, 0, pCpu, &cb);
     107    int rc = DISInstrWithReader(CodeIndex, DISCPUMODE_32BIT, DisasmTest1ReadCode, 0, pCpu, &cb);
    108108    *pcb = cb;
    109109    MY_PRINTF(("DISCoreOneEx -> rc=%d cb=%d  Cpu: opcode=%#x pCurInstr=%p (42=%d)\n", \
    … …  
    122122
    123123    memset(&Cpu, 0, sizeof(Cpu));
    124     Cpu.mode = CPUMODE_32BIT;
     124    Cpu.mode = DISCPUMODE_32BIT;
    125125
    126126#define DISAS_AND_CHECK(cbInstr, enmOp) \

  • TabularUnified trunk/src/VBox/Runtime/testcase/tstLdrObj.cpp

    r41674 r41675  
    9898    static unsigned cb;
    9999    DISCPUSTATE Cpu;
    100     DISInstr((void *)(uintptr_t)SomeExportFunction3, CPUMODE_32BIT, &Cpu, &cb);
     100    DISInstr((void *)(uintptr_t)SomeExportFunction3, DISCPUMODE_32BIT, &Cpu, &cb);
    101101    return (void *)(uintptr_t)&SomeExportFunction1;
    102102}

  • TabularUnified trunk/src/VBox/Runtime/testcase/tstLdrObjR0.cpp

    r41674 r41675  
    9696
    9797    memset(&Cpu, 0, sizeof(Cpu));
    98     Cpu.mode = CPUMODE_32BIT;
     98    Cpu.mode = DISCPUMODE_32BIT;
    9999
    100     DISInstr((void *)(uintptr_t)SomeExportFunction3, CPUMODE_32BIT, &Cpu, &cb);
     100    DISInstr((void *)(uintptr_t)SomeExportFunction3, DISCPUMODE_32BIT, &Cpu, &cb);
    101101    return (void *)(uintptr_t)&SomeExportFunction1;
    102102}

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

    r41674 r41675  
    789789        case OP_LMSW:       return "Lmsw";
    790790        case OP_SMSW:       return "Smsw";
    791         case OP_CMPXCHG:    return pDis->prefix & PREFIX_LOCK ? "Lock CmpXchg"   : "CmpXchg";
    792         case OP_CMPXCHG8B:  return pDis->prefix & PREFIX_LOCK ? "Lock CmpXchg8b" : "CmpXchg8b";
     791        case OP_CMPXCHG:    return pDis->prefix & DISPREFIX_LOCK ? "Lock CmpXchg"   : "CmpXchg";
     792        case OP_CMPXCHG8B:  return pDis->prefix & DISPREFIX_LOCK ? "Lock CmpXchg8b" : "CmpXchg8b";
    793793
    794794        default:
    … …  
    10091009static int emInterpretPop(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    10101010{
    1011     Assert(pDis->mode != CPUMODE_64BIT);    /** @todo check */
     1011    Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
    10121012    OP_PARAMVAL param1;
    10131013    NOREF(pvFault);
    … …  
    10281028
    10291029            /* Read stack value first */
    1030             if (SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->ss, &pRegFrame->ssHid) == CPUMODE_16BIT)
     1030            if (SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->ss, &pRegFrame->ssHid) == DISCPUMODE_16BIT)
    10311031                return VERR_EM_INTERPRETER; /* No legacy 16 bits stuff here, please. */
    10321032
    … …  
    15611561            }
    15621562#ifdef LOG_ENABLED
    1563             if (pDis->mode == CPUMODE_64BIT)
     1563            if (pDis->mode == DISCPUMODE_64BIT)
    15641564                LogFlow(("EMInterpretInstruction at %RGv: OP_MOV %RGv <- %RX64 (%d) &val64=%RHv\n", (RTGCPTR)pRegFrame->rip, pDest, val64, param2.size, &val64));
    15651565            else
    … …  
    16241624            }
    16251625#ifdef LOG_ENABLED
    1626             if (pDis->mode == CPUMODE_64BIT)
     1626            if (pDis->mode == DISCPUMODE_64BIT)
    16271627                LogFlow(("EMInterpretInstruction: OP_MOV %RGv -> %RX64 (%d)\n", pSrc, val64, param1.size));
    16281628            else
    … …  
    16521652
    16531653    /* Don't support any but these three prefix bytes. */
    1654     if ((pDis->prefix & ~(PREFIX_ADDRSIZE|PREFIX_OPSIZE|PREFIX_REP|PREFIX_REX)))
     1654    if ((pDis->prefix & ~(DISPREFIX_ADDRSIZE|DISPREFIX_OPSIZE|DISPREFIX_REP|DISPREFIX_REX)))
    16551655        return VERR_EM_INTERPRETER;
    16561656
    16571657    switch (pDis->addrmode)
    16581658    {
    1659     case CPUMODE_16BIT:
     1659    case DISCPUMODE_16BIT:
    16601660        GCOffset   = pRegFrame->di;
    16611661        cTransfers = pRegFrame->cx;
    16621662        break;
    1663     case CPUMODE_32BIT:
     1663    case DISCPUMODE_32BIT:
    16641664        GCOffset   = pRegFrame->edi;
    16651665        cTransfers = pRegFrame->ecx;
    16661666        break;
    1667     case CPUMODE_64BIT:
     1667    case DISCPUMODE_64BIT:
    16681668        GCOffset   = pRegFrame->rdi;
    16691669        cTransfers = pRegFrame->rcx;
    … …  
    16771677    switch (pDis->opmode)
    16781678    {
    1679     case CPUMODE_16BIT:
     1679    case DISCPUMODE_16BIT:
    16801680        cbSize = 2;
    16811681        break;
    1682     case CPUMODE_32BIT:
     1682    case DISCPUMODE_32BIT:
    16831683        cbSize = 4;
    16841684        break;
    1685     case CPUMODE_64BIT:
     1685    case DISCPUMODE_64BIT:
    16861686        cbSize = 8;
    16871687        break;
    … …  
    16931693    offIncrement = pRegFrame->eflags.Bits.u1DF ? -(signed)cbSize : (signed)cbSize;
    16941694
    1695     if (!(pDis->prefix & PREFIX_REP))
     1695    if (!(pDis->prefix & DISPREFIX_REP))
    16961696    {
    16971697        LogFlow(("emInterpretStosWD dest=%04X:%RGv (%RGv) cbSize=%d\n", pRegFrame->es, GCOffset, GCDest, cbSize));
    … …  
    17051705        switch (pDis->addrmode)
    17061706        {
    1707         case CPUMODE_16BIT:
     1707        case DISCPUMODE_16BIT:
    17081708            pRegFrame->di  += offIncrement;
    17091709            break;
    1710         case CPUMODE_32BIT:
     1710        case DISCPUMODE_32BIT:
    17111711            pRegFrame->edi += offIncrement;
    17121712            break;
    1713         case CPUMODE_64BIT:
     1713        case DISCPUMODE_64BIT:
    17141714            pRegFrame->rdi += offIncrement;
    17151715            break;
    … …  
    17701770        switch (pDis->addrmode)
    17711771        {
    1772         case CPUMODE_16BIT:
     1772        case DISCPUMODE_16BIT:
    17731773            pRegFrame->di = GCOffset;
    17741774            pRegFrame->cx = cTransfers;
    17751775            break;
    1776         case CPUMODE_32BIT:
     1776        case DISCPUMODE_32BIT:
    17771777            pRegFrame->edi = GCOffset;
    17781778            pRegFrame->ecx = cTransfers;
    17791779            break;
    1780         case CPUMODE_64BIT:
     1780        case DISCPUMODE_64BIT:
    17811781            pRegFrame->rdi = GCOffset;
    17821782            pRegFrame->rcx = cTransfers;
    … …  
    18481848    LogFlow(("%s %RGv rax=%RX64 %RX64\n", emGetMnemonic(pDis), GCPtrPar1, pRegFrame->rax, valpar));
    18491849
    1850     if (pDis->prefix & PREFIX_LOCK)
     1850    if (pDis->prefix & DISPREFIX_LOCK)
    18511851        eflags = EMEmulateLockCmpXchg(pvParam1, &pRegFrame->rax, valpar, pDis->param2.cb);
    18521852    else
    … …  
    18701870static int emInterpretCmpXchg8b(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    18711871{
    1872     Assert(pDis->mode != CPUMODE_64BIT);    /** @todo check */
     1872    Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
    18731873    OP_PARAMVAL param1;
    18741874    NOREF(pvFault);
    … …  
    19011901    LogFlow(("%s %RGv=%08x eax=%08x\n", emGetMnemonic(pDis), pvParam1, pRegFrame->eax));
    19021902
    1903     if (pDis->prefix & PREFIX_LOCK)
     1903    if (pDis->prefix & DISPREFIX_LOCK)
    19041904        eflags = EMEmulateLockCmpXchg8b(pvParam1, &pRegFrame->eax, &pRegFrame->edx, pRegFrame->ebx, pRegFrame->ecx);
    19051905    else
    … …  
    19241924static int emInterpretXAdd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    19251925{
    1926     Assert(pDis->mode != CPUMODE_64BIT);    /** @todo check */
     1926    Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
    19271927    OP_PARAMVAL param1;
    19281928    void *pvParamReg2;
    … …  
    19701970            LogFlow(("XAdd %RGv=%p reg=%08llx\n", GCPtrPar1, pvParam1, *(uint64_t *)pvParamReg2));
    19711971
    1972             if (pDis->prefix & PREFIX_LOCK)
     1972            if (pDis->prefix & DISPREFIX_LOCK)
    19731973                eflags = EMEmulateLockXAdd(pvParam1, pvParamReg2, cbParamReg2);
    19741974            else
    … …  
    26542654    AssertRCReturn(rc, VERR_EM_INTERPRETER);
    26552655
    2656     if (!(pDis->prefix & PREFIX_OPSIZE))
     2656    if (!(pDis->prefix & 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 & PREFIX_REX));
     3032    Assert(!(pDis->prefix & DISPREFIX_REX));
    30333033    NOREF(pDis); NOREF(pvFault); NOREF(pcbSize);
    30343034    return EMInterpretRdmsr(pVM, pVCpu, pRegFrame);
    … …  
    31043104
    31053105#ifdef IN_RC
    3106     if (    (pDis->prefix & (PREFIX_REPNE | PREFIX_REP))
    3107         ||  (   (pDis->prefix & PREFIX_LOCK)
     3106    if (    (pDis->prefix & (DISPREFIX_REPNE | DISPREFIX_REP))
     3107        ||  (   (pDis->prefix & DISPREFIX_LOCK)
    31083108             && pDis->pCurInstr->opcode != OP_CMPXCHG
    31093109             && pDis->pCurInstr->opcode != OP_CMPXCHG8B
    … …  
    31163116       )
    31173117#else
    3118     if (    (pDis->prefix & PREFIX_REPNE)
    3119         ||  (   (pDis->prefix & PREFIX_REP)
     3118    if (    (pDis->prefix & DISPREFIX_REPNE)
     3119        ||  (   (pDis->prefix & DISPREFIX_REP)
    31203120             && pDis->pCurInstr->opcode != OP_STOSWD
    31213121            )
    3122         ||  (   (pDis->prefix & PREFIX_LOCK)
     3122        ||  (   (pDis->prefix & 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 & PREFIX_LOCK) \
     3230            if (pDis->prefix & DISPREFIX_LOCK) \
    32313231                rc = emInterpretLock##InstrFn(pVM, pVCpu, pDis, pRegFrame, pvFault, pcbSize, pfnEmulateLock); \
    32323232            else \

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

    r41072 r41675  
    670670     * We do not support segment prefixes or REPNE.
    671671     */
    672     if (pCpu->prefix & (PREFIX_SEG | PREFIX_REPNE))
     672    if (pCpu->prefix & (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 & PREFIX_REP)
     681    if (pCpu->prefix & DISPREFIX_REP)
    682682    {
    683683#ifndef IN_RC
    … …  
    688688
    689689        cTransfers = pRegFrame->ecx;
    690         if (SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid) == CPUMODE_16BIT)
     690        if (SELMGetCpuModeFromSelector(pVM, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid) == DISCPUMODE_16BIT)
    691691            cTransfers &= 0xffff;
    692692
    … …  
    767767#endif
    768768            /* Update ecx. */
    769             if (pCpu->prefix & PREFIX_REP)
     769            if (pCpu->prefix & DISPREFIX_REP)
    770770                pRegFrame->ecx = cTransfers;
    771771        }
    … …  
    875875
    876876        /* Update ecx on exit. */
    877         if (pCpu->prefix & PREFIX_REP)
     877        if (pCpu->prefix & DISPREFIX_REP)
    878878            pRegFrame->ecx = cTransfers;
    879879    }
    … …  
    898898    switch (enmCpuMode)
    899899    {
    900         case CPUMODE_16BIT: return UINT16_MAX;
    901         case CPUMODE_32BIT: return UINT32_MAX;
    902         case CPUMODE_64BIT: return UINT64_MAX;
     900        case DISCPUMODE_16BIT: return UINT16_MAX;
     901        case DISCPUMODE_32BIT: return UINT32_MAX;
     902        case DISCPUMODE_64BIT: return UINT64_MAX;
    903903        default:
    904904            AssertFailedReturn(UINT32_MAX);
    … …  
    928928     * We do not support segment prefixes or REPNE..
    929929     */
    930     if (pCpu->prefix & (PREFIX_SEG | PREFIX_REPNE))
     930    if (pCpu->prefix & (DISPREFIX_SEG | DISPREFIX_REPNE))
    931931        return VINF_IOM_R3_MMIO_READ_WRITE; /** @todo -> REM instead of HC */
    932932
    … …  
    936936    uint64_t const fAddrMask = iomDisModeToMask(pCpu->addrmode);
    937937    RTGCUINTREG cTransfers = 1;
    938     if (pCpu->prefix & PREFIX_REP)
     938    if (pCpu->prefix & 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 & PREFIX_REP)
     985                if (pCpu->prefix & 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 & PREFIX_REP)
     1000                if (pCpu->prefix & DISPREFIX_REP)
    10011001                    pRegFrame->rcx &= ~fAddrMask;
    10021002            }
    … …  
    10251025
    10261026        /* Update rcx on exit. */
    1027         if (pCpu->prefix & PREFIX_REP)
     1027        if (pCpu->prefix & 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 & (PREFIX_SEG | PREFIX_REP | PREFIX_REPNE))
     1064    if (pCpu->prefix & (DISPREFIX_SEG | DISPREFIX_REP | DISPREFIX_REPNE))
    10651065        return VINF_IOM_R3_MMIO_READ_WRITE; /** @todo -> REM instead of HC */
    10661066
    … …  
    20302030     * pointer. Segment prefixes are deliberately ignored, as per the instruction specification.
    20312031     */
    2032     if (   (uPrefix & PREFIX_REPNE)
     2032    if (   (uPrefix & DISPREFIX_REPNE)
    20332033        || pRegFrame->eflags.Bits.u1DF)
    20342034        return VINF_EM_RAW_EMULATE_INSTR;
    … …  
    20412041    uint64_t const fAddrMask = iomDisModeToMask(enmAddrMode);
    20422042    RTGCUINTREG cTransfers = 1;
    2043     if (uPrefix & PREFIX_REP)
     2043    if (uPrefix & DISPREFIX_REP)
    20442044    {
    20452045#ifndef IN_RC
    … …  
    21082108
    21092109    /* Update rcx on exit. */
    2110     if (uPrefix & PREFIX_REP)
     2110    if (uPrefix & DISPREFIX_REP)
    21112111        pRegFrame->rcx = (cTransfers & fAddrMask)
    21122112                       | (pRegFrame->rcx & ~fAddrMask);
    … …  
    21472147        cb = 1;
    21482148    else
    2149         cb = (pCpu->opmode == CPUMODE_16BIT) ? 2 : 4;       /* dword in both 32 & 64 bits mode */
     2149        cb = (pCpu->opmode == DISCPUMODE_16BIT) ? 2 : 4;       /* dword in both 32 & 64 bits mode */
    21502150
    21512151    VBOXSTRICTRC rcStrict = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, Port, cb);
    … …  
    21922192     * decrementing source pointer.
    21932193     */
    2194     if (   (uPrefix & (PREFIX_SEG | PREFIX_REPNE))
     2194    if (   (uPrefix & (DISPREFIX_SEG | DISPREFIX_REPNE))
    21952195        || pRegFrame->eflags.Bits.u1DF)
    21962196        return VINF_EM_RAW_EMULATE_INSTR;
    … …  
    22032203    uint64_t const fAddrMask = iomDisModeToMask(enmAddrMode);
    22042204    RTGCUINTREG cTransfers = 1;
    2205     if (uPrefix & PREFIX_REP)
     2205    if (uPrefix & DISPREFIX_REP)
    22062206    {
    22072207#ifndef IN_RC
    … …  
    22752275
    22762276    /* Update rcx on exit. */
    2277     if (uPrefix & PREFIX_REP)
     2277    if (uPrefix & DISPREFIX_REP)
    22782278        pRegFrame->rcx = (cTransfers & fAddrMask)
    22792279                       | (pRegFrame->rcx & ~fAddrMask);
    … …  
    23162316        cb = 1;
    23172317    else
    2318         cb = (pCpu->opmode == CPUMODE_16BIT) ? 2 : 4;       /* dword in both 32 & 64 bits mode */
     2318        cb = (pCpu->opmode == DISCPUMODE_16BIT) ? 2 : 4;       /* dword in both 32 & 64 bits mode */
    23192319
    23202320    VBOXSTRICTRC rcStrict = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, Port, cb);

  • TabularUnified trunk/src/VBox/VMM/VMMAll/PGMAllBth.h

    r41458 r41675  
    918918                    if (    rc == VINF_SUCCESS
    919919                        &&  pDis->pCurInstr->opcode == OP_MOVSWD
    920                         &&  (pDis->prefix & PREFIX_REP))
     920                        &&  (pDis->prefix & DISPREFIX_REP))
    921921                    {
    922922                        CSAMMarkPossibleCodePage(pVM, pvFault);

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

    r41446 r41675  
    107107            rc = EMInterpretDisasOne(pVM, pVCpu, pRegFrame, pDis, &cbOp);
    108108            if (     RT_SUCCESS(rc)
    109                 &&   pDis->mode == CPUMODE_32BIT  /** @todo why does this matter? */
    110                 &&  !(pDis->prefix & (PREFIX_REPNE | PREFIX_REP | PREFIX_SEG)))
     109                &&   pDis->mode == DISCPUMODE_32BIT  /** @todo why does this matter? */
     110                &&  !(pDis->prefix & (DISPREFIX_REPNE | DISPREFIX_REP | DISPREFIX_SEG)))
    111111            {
    112112                switch (pDis->opcode)

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

    r41663 r41675  
    793793        case OP_MOVSWD:
    794794        case OP_STOSWD:
    795             if (    pDis->prefix == (PREFIX_REP|PREFIX_REX)
     795            if (    pDis->prefix == (DISPREFIX_REP|DISPREFIX_REX)
    796796                &&  pRegFrame->rcx >= 0x40
    797797               )
    798798            {
    799                 Assert(pDis->mode == CPUMODE_64BIT);
     799                Assert(pDis->mode == DISCPUMODE_64BIT);
    800800
    801801                Log(("pgmPoolMonitorIsReused: OP_STOSQ\n"));
    … …  
    890890    NOREF(pVM);
    891891
    892     Assert(pDis->mode == CPUMODE_32BIT || pDis->mode == CPUMODE_64BIT);
     892    Assert(pDis->mode == DISCPUMODE_32BIT || pDis->mode == DISCPUMODE_64BIT);
    893893    Assert(pRegFrame->rcx <= 0x20);
    894894
    895895#ifdef VBOX_STRICT
    896     if (pDis->opmode == CPUMODE_32BIT)
     896    if (pDis->opmode == DISCPUMODE_32BIT)
    897897        Assert(uIncrement == 4);
    898898    else
    … …  
    11551155         * Simple instructions, no REP prefix.
    11561156         */
    1157         if (!(pDis->prefix & (PREFIX_REP | PREFIX_REPNE)))
     1157        if (!(pDis->prefix & (DISPREFIX_REP | DISPREFIX_REPNE)))
    11581158        {
    11591159            rc = pgmPoolAccessHandlerSimple(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault, &fReused);
    … …  
    12031203            bool fValidStosd = false;
    12041204
    1205             if (    pDis->mode == CPUMODE_32BIT
    1206                 &&  pDis->prefix == PREFIX_REP
     1205            if (    pDis->mode == DISCPUMODE_32BIT
     1206                &&  pDis->prefix == DISPREFIX_REP
    12071207                &&  pRegFrame->ecx <= 0x20
    12081208                &&  pRegFrame->ecx * 4 <= PAGE_SIZE - ((uintptr_t)pvFault & PAGE_OFFSET_MASK)
    … …  
    12151215            }
    12161216            else
    1217             if (    pDis->mode == CPUMODE_64BIT
    1218                 &&  pDis->prefix == (PREFIX_REP | PREFIX_REX)
     1217            if (    pDis->mode == DISCPUMODE_64BIT
     1218                &&  pDis->prefix == (DISPREFIX_REP | DISPREFIX_REX)
    12191219                &&  pRegFrame->rcx <= 0x20
    12201220                &&  pRegFrame->rcx * 8 <= PAGE_SIZE - ((uintptr_t)pvFault & PAGE_OFFSET_MASK)

  • TabularUnified trunk/src/VBox/VMM/VMMAll/SELMAll.cpp

    r40449 r41675  
    911911        Desc = paLDT[Sel >> X86_SEL_SHIFT];
    912912    }
    913     return (Desc.Gen.u1DefBig) ? CPUMODE_32BIT : CPUMODE_16BIT;
     913    return (Desc.Gen.u1DefBig) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
    914914}
    915915#endif /* !IN_RING0 */
    … …  
    938938        if (    eflags.Bits.u1VM
    939939            ||  CPUMIsGuestInRealMode(pVCpu))
    940             return CPUMODE_16BIT;
     940            return DISCPUMODE_16BIT;
    941941
    942942        return selmGetCpuModeFromSelector(pVCpu->CTX_SUFF(pVM), pVCpu, Sel);
    … …  
    945945    if (    pHiddenSel->Attr.n.u1Long
    946946        &&  CPUMIsGuestInLongMode(pVCpu))
    947         return CPUMODE_64BIT;
     947        return DISCPUMODE_64BIT;
    948948
    949949    /* Else compatibility or 32 bits mode. */
    950     return pHiddenSel->Attr.n.u1DefBig ? CPUMODE_32BIT : CPUMODE_16BIT;
     950    return pHiddenSel->Attr.n.u1DefBig ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
    951951}
    952952

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

    r41645 r41675  
    29722972     */
    29732973    DISCPUMODE enmMode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
    2974     if (enmMode != CPUMODE_16BIT)
     2974    if (enmMode != DISCPUMODE_16BIT)
    29752975    {
    29762976        RTGCPTR pbCode;

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

    r41645 r41675  
    35853585                        X86EFLAGS eflags;
    35863586
    3587                         if (pDis->prefix & PREFIX_OPSIZE)
     3587                        if (pDis->prefix & DISPREFIX_OPSIZE)
    35883588                        {
    35893589                            cbParm = 4;
    … …  
    36273627                        X86EFLAGS eflags;
    36283628
    3629                         if (pDis->prefix & PREFIX_OPSIZE)
     3629                        if (pDis->prefix & DISPREFIX_OPSIZE)
    36303630                        {
    36313631                            cbParm = 4;
    … …  
    36693669                        uint16_t  aIretFrame[3];
    36703670
    3671                         if (pDis->prefix & (PREFIX_OPSIZE | PREFIX_ADDRSIZE))
     3671                        if (pDis->prefix & (DISPREFIX_OPSIZE | DISPREFIX_ADDRSIZE))
    36723672                        {
    36733673                            rc = VERR_EM_INTERPRETER;

  • TabularUnified trunk/src/VBox/VMM/VMMR3/CPUM.cpp

    r41674 r41675  
    36313631            State.cbSegLimit      = pCtx->csHid.u32Limit;
    36323632            enmDisCpuMode         = (State.f64Bits)
    3633                                     ? CPUMODE_64BIT
     3633                                    ? DISCPUMODE_64BIT
    36343634                                    : pCtx->csHid.Attr.n.u1DefBig
    3635                                     ? CPUMODE_32BIT
    3636                                     : CPUMODE_16BIT;
     3635                                    ? DISCPUMODE_32BIT
     3636                                    : DISCPUMODE_16BIT;
    36373637        }
    36383638        else
    … …  
    36593659            State.GCPtrSegEnd     = SelInfo.cbLimit + 1 + (RTGCUINTPTR)SelInfo.GCPtrBase;
    36603660            State.cbSegLimit      = SelInfo.cbLimit;
    3661             enmDisCpuMode         = SelInfo.u.Raw.Gen.u1DefBig ? CPUMODE_32BIT : CPUMODE_16BIT;
     3661            enmDisCpuMode         = SelInfo.u.Raw.Gen.u1DefBig ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
    36623662        }
    36633663    }
    … …  
    36653665    {
    36663666        /* real or V86 mode */
    3667         enmDisCpuMode         = CPUMODE_16BIT;
     3667        enmDisCpuMode         = DISCPUMODE_16BIT;
    36683668        State.GCPtrSegBase    = pCtx->cs * 16;
    36693669        State.GCPtrSegEnd     = 0xFFFFFFFF;

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

    r41674 r41675  
    870870                Assert(VALID_PTR(pCurInstrHC));
    871871
    872                 rc = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, (fCode32) ? CPUMODE_32BIT : CPUMODE_16BIT,
     872                rc = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, (fCode32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
    873873                                    &cpu, &opsize, NULL, 0);
    874874            }
    … …  
    10531053                STAM_PROFILE_START(&pVM->csam.s.StatTimeDisasm, a);
    10541054#ifdef DEBUG
    1055                 rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, (fCode32) ? CPUMODE_32BIT : CPUMODE_16BIT,
     1055                rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, (fCode32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
    10561056                                     &cpu, &opsize, szOutput, sizeof(szOutput));
    10571057                if (RT_SUCCESS(rc2)) Log(("CSAM Call Analysis: %s", szOutput));
    10581058#else
    1059                 rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, (fCode32) ? CPUMODE_32BIT : CPUMODE_16BIT,
     1059                rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, (fCode32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
    10601060                                     &cpu, &opsize, NULL, 0);
    10611061#endif
    … …  
    12661266            STAM_PROFILE_START(&pVM->csam.s.StatTimeDisasm, a);
    12671267#ifdef DEBUG
    1268             rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, fCode32 ? CPUMODE_32BIT : CPUMODE_16BIT,
     1268            rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, fCode32 ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
    12691269                                 &cpu, &opsize, szOutput, sizeof(szOutput));
    12701270            if (RT_SUCCESS(rc2)) Log(("CSAM Analysis: %s", szOutput));
    12711271#else
    1272             rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, fCode32 ? CPUMODE_32BIT : CPUMODE_16BIT,
     1272            rc2 = CSAMR3DISInstr(pVM, pCurInstrGC, pCurInstrHC, fCode32 ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
    12731273                                 &cpu, &opsize, NULL, 0);
    12741274#endif
    … …  
    22612261    {
    22622262        /* Assuming 32 bits code for now. */
    2263         Assert(SELMGetCpuModeFromSelector(VMMGetCpu0(pVM), pCtxCore->eflags, pCtxCore->cs, &pCtxCore->csHid) == CPUMODE_32BIT);
     2263        Assert(SELMGetCpuModeFromSelector(VMMGetCpu0(pVM), pCtxCore->eflags, pCtxCore->cs, &pCtxCore->csHid) == DISCPUMODE_32BIT);
    22642264
    22652265        pInstrGC = SELMToFlat(pVM, DIS_SELREG_CS, pCtxCore, pInstrGC);

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

    r41674 r41675  
    122122        case DBGF_DISAS_FLAGS_DEFAULT_MODE:
    123123            enmCpuMode   = pState->f64Bits
    124                          ? CPUMODE_64BIT
     124                         ? DISCPUMODE_64BIT
    125125                         : pSelInfo->u.Raw.Gen.u1DefBig
    126                          ? CPUMODE_32BIT
    127                          : CPUMODE_16BIT;
     126                         ? DISCPUMODE_32BIT
     127                         : DISCPUMODE_16BIT;
    128128            break;
    129129        case DBGF_DISAS_FLAGS_16BIT_MODE:
    130130        case DBGF_DISAS_FLAGS_16BIT_REAL_MODE:
    131             enmCpuMode = CPUMODE_16BIT;
     131            enmCpuMode = DISCPUMODE_16BIT;
    132132            break;
    133133        case DBGF_DISAS_FLAGS_32BIT_MODE:
    134             enmCpuMode = CPUMODE_32BIT;
     134            enmCpuMode = DISCPUMODE_32BIT;
    135135            break;
    136136        case DBGF_DISAS_FLAGS_64BIT_MODE:
    137             enmCpuMode = CPUMODE_64BIT;
     137            enmCpuMode = DISCPUMODE_64BIT;
    138138            break;
    139139    }

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

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

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

    r40451 r41675  
    428428        VBOXSTRICTRC rcStrict = VINF_EM_RAW_EMULATE_INSTR;
    429429
    430         if (!(Cpu.prefix & (PREFIX_REP | PREFIX_REPNE)))
     430        if (!(Cpu.prefix & (DISPREFIX_REP | DISPREFIX_REPNE)))
    431431        {
    432432            switch (Cpu.pCurInstr->opcode)
    … …  
    447447            }
    448448        }
    449         else if (Cpu.prefix & PREFIX_REP)
     449        else if (Cpu.prefix & DISPREFIX_REP)
    450450        {
    451451            switch (Cpu.pCurInstr->opcode)
    … …  
    684684            {
    685685                rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
    686                                         (SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0);
     686                                        (SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == DISCPUMODE_32BIT) ? PATMFL_CODE32 : 0);
    687687                if (RT_SUCCESS(rc))
    688688                {
    … …  
    934934        {
    935935            int rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
    936                                         (SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0);
     936                                        (SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == DISCPUMODE_32BIT) ? PATMFL_CODE32 : 0);
    937937            if (RT_SUCCESS(rc))
    938938            {
    … …  
    10411041        if (    (pCtx->ss & X86_SEL_RPL) == 0
    10421042            &&  !pCtx->eflags.Bits.u1VM
    1043             &&  SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT)
     1043            &&  SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == DISCPUMODE_32BIT)
    10441044        {
    10451045            STAM_PROFILE_START(&pVCpu->em.s.StatPrivEmu, a);

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

    r41674 r41675  
    604604    disinfo.fReadFlags  = fReadFlags;
    605605    return RT_SUCCESS(DISInstrToStrWithReader(InstrGCPtr32,
    606                                               (pPatch->flags & PATMFL_CODE32) ? CPUMODE_32BIT : CPUMODE_16BIT,
     606                                              (pPatch->flags & PATMFL_CODE32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
    607607                                              patmReadBytes, &disinfo,
    608608                                              pCpu, pcbInstr, pszOutput, cbOutput));
    … …  
    620620    disinfo.fReadFlags  = fReadFlags;
    621621    return RT_SUCCESS(DISInstrWithReader(InstrGCPtr32,
    622                                          (pPatch->flags & PATMFL_CODE32) ? CPUMODE_32BIT : CPUMODE_16BIT,
     622                                         (pPatch->flags & PATMFL_CODE32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT,
    623623                                         patmReadBytes, &disinfo,
    624624                                         pCpu, pcbInstr));
    … …  
    16541654         */
    16551655        Log(("patmRecompileCallback: jump to code we've recompiled before %RRv!\n", pCurInstrGC));
    1656         return patmPatchGenRelJump(pVM, pPatch, pCurInstrGC, OP_JMP, !!(pCpu->prefix & PREFIX_OPSIZE));
     1656        return patmPatchGenRelJump(pVM, pPatch, pCurInstrGC, OP_JMP, !!(pCpu->prefix & DISPREFIX_OPSIZE));
    16571657    }
    16581658
    … …  
    17131713        }
    17141714        else
    1715             rc = patmPatchGenRelJump(pVM, pPatch, pTargetGC, pCpu->pCurInstr->opcode, !!(pCpu->prefix & PREFIX_OPSIZE));
     1715            rc = patmPatchGenRelJump(pVM, pPatch, pTargetGC, pCpu->pCurInstr->opcode, !!(pCpu->prefix & DISPREFIX_OPSIZE));
    17161716
    17171717        if (RT_SUCCESS(rc))
    … …  
    18551855            fGenerateJmpBack = false;
    18561856
    1857         rc = patmPatchGenPopf(pVM, pPatch, pCurInstrGC + pCpu->opsize, !!(pCpu->prefix & PREFIX_OPSIZE), fGenerateJmpBack);
     1857        rc = patmPatchGenPopf(pVM, pPatch, pCurInstrGC + pCpu->opsize, !!(pCpu->prefix & DISPREFIX_OPSIZE), fGenerateJmpBack);
    18581858        if (RT_SUCCESS(rc))
    18591859        {
    … …  
    18731873
    18741874    case OP_PUSHF:
    1875         rc = patmPatchGenPushf(pVM, pPatch, !!(pCpu->prefix & PREFIX_OPSIZE));
     1875        rc = patmPatchGenPushf(pVM, pPatch, !!(pCpu->prefix & 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 & PREFIX_OPSIZE));
     1892        rc = patmPatchGenIret(pVM, pPatch, pCurInstrGC, !!(pCpu->prefix & DISPREFIX_OPSIZE));
    18931893        if (RT_SUCCESS(rc))
    18941894        {
    … …  
    32173217    pPatch->uCurPatchOffset   = 0;
    32183218
    3219     cpu.mode = (pPatch->flags & PATMFL_CODE32) ? CPUMODE_32BIT : CPUMODE_16BIT;
     3219    cpu.mode = (pPatch->flags & PATMFL_CODE32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
    32203220
    32213221    /* Note: Set the PATM interrupt flag here; it was cleared before the patched call. (!!!) */
    … …  
    42124212    pPatchRec->patch.pPrivInstrGC = pInstrGC;
    42134213    pPatchRec->patch.flags   = flags;
    4214     pPatchRec->patch.uOpMode = (flags & PATMFL_CODE32) ? CPUMODE_32BIT : CPUMODE_16BIT;
     4214    pPatchRec->patch.uOpMode = (flags & PATMFL_CODE32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
    42154215    pPatchRec->patch.pTrampolinePatchesHead = NULL;
    42164216
    … …  
    64576457        if (disret && (cpu.pCurInstr->opcode == OP_SYSEXIT || cpu.pCurInstr->opcode == OP_HLT || cpu.pCurInstr->opcode == OP_INT3))
    64586458        {
    6459             cpu.mode = (pPatch->patch.flags & PATMFL_CODE32) ? CPUMODE_32BIT : CPUMODE_16BIT;
     6459            cpu.mode = (pPatch->patch.flags & PATMFL_CODE32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
    64606460            disret = patmR3DisInstr(pVM, &pPatch->patch, pNewEip, PATMGCVirtToHCVirt(pVM, &cacheRec, pNewEip), PATMREAD_RAWCODE,
    64616461                                    &cpu, &opsize);

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

    r41663 r41675  
    701701        offset = 0;
    702702        /* include prefix byte to make sure we don't use the incorrect selector register. */
    703         if (pCpu->prefix & PREFIX_SEG)
     703        if (pCpu->prefix & DISPREFIX_SEG)
    704704            pPB[offset++] = DISQuerySegPrefixByte(pCpu);
    705705        pPB[offset++] = 0xFF;              // push r/m32
    706706        pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, 6 /* group 5 */, pCpu->ModRM.Bits.Rm);
    707707        i = 2;  /* standard offset of modrm bytes */
    708         if (pCpu->prefix & PREFIX_OPSIZE)
     708        if (pCpu->prefix & DISPREFIX_OPSIZE)
    709709            i++;    //skip operand prefix
    710         if (pCpu->prefix & PREFIX_SEG)
     710        if (pCpu->prefix & DISPREFIX_SEG)
    711711            i++;    //skip segment prefix
    712712
    … …  
    797797    offset = 0;
    798798    /* include prefix byte to make sure we don't use the incorrect selector register. */
    799     if (pCpu->prefix & PREFIX_SEG)
     799    if (pCpu->prefix & DISPREFIX_SEG)
    800800        pPB[offset++] = DISQuerySegPrefixByte(pCpu);
    801801
    … …  
    803803    pPB[offset++] = MAKE_MODRM(pCpu->ModRM.Bits.Mod, 6 /* group 5 */, pCpu->ModRM.Bits.Rm);
    804804    i = 2;  /* standard offset of modrm bytes */
    805     if (pCpu->prefix & PREFIX_OPSIZE)
     805    if (pCpu->prefix & DISPREFIX_OPSIZE)
    806806        i++;    //skip operand prefix
    807     if (pCpu->prefix & PREFIX_SEG)
     807    if (pCpu->prefix & DISPREFIX_SEG)
    808808        i++;    //skip segment prefix
    809809
    … …  
    12761276    PATCHGEN_PROLOG_NODEF(pVM, pPatch);
    12771277    offset = 0;
    1278     if (pCpu->prefix & PREFIX_OPSIZE)
     1278    if (pCpu->prefix & DISPREFIX_OPSIZE)
    12791279        pPB[offset++] = 0x66;       /* size override -> 16 bits push */
    12801280    pPB[offset++] = 0x16;
    … …  
    12891289    PATCHGEN_PROLOG_NODEF(pVM, pPatch);
    12901290    offset = 0;
    1291     if (pCpu->prefix & PREFIX_OPSIZE)
     1291    if (pCpu->prefix & DISPREFIX_OPSIZE)
    12921292        pPB[offset++] = 0x66; /* size override -> 16 bits pop */
    12931293    pPB[offset++] = 0x58 + pCpu->param1.base.reg_gen;
    … …  
    13201320
    13211321    /** @todo segment prefix (untested) */
    1322     Assert(pCpu->prefix == PREFIX_NONE || pCpu->prefix == PREFIX_OPSIZE);
     1322    Assert(pCpu->prefix == DISPREFIX_NONE || pCpu->prefix == DISPREFIX_OPSIZE);
    13231323
    13241324    PATCHGEN_PROLOG(pVM, pPatch);
    … …  
    13291329        // 8B 15 [32 bits addr]   mov edx, CPUMCTX.tr/ldtr
    13301330
    1331         if (pCpu->prefix == PREFIX_OPSIZE)
     1331        if (pCpu->prefix == DISPREFIX_OPSIZE)
    13321332            pPB[offset++] = 0x66;
    13331333
    … …  
    13601360        pPB[offset++] = 0x52;              // push      edx
    13611361
    1362         if (pCpu->prefix == PREFIX_SEG)
     1362        if (pCpu->prefix == DISPREFIX_SEG)
    13631363        {
    13641364            pPB[offset++] = DISQuerySegPrefixByte(pCpu);
    … …  
    13691369
    13701370        i = 3;  /* standard offset of modrm bytes */
    1371         if (pCpu->prefix == PREFIX_OPSIZE)
     1371        if (pCpu->prefix == DISPREFIX_OPSIZE)
    13721372            i++;    //skip operand prefix
    1373         if (pCpu->prefix == PREFIX_SEG)
     1373        if (pCpu->prefix == DISPREFIX_SEG)
    13741374            i++;    //skip segment prefix
    13751375
    … …  
    14201420
    14211421    /* @todo segment prefix (untested) */
    1422     Assert(pCpu->prefix == PREFIX_NONE);
     1422    Assert(pCpu->prefix == DISPREFIX_NONE);
    14231423
    14241424    // sgdt %Ms
    … …  
    14551455    pPB[offset++] = 0x52;              // push      edx
    14561456
    1457     if (pCpu->prefix == PREFIX_SEG)
     1457    if (pCpu->prefix == DISPREFIX_SEG)
    14581458    {
    14591459        pPB[offset++] = DISQuerySegPrefixByte(pCpu);
    … …  
    14641464
    14651465    i = 3;  /* standard offset of modrm bytes */
    1466     if (pCpu->prefix == PREFIX_OPSIZE)
     1466    if (pCpu->prefix == DISPREFIX_OPSIZE)
    14671467        i++;    //skip operand prefix
    1468     if (pCpu->prefix == PREFIX_SEG)
     1468    if (pCpu->prefix == DISPREFIX_SEG)
    14691469        i++;    //skip segment prefix
    14701470    rc = patmPatchReadBytes(pVM, &pPB[offset], (RTRCPTR)((RTGCUINTPTR32)pCurInstrGC + i), pCpu->opsize - i);

  • TabularUnified trunk/src/VBox/VMM/VMMR3/VMMSwitcher.cpp

    r41674 r41675  
    835835                DISCPUSTATE Cpu;
    836836                char        szDisas[256];
    837                 int rc = DISInstr(pu8CodeR3 + offCode, CPUMODE_32BIT, &Cpu, &cbInstr);
     837                int rc = DISInstr(pu8CodeR3 + offCode, DISCPUMODE_32BIT, &Cpu, &cbInstr);
    838838                if (RT_SUCCESS(rc))
    839839                {

  • TabularUnified trunk/src/VBox/VMM/VMMRC/PATMRC.cpp

    r41674 r41675  
    511511
    512512            cpu.mode = SELMGetCpuModeFromSelector(VMMGetCpu0(pVM), pRegFrame->eflags, pRegFrame->cs, 0);
    513             if (cpu.mode != CPUMODE_32BIT)
     513            if (cpu.mode != DISCPUMODE_32BIT)
    514514            {
    515515                AssertFailed();

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

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

  • TabularUnified trunk/src/VBox/VMM/include/EMHandleRCTmpl.h

    r41168 r41675  
    112112        case VINF_PATM_HC_MMIO_PATCH_READ:
    113113            rc = PATMR3InstallPatch(pVM, SELMToFlat(pVM, DIS_SELREG_CS, CPUMCTX2CORE(pCtx), pCtx->eip),
    114                                     PATMFL_MMIO_ACCESS | ((SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == CPUMODE_32BIT) ? PATMFL_CODE32 : 0));
     114                                    PATMFL_MMIO_ACCESS | ((SELMGetCpuModeFromSelector(pVCpu, pCtx->eflags, pCtx->cs, &pCtx->csHid) == DISCPUMODE_32BIT) ? PATMFL_CODE32 : 0));
    115115            if (RT_FAILURE(rc))
    116116                rc = emR3ExecuteInstruction(pVM, pVCpu, "MMIO");

  • TabularUnified trunk/src/VBox/VMM/testcase/tstCompiler.cpp

    r41669 r41675  
    207207        char        sz[256];
    208208        uint32_t    cbInstr = 0;
    209         if (RT_SUCCESS(DISInstrToStr(pbCur, CPUMODE_32BIT, &Cpu, &cbInstr, sz, sizeof(sz))))
     209        if (RT_SUCCESS(DISInstrToStr(pbCur, DISCPUMODE_32BIT, &Cpu, &cbInstr, sz, sizeof(sz))))
    210210        {
    211211            RTPrintf("tstBitFields: %s", sz);

  • TabularUnified trunk/src/recompiler/VBoxRecompiler.c

    r41669 r41675  
    40724072        DISCPUSTATE     Cpu;
    40734073#ifdef RT_ARCH_X86
    4074         DISCPUMODE      enmCpuMode = CPUMODE_32BIT;
     4074        DISCPUMODE      enmCpuMode = DISCPUMODE_32BIT;
    40754075#else
    4076         DISCPUMODE      enmCpuMode = CPUMODE_64BIT;
     4076        DISCPUMODE      enmCpuMode = DISCPUMODE_64BIT;
    40774077#endif
    40784078
Note: See TracChangeset for help on using the changeset viewer.

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