VirtualBox

Changeset 41675 in vbox for trunk/src/VBox/VMM


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/src/VBox/VMM
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • 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 \

  • 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);

  • 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);

  • 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)

  • 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)

  • 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

  • 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;

  • 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;

  • 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;

  • 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);

  • 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    }

  • 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)

  • 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);

  • 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);

  • 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);

  • 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                {

  • 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();

  • 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));

  • 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");

  • 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);
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