VirtualBox

Changeset 41736 in vbox for trunk/src


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

DISCPUMODE: s/mode/uCpuMode/ - found and removed a bunch of uncessary cpu mode setting before calilng the API.

Location:
trunk/src/VBox
Files:
12 edited

Legend:

Unmodified
Added
Removed

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

    r41735 r41736  
    291291    RT_BZERO(pCpu, RT_OFFSETOF(DISCPUSTATE, pvUser2));
    292292
    293     pCpu->mode              = enmCpuMode;
     293    pCpu->uCpuMode          = enmCpuMode;
    294294    if (enmCpuMode == DISCPUMODE_64BIT)
    295295    {
    … …  
    360360                pCpu->idxSegPrefix = (DISSELREG)(paOneByteMap[codebyte].param1 - OP_PARM_REG_SEG_START);
    361361                /* Segment prefixes for CS, DS, ES and SS are ignored in long mode. */
    362                 if (   pCpu->mode != DISCPUMODE_64BIT
     362                if (   pCpu->uCpuMode != DISCPUMODE_64BIT
    363363                    || pCpu->idxSegPrefix >= DISSELREG_FS)
    364364                {
    … …  
    377377            case OP_ADDRSIZE:
    378378                pCpu->fPrefix |= DISPREFIX_ADDRSIZE;
    379                 if (pCpu->mode == DISCPUMODE_16BIT)
     379                if (pCpu->uCpuMode == DISCPUMODE_16BIT)
    380380                    pCpu->uAddrMode = DISCPUMODE_32BIT;
    381381                else
    382                 if (pCpu->mode == DISCPUMODE_32BIT)
     382                if (pCpu->uCpuMode == DISCPUMODE_32BIT)
    383383                    pCpu->uAddrMode = DISCPUMODE_16BIT;
    384384                else
    … …  
    391391            case OP_OPSIZE:
    392392                pCpu->fPrefix |= DISPREFIX_OPSIZE;
    393                 if (pCpu->mode == DISCPUMODE_16BIT)
     393                if (pCpu->uCpuMode == DISCPUMODE_16BIT)
    394394                    pCpu->uOpMode = DISCPUMODE_32BIT;
    395395                else
    … …  
    411411
    412412            case OP_REX:
    413                 Assert(pCpu->mode == DISCPUMODE_64BIT);
     413                Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
    414414                /* REX prefix byte */
    415415                pCpu->fPrefix   |= DISPREFIX_REX;
    … …  
    476476
    477477    /* Correct the operand size if the instruction is marked as forced or default 64 bits */
    478     if (pCpu->mode == DISCPUMODE_64BIT)
     478    if (pCpu->uCpuMode == DISCPUMODE_64BIT)
    479479    {
    480480        if (pOp->optype & DISOPTYPE_FORCED_64_OP_SIZE)
    … …  
    489489    {
    490490        /* Forced 32 bits operand size for certain instructions (mov crx, mov drx). */
    491         Assert(pCpu->mode != DISCPUMODE_64BIT);
     491        Assert(pCpu->uCpuMode != DISCPUMODE_64BIT);
    492492        pCpu->uOpMode = DISCPUMODE_32BIT;
    493493    }
    … …  
    554554
    555555    /* Correct the operand size if the instruction is marked as forced or default 64 bits */
    556     if (pCpu->mode == DISCPUMODE_64BIT)
     556    if (pCpu->uCpuMode == DISCPUMODE_64BIT)
    557557    {
    558558        /* Note: redundant, but just in case this ever changes */
    … …  
    805805            {
    806806                /* 32 bits displacement */
    807                 if (pCpu->mode != DISCPUMODE_64BIT)
     807                if (pCpu->uCpuMode != DISCPUMODE_64BIT)
    808808                {
    809809                    pParam->fUse |= DISUSE_DISPLACEMENT32;
    … …  
    10821082    if (pCpu->fPrefix & DISPREFIX_REX)
    10831083    {
    1084         Assert(pCpu->mode == DISCPUMODE_64BIT);
     1084        Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
    10851085
    10861086        /* REX.R extends the Reg field. */
    … …  
    11281128    if (pCpu->fPrefix & DISPREFIX_REX)
    11291129    {
    1130         Assert(pCpu->mode == DISCPUMODE_64BIT);
     1130        Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
    11311131
    11321132        /* REX.R extends the Reg field. */
    … …  
    17611761                /* Cancel prefix changes. */
    17621762                pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
    1763                 pCpu->uOpMode  = pCpu->mode;
     1763                pCpu->uOpMode  = pCpu->uCpuMode;
    17641764            }
    17651765            break;
    … …  
    18281828                /* Cancel prefix changes. */
    18291829                pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
    1830                 pCpu->uOpMode  = pCpu->mode;
     1830                pCpu->uOpMode  = pCpu->uCpuMode;
    18311831            }
    18321832        }
    … …  
    18791879            /* Cancel prefix changes. */
    18801880            pCpu->fPrefix &= ~DISPREFIX_OPSIZE;
    1881             pCpu->uOpMode  = pCpu->mode;
     1881            pCpu->uOpMode  = pCpu->uCpuMode;
    18821882        }
    18831883    }

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

    r41735 r41736  
    800800
    801801                            case DISUSE_IMMEDIATE16:
    802                                 if (    pCpu->mode != pCpu->uOpMode
     802                                if (    pCpu->uCpuMode != pCpu->uOpMode
    803803                                    ||  (   (fFlags & DIS_FMT_FLAGS_STRICT)
    804804                                         && (   (int8_t)pParam->parval == (int16_t)pParam->parval
    … …  
    823823
    824824                            case DISUSE_IMMEDIATE32:
    825                                 if (    pCpu->uOpMode != (pCpu->mode == DISCPUMODE_16BIT ? DISCPUMODE_16BIT : DISCPUMODE_32BIT) /* not perfect */
     825                                if (    pCpu->uOpMode != (pCpu->uCpuMode == DISCPUMODE_16BIT ? DISCPUMODE_16BIT : DISCPUMODE_32BIT) /* not perfect */
    826826                                    ||  (   (fFlags & DIS_FMT_FLAGS_STRICT)
    827827                                         && (   (int8_t)pParam->parval == (int32_t)pParam->parval
    … …  
    908908
    909909                        RTUINTPTR uTrgAddr = pCpu->uInstrAddr + pCpu->cbInstr + offDisplacement;
    910                         if (pCpu->mode == DISCPUMODE_16BIT)
     910                        if (pCpu->uCpuMode == DISCPUMODE_16BIT)
    911911                            PUT_NUM_16(uTrgAddr);
    912                         else if (pCpu->mode == DISCPUMODE_32BIT)
     912                        else if (pCpu->uCpuMode == DISCPUMODE_32BIT)
    913913                            PUT_NUM_32(uTrgAddr);
    914914                        else
    … …  
    12731273            case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
    12741274            case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
    1275                 f = pCpu->mode == DISCPUMODE_64BIT ? DISPREFIX_REX : 0;
     1275                f = pCpu->uCpuMode == DISCPUMODE_64BIT ? DISPREFIX_REX : 0;
    12761276                break;
    12771277
    … …  
    12911291    {
    12921292        /* no effective address which it may apply to. */
    1293         Assert((pCpu->fPrefix & DISPREFIX_SEG) || pCpu->mode == DISCPUMODE_64BIT);
     1293        Assert((pCpu->fPrefix & DISPREFIX_SEG) || pCpu->uCpuMode == DISCPUMODE_64BIT);
    12941294        if (    !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param1.fUse)
    12951295            &&  !DISUSE_IS_EFFECTIVE_ADDR(pCpu->param2.fUse)
    … …  
    15171517    if (    pCpu->pCurInstr->opcode == OP_MOVZX
    15181518        &&  pCpu->bOpCode == 0xB7
    1519         &&  (pCpu->mode == DISCPUMODE_16BIT) != !!(fPrefixes & DISPREFIX_OPSIZE))
     1519        &&  (pCpu->uCpuMode == DISCPUMODE_16BIT) != !!(fPrefixes & DISPREFIX_OPSIZE))
    15201520        return true;
    15211521

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

    r41735 r41736  
    587587        if (pParam->fUse & DISUSE_DISPLACEMENT8)
    588588        {
    589             if (pCpu->mode == DISCPUMODE_32BIT)
     589            if (pCpu->uCpuMode == DISCPUMODE_32BIT)
    590590                pParamVal->val.val32 += (int32_t)pParam->uDisp.i8;
    591591            else
    592             if (pCpu->mode == DISCPUMODE_64BIT)
     592            if (pCpu->uCpuMode == DISCPUMODE_64BIT)
    593593                pParamVal->val.val64 += (int64_t)pParam->uDisp.i8;
    594594            else
    … …  
    598598        if (pParam->fUse & DISUSE_DISPLACEMENT16)
    599599        {
    600             if (pCpu->mode == DISCPUMODE_32BIT)
     600            if (pCpu->uCpuMode == DISCPUMODE_32BIT)
    601601                pParamVal->val.val32 += (int32_t)pParam->uDisp.i16;
    602602            else
    603             if (pCpu->mode == DISCPUMODE_64BIT)
     603            if (pCpu->uCpuMode == DISCPUMODE_64BIT)
    604604                pParamVal->val.val64 += (int64_t)pParam->uDisp.i16;
    605605            else
    … …  
    609609        if (pParam->fUse & DISUSE_DISPLACEMENT32)
    610610        {
    611             if (pCpu->mode == DISCPUMODE_32BIT)
     611            if (pCpu->uCpuMode == DISCPUMODE_32BIT)
    612612                pParamVal->val.val32 += pParam->uDisp.i32;
    613613            else
    … …  
    617617        if (pParam->fUse & DISUSE_DISPLACEMENT64)
    618618        {
    619             Assert(pCpu->mode == DISCPUMODE_64BIT);
     619            Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
    620620            pParamVal->val.val64 += pParam->uDisp.i64;
    621621        }
    … …  
    623623        if (pParam->fUse & DISUSE_RIPDISPLACEMENT32)
    624624        {
    625             Assert(pCpu->mode == DISCPUMODE_64BIT);
     625            Assert(pCpu->uCpuMode == DISCPUMODE_64BIT);
    626626            /* Relative to the RIP of the next instruction. */
    627627            pParamVal->val.val64 += pParam->uDisp.i32 + pCtx->rip + pCpu->cbInstr;

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

    r41731 r41736  
    154154
    155155
    156 static bool MyDisBlock(PDISCPUSTATE pCpu, RTHCUINTPTR pvCodeBlock, int32_t cbMax, RTUINTPTR off,
     156static bool MyDisBlock(DISCPUMODE enmCpuMode, RTHCUINTPTR pvCodeBlock, int32_t cbMax, RTUINTPTR off,
    157157                       RTUINTPTR uNearAddr, RTUINTPTR uSearchAddr)
    158158{
    159     int32_t i = 0;
     159    DISCPUSTATE Cpu;
     160    int32_t     i = 0;
    160161    while (i < cbMax)
    161162    {
    … …  
    164165        char        szOutput[256];
    165166        unsigned    cbInstr;
    166         int rc = DISInstrWithReader(uNearAddr + i, (DISCPUMODE)pCpu->mode,
     167        int rc = DISInstrWithReader(uNearAddr + i, enmCpuMode,
    167168                                    MyReadBytes, (uint8_t *)pvCodeBlock - (uintptr_t)uNearAddr,
    168                                     pCpu, &cbInstr);
     169                                    &Cpu, &cbInstr);
    169170        RTAssertSetMayPanic(fMayPanic);
    170171        RTAssertSetQuiet(fQuiet);
    … …  
    172173            return false;
    173174
    174         DISFormatYasmEx(pCpu, szOutput, sizeof(szOutput),
     175        DISFormatYasmEx(&Cpu, szOutput, sizeof(szOutput),
    175176                        DIS_FMT_FLAGS_RELATIVE_BRANCH | DIS_FMT_FLAGS_BYTES_RIGHT | DIS_FMT_FLAGS_ADDR_LEFT  | DIS_FMT_FLAGS_BYTES_SPACED,
    176177                        MyGetSymbol, NULL);
    … …  
    244245    if (NearSym.Addr - NearSym.aSyms[0].Value < 0x10000)
    245246    {
    246         DISCPUSTATE Cpu;
    247         memset(&Cpu, 0, sizeof(Cpu));
    248247#ifdef RT_ARCH_X86 /** @todo select according to the module type. */
    249         Cpu.mode = DISCPUMODE_32BIT;
     248        DISCPUMODE enmDisCpuMode = DISCPUMODE_32BIT;
    250249#else
    251         Cpu.mode = DISCPUMODE_64BIT;
     250        DISCPUMODE enmDisCpuMode = DISCPUMODE_64BIT;
    252251#endif
    253252        uint8_t *pbCode = (uint8_t *)g_pvBits + (NearSym.aSyms[0].Value - g_uLoadAddr);
    254         MyDisBlock(&Cpu, (uintptr_t)pbCode,
     253        MyDisBlock(enmDisCpuMode, (uintptr_t)pbCode,
    255254                   RT_MAX(NearSym.aSyms[1].Value - NearSym.aSyms[0].Value, 0x20000),
    256255                   NearSym.aSyms[0].Value - (RTUINTPTR)pbCode,

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

    r41734 r41736  
    122122
    123123    memset(&Cpu, 0, sizeof(Cpu));
    124     Cpu.mode = DISCPUMODE_32BIT;
    125124
    126125#define DISAS_AND_CHECK(cbInstr, enmOp) \

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

    r41675 r41736  
    9696
    9797    memset(&Cpu, 0, sizeof(Cpu));
    98     Cpu.mode = DISCPUMODE_32BIT;
    9998
    10099    DISInstr((void *)(uintptr_t)SomeExportFunction3, DISCPUMODE_32BIT, &Cpu, &cb);

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

    r41735 r41736  
    364364        State.GCPtr = NIL_RTGCPTR;
    365365    }
    366     return DISInstrWithReader(InstrGC, (DISCPUMODE)pDis->mode, emReadBytes, &State, pDis, pOpsize);
     366    return DISInstrWithReader(InstrGC, (DISCPUMODE)pDis->uCpuMode, emReadBytes, &State, pDis, pOpsize);
    367367}
    368368
    … …  
    377377    State.GCPtr = InstrGC;
    378378
    379     return DISInstrWithReader(InstrGC, (DISCPUMODE)pDis->mode, emReadBytes, &State, pDis, pOpsize);
     379    return DISInstrWithReader(InstrGC, (DISCPUMODE)pDis->uCpuMode, emReadBytes, &State, pDis, pOpsize);
    380380}
    381381
    … …  
    503503        uint32_t     cbOp;
    504504        PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
    505         pDis->mode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
     505        pDis->uCpuMode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
    506506        rc = emDisCoreOne(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
    507507        if (RT_SUCCESS(rc))
    … …  
    557557        uint32_t     cbOp;
    558558        PDISCPUSTATE pDis = &pVCpu->em.s.DisState;
    559         pDis->mode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
     559        pDis->uCpuMode = SELMGetCpuModeFromSelector(pVCpu, pRegFrame->eflags, pRegFrame->cs, &pRegFrame->csHid);
    560560        rc = emDisCoreOne(pVCpu->CTX_SUFF(pVM), pVCpu, pDis, (RTGCUINTPTR)pbCode, &cbOp);
    561561        if (RT_SUCCESS(rc))
    … …  
    10091009static int emInterpretPop(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    10101010{
    1011     Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
     1011    Assert(pDis->uCpuMode != DISCPUMODE_64BIT);    /** @todo check */
    10121012    DISQPVPARAMVAL param1;
    10131013    NOREF(pvFault);
    … …  
    15611561            }
    15621562#ifdef LOG_ENABLED
    1563             if (pDis->mode == DISCPUMODE_64BIT)
     1563            if (pDis->uCpuMode == 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 == DISCPUMODE_64BIT)
     1626            if (pDis->uCpuMode == DISCPUMODE_64BIT)
    16271627                LogFlow(("EMInterpretInstruction: OP_MOV %RGv -> %RX64 (%d)\n", pSrc, val64, param1.size));
    16281628            else
    … …  
    18701870static int emInterpretCmpXchg8b(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    18711871{
    1872     Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
     1872    Assert(pDis->uCpuMode != DISCPUMODE_64BIT);    /** @todo check */
    18731873    DISQPVPARAMVAL param1;
    18741874    NOREF(pvFault);
    … …  
    19241924static int emInterpretXAdd(PVM pVM, PVMCPU pVCpu, PDISCPUSTATE pDis, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, uint32_t *pcbSize)
    19251925{
    1926     Assert(pDis->mode != DISCPUMODE_64BIT);    /** @todo check */
     1926    Assert(pDis->uCpuMode != DISCPUMODE_64BIT);    /** @todo check */
    19271927    DISQPVPARAMVAL param1;
    19281928    void *pvParamReg2;

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

    r41734 r41736  
    107107            rc = EMInterpretDisasOne(pVM, pVCpu, pRegFrame, pDis, &cbOp);
    108108            if (     RT_SUCCESS(rc)
    109                 &&   pDis->mode == DISCPUMODE_32BIT  /** @todo why does this matter? */
     109                &&   pDis->uCpuMode == DISCPUMODE_32BIT  /** @todo why does this matter? */
    110110                &&  !(pDis->fPrefix & (DISPREFIX_REPNE | DISPREFIX_REP | DISPREFIX_SEG)))
    111111            {

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

    r41735 r41736  
    797797               )
    798798            {
    799                 Assert(pDis->mode == DISCPUMODE_64BIT);
     799                Assert(pDis->uCpuMode == DISCPUMODE_64BIT);
    800800
    801801                Log(("pgmPoolMonitorIsReused: OP_STOSQ\n"));
    … …  
    890890    NOREF(pVM);
    891891
    892     Assert(pDis->mode == DISCPUMODE_32BIT || pDis->mode == DISCPUMODE_64BIT);
     892    Assert(pDis->uCpuMode == DISCPUMODE_32BIT || pDis->uCpuMode == DISCPUMODE_64BIT);
    893893    Assert(pRegFrame->rcx <= 0x20);
    894894
    … …  
    11981198        if (    pDis->pCurInstr->opcode == OP_STOSWD
    11991199            &&  !pRegFrame->eflags.Bits.u1DF
    1200             &&  pDis->uOpMode == pDis->mode
    1201             &&  pDis->uAddrMode == pDis->mode)
     1200            &&  pDis->uOpMode == pDis->uCpuMode
     1201            &&  pDis->uAddrMode == pDis->uCpuMode)
    12021202        {
    12031203            bool fValidStosd = false;
    12041204
    1205             if (    pDis->mode == DISCPUMODE_32BIT
     1205            if (    pDis->uCpuMode == DISCPUMODE_32BIT
    12061206                &&  pDis->fPrefix == DISPREFIX_REP
    12071207                &&  pRegFrame->ecx <= 0x20
    … …  
    12151215            }
    12161216            else
    1217             if (    pDis->mode == DISCPUMODE_64BIT
     1217            if (    pDis->uCpuMode == DISCPUMODE_64BIT
    12181218                &&  pDis->fPrefix == (DISPREFIX_REP | DISPREFIX_REX)
    12191219                &&  pRegFrame->rcx <= 0x20

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

    r41735 r41736  
    29822982            PDISCPUSTATE pDis = &pVCpu->hwaccm.s.DisState;
    29832983
    2984             pDis->mode = enmMode;
     2984            pDis->uCpuMode = enmMode;
    29852985            rc = EMInterpretDisasOneEx(pVM, pVCpu, pbCode, pRegFrame, pDis, &cbOp);
    29862986            Assert(RT_FAILURE(rc) || pDis->pCurInstr->opcode == OP_INVLPG);

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

    r41734 r41736  
    31893189    PPATCHINFO pPatch = &pPatchRec->patch;
    31903190    int rc = VERR_PATCHING_REFUSED;
    3191     DISCPUSTATE cpu;
    31923191    uint32_t orgOffsetPatchMem = ~0;
    31933192    bool fInserted;
    … …  
    32153214    pPatch->pPatchBlockOffset = pVM->patm.s.offPatchMem;
    32163215    pPatch->uCurPatchOffset   = 0;
    3217 
    3218     cpu.mode = (pPatch->flags & PATMFL_CODE32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
    32193216
    32203217    /* Note: Set the PATM interrupt flag here; it was cleared before the patched call. (!!!) */
    … …  
    64536450        if (disret && (cpu.pCurInstr->opcode == OP_SYSEXIT || cpu.pCurInstr->opcode == OP_HLT || cpu.pCurInstr->opcode == OP_INT3))
    64546451        {
    6455             cpu.mode = (pPatch->patch.flags & PATMFL_CODE32) ? DISCPUMODE_32BIT : DISCPUMODE_16BIT;
    64566452            disret = patmR3DisInstr(pVM, &pPatch->patch, pNewEip, PATMGCVirtToHCVirt(pVM, &cacheRec, pNewEip), PATMREAD_RAWCODE,
    64576453                                    &cpu, &cbInstr);

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

    r41692 r41736  
    510510            }
    511511
    512             cpu.mode = SELMGetCpuModeFromSelector(VMMGetCpu0(pVM), pRegFrame->eflags, pRegFrame->cs, 0);
    513             if (cpu.mode != DISCPUMODE_32BIT)
     512            DISCPUMODE enmCpuMode = SELMGetCpuModeFromSelector(VMMGetCpu0(pVM), pRegFrame->eflags, pRegFrame->cs, 0);
     513            if (enmCpuMode != DISCPUMODE_32BIT)
    514514            {
    515515                AssertFailed();
    … …  
    523523            rc = VBOXSTRICTRC_TODO(rcStrict);
    524524#else
    525             rc = DISInstr(&pRec->patch.aPrivInstr[0], (DISCPUMODE)cpu.mode, &cpu, &cbOp);
     525            rc = DISInstr(&pRec->patch.aPrivInstr[0], enmCpuMode, &cpu, &cbOp);
    526526            if (RT_FAILURE(rc))
    527527            {
Note: See TracChangeset for help on using the changeset viewer.

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