VirtualBox

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


Ignore:
Timestamp:
Jun 13, 2012 9:37:47 AM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
78485
Message:

OP_PARAMETER::flags -> fUse.

Location:
trunk/src/VBox/VMM
Files:
12 edited

Legend:

Unmodified
Added
Removed

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    r41676 r41678  
    761761{
    762762    uint32_t disp;
    763     if (pCpu->param1.flags & DISUSE_IMMEDIATE8_REL)
     763    if (pCpu->param1.fUse & DISUSE_IMMEDIATE8_REL)
    764764    {
    765765        disp = (int32_t)(char)pCpu->param1.parval;
    766766    }
    767767    else
    768     if (pCpu->param1.flags & DISUSE_IMMEDIATE16_REL)
     768    if (pCpu->param1.fUse & DISUSE_IMMEDIATE16_REL)
    769769    {
    770770        disp = (int32_t)(uint16_t)pCpu->param1.parval;
    771771    }
    772772    else
    773     if (pCpu->param1.flags & DISUSE_IMMEDIATE32_REL)
     773    if (pCpu->param1.fUse & DISUSE_IMMEDIATE32_REL)
    774774    {
    775775        disp = (int32_t)pCpu->param1.parval;
    … …  
    777777    else
    778778    {
    779         Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.flags));
     779        Log(("We don't support far jumps here!! (%08X)\n", pCpu->param1.fUse));
    780780        return 0;
    781781    }
Note: See TracChangeset for help on using the changeset viewer.

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