VirtualBox

Changeset 41733 in vbox


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

DISCPUSTATE: s/prefix_rex/fRexPrefix/ s/lastprefix/bLastPrefix/ s/opcode/bOpcode/

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/dis.h

    r41732 r41733  
    4848} DISCPUMODE;
    4949
    50 /** @name Prefix byte flags (DISCPUSTATE::prefix_rex).
     50/** @name Prefix byte flags (DISCPUSTATE::fRexPrefix).
    5151 * @{
    5252 */
    … …  
    6868/** @} */
    6969
    70 /** @name 64 bits prefix byte flags (DISCPUSTATE::prefix_rex).
     70/** @name 64 bits prefix byte flags (DISCPUSTATE::fRexPrefix).
    7171 * Requires VBox/disopcode.h.
    7272 * @{
    … …  
    537537    /* off: 0x070 (112) */
    538538    /** REX prefix value (64 bits only). */
    539     uint8_t         prefix_rex;
     539    uint8_t         fRexPrefix;
    540540    /** Segment prefix value (DISSELREG). */
    541541    uint8_t         idxSegPrefix;
    542542    /** Last prefix byte (for SSE2 extension tables). */
    543     uint8_t         lastprefix;
     543    uint8_t         bLastPrefix;
    544544    /** First opcode byte of instruction. */
    545     uint8_t         opcode;
     545    uint8_t         bOpCode;
    546546    /* off: 0x074 (116) */
    547547    /** The size of the prefix bytes. */

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

    r41732 r41733  
    345345            {
    346346                /** Last prefix byte (for SSE2 extension tables); don't include the REX prefix */
    347                 pCpu->lastprefix = opcode;
     347                pCpu->bLastPrefix = opcode;
    348348                pCpu->prefix &= ~DISPREFIX_REX;
    349349            }
    … …  
    414414                /* REX prefix byte */
    415415                pCpu->prefix    |= DISPREFIX_REX;
    416                 pCpu->prefix_rex = DISPREFIX_REX_OP_2_FLAGS(paOneByteMap[codebyte].param1);
     416                pCpu->fRexPrefix = DISPREFIX_REX_OP_2_FLAGS(paOneByteMap[codebyte].param1);
    417417                iByte           += sizeof(uint8_t);
    418418
    419                 if (pCpu->prefix_rex & DISPREFIX_REX_FLAGS_W)
     419                if (pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_W)
    420420                    pCpu->opmode = DISCPUMODE_64BIT;  /* overrides size prefix byte */
    421421                continue;   //fetch the next byte
    … …  
    426426        iByte += sizeof(uint8_t); //first opcode byte
    427427
    428         pCpu->opcode = codebyte;
    429 
    430         cbInc = disParseInstruction(uInstrAddr + iByte, &paOneByteMap[pCpu->opcode], pCpu);
     428        pCpu->bOpCode = codebyte;
     429
     430        cbInc = disParseInstruction(uInstrAddr + iByte, &paOneByteMap[pCpu->bOpCode], pCpu);
    431431        iByte += cbInc;
    432432        break;
    … …  
    527527    ModRM = disReadByte(pCpu, uCodePtr);
    528528
    529     index = pCpu->opcode - 0xD8;
     529    index = pCpu->bOpCode - 0xD8;
    530530    if (ModRM <= 0xBF)
    531531    {
    … …  
    666666        /* REX.B extends the Base field if not scaled index + disp32 */
    667667        if (!(pCpu->SIB.Bits.Base == 5 && pCpu->ModRM.Bits.Mod == 0))
    668             pCpu->SIB.Bits.Base  |= ((!!(pCpu->prefix_rex & DISPREFIX_REX_FLAGS_B)) << 3);
    669 
    670         pCpu->SIB.Bits.Index |= ((!!(pCpu->prefix_rex & DISPREFIX_REX_FLAGS_X)) << 3);
     668            pCpu->SIB.Bits.Base  |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
     669
     670        pCpu->SIB.Bits.Index |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_X)) << 3);
    671671    }
    672672
    … …  
    698698    {
    699699        /* REX.B extends the Base field. */
    700         pCpu->SIB.Bits.Base  |= ((!!(pCpu->prefix_rex & DISPREFIX_REX_FLAGS_B)) << 3);
     700        pCpu->SIB.Bits.Base  |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
    701701        /* REX.X extends the Index field. */
    702         pCpu->SIB.Bits.Index |= ((!!(pCpu->prefix_rex & DISPREFIX_REX_FLAGS_X)) << 3);
     702        pCpu->SIB.Bits.Index |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_X)) << 3);
    703703    }
    704704
    … …  
    10851085
    10861086        /* REX.R extends the Reg field. */
    1087         pCpu->ModRM.Bits.Reg |= ((!!(pCpu->prefix_rex & DISPREFIX_REX_FLAGS_R)) << 3);
     1087        pCpu->ModRM.Bits.Reg |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_R)) << 3);
    10881088
    10891089        /* REX.B extends the Rm field if there is no SIB byte nor a 32 bits displacement */
    … …  
    10941094              &&  pCpu->ModRM.Bits.Rm  == 5))
    10951095        {
    1096             pCpu->ModRM.Bits.Rm |= ((!!(pCpu->prefix_rex & DISPREFIX_REX_FLAGS_B)) << 3);
     1096            pCpu->ModRM.Bits.Rm |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
    10971097        }
    10981098    }
    … …  
    11311131
    11321132        /* REX.R extends the Reg field. */
    1133         pCpu->ModRM.Bits.Reg |= ((!!(pCpu->prefix_rex & DISPREFIX_REX_FLAGS_R)) << 3);
     1133        pCpu->ModRM.Bits.Reg |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_R)) << 3);
    11341134
    11351135        /* REX.B extends the Rm field if there is no SIB byte nor a 32 bits displacement */
    … …  
    11401140              &&  pCpu->ModRM.Bits.Rm  == 5))
    11411141        {
    1142             pCpu->ModRM.Bits.Rm |= ((!!(pCpu->prefix_rex & DISPREFIX_REX_FLAGS_B)) << 3);
     1142            pCpu->ModRM.Bits.Rm |= ((!!(pCpu->fRexPrefix & DISPREFIX_REX_FLAGS_B)) << 3);
    11431143        }
    11441144    }
    … …  
    15711571                &&  pParam == &pCpu->param1             /* ugly assumption that it only applies to the first parameter */
    15721572                &&  (pCpu->prefix & DISPREFIX_REX)
    1573                 &&  (pCpu->prefix_rex & DISPREFIX_REX_FLAGS))
     1573                &&  (pCpu->fRexPrefix & DISPREFIX_REX_FLAGS))
    15741574                pParam->base.reg_gen += 8;
    15751575
    … …  
    16151615                &&  pParam == &pCpu->param1             /* ugly assumption that it only applies to the first parameter */
    16161616                &&  (pCpu->prefix & DISPREFIX_REX)
    1617                 &&  (pCpu->prefix_rex & DISPREFIX_REX_FLAGS))
     1617                &&  (pCpu->fRexPrefix & DISPREFIX_REX_FLAGS))
    16181618                pParam->base.reg_gen += 8;              /* least significant byte of R8-R15 */
    16191619        }
    … …  
    17421742
    17431743    /* 2nd byte */
    1744     pCpu->opcode = disReadByte(pCpu, uCodePtr);
     1744    pCpu->bOpCode = disReadByte(pCpu, uCodePtr);
    17451745
    17461746    /* default to the non-prefixed table. */
    1747     pOpcode      = &g_aTwoByteMapX86[pCpu->opcode];
     1747    pOpcode      = &g_aTwoByteMapX86[pCpu->bOpCode];
    17481748
    17491749    /* Handle opcode table extensions that rely on the address, repe or repne prefix byte.  */
    17501750    /** @todo Should we take the first or last prefix byte in case of multiple prefix bytes??? */
    1751     if (pCpu->lastprefix)
    1752     {
    1753         switch (pCpu->lastprefix)
     1751    if (pCpu->bLastPrefix)
     1752    {
     1753        switch (pCpu->bLastPrefix)
    17541754        {
    17551755        case OP_OPSIZE: /* 0x66 */
    1756             if (g_aTwoByteMapX86_PF66[pCpu->opcode].opcode != OP_INVALID)
     1756            if (g_aTwoByteMapX86_PF66[pCpu->bOpCode].opcode != OP_INVALID)
    17571757            {
    17581758                /* Table entry is valid, so use the extension table. */
    1759                 pOpcode = &g_aTwoByteMapX86_PF66[pCpu->opcode];
     1759                pOpcode = &g_aTwoByteMapX86_PF66[pCpu->bOpCode];
    17601760
    17611761                /* Cancel prefix changes. */
    … …  
    17661766
    17671767        case OP_REPNE:   /* 0xF2 */
    1768             if (g_aTwoByteMapX86_PFF2[pCpu->opcode].opcode != OP_INVALID)
     1768            if (g_aTwoByteMapX86_PFF2[pCpu->bOpCode].opcode != OP_INVALID)
    17691769            {
    17701770                /* Table entry is valid, so use the extension table. */
    1771                 pOpcode = &g_aTwoByteMapX86_PFF2[pCpu->opcode];
     1771                pOpcode = &g_aTwoByteMapX86_PFF2[pCpu->bOpCode];
    17721772
    17731773                /* Cancel prefix changes. */
    … …  
    17771777
    17781778        case OP_REPE:  /* 0xF3 */
    1779             if (g_aTwoByteMapX86_PFF3[pCpu->opcode].opcode != OP_INVALID)
     1779            if (g_aTwoByteMapX86_PFF3[pCpu->bOpCode].opcode != OP_INVALID)
    17801780            {
    17811781                /* Table entry is valid, so use the extension table. */
    1782                 pOpcode = &g_aTwoByteMapX86_PFF3[pCpu->opcode];
     1782                pOpcode = &g_aTwoByteMapX86_PFF3[pCpu->bOpCode];
    17831783
    17841784                /* Cancel prefix changes. */
    … …  
    18011801
    18021802    /* 3rd byte */
    1803     pCpu->opcode = disReadByte(pCpu, uCodePtr);
     1803    pCpu->bOpCode = disReadByte(pCpu, uCodePtr);
    18041804
    18051805    /* default to the non-prefixed table. */
    1806     if (g_apThreeByteMapX86_0F38[pCpu->opcode >> 4])
    1807     {
    1808         pOpcode = g_apThreeByteMapX86_0F38[pCpu->opcode >> 4];
    1809         pOpcode = &pOpcode[pCpu->opcode & 0xf];
     1806    if (g_apThreeByteMapX86_0F38[pCpu->bOpCode >> 4])
     1807    {
     1808        pOpcode = g_apThreeByteMapX86_0F38[pCpu->bOpCode >> 4];
     1809        pOpcode = &pOpcode[pCpu->bOpCode & 0xf];
    18101810    }
    18111811    else
    … …  
    18141814    /* Handle opcode table extensions that rely on the address, repne prefix byte.  */
    18151815    /** @todo Should we take the first or last prefix byte in case of multiple prefix bytes??? */
    1816     switch (pCpu->lastprefix)
     1816    switch (pCpu->bLastPrefix)
    18171817    {
    18181818    case OP_OPSIZE: /* 0x66 */
    1819         if (g_apThreeByteMapX86_660F38[pCpu->opcode >> 4])
     1819        if (g_apThreeByteMapX86_660F38[pCpu->bOpCode >> 4])
    18201820        {
    1821             pOpcode = g_apThreeByteMapX86_660F38[pCpu->opcode >> 4];
    1822             pOpcode = &pOpcode[pCpu->opcode & 0xf];
     1821            pOpcode = g_apThreeByteMapX86_660F38[pCpu->bOpCode >> 4];
     1822            pOpcode = &pOpcode[pCpu->bOpCode & 0xf];
    18231823
    18241824            if (pOpcode->opcode != OP_INVALID)
    … …  
    18341834
    18351835    case OP_REPNE:   /* 0xF2 */
    1836         if (g_apThreeByteMapX86_F20F38[pCpu->opcode >> 4])
     1836        if (g_apThreeByteMapX86_F20F38[pCpu->bOpCode >> 4])
    18371837        {
    1838             pOpcode = g_apThreeByteMapX86_F20F38[pCpu->opcode >> 4];
    1839             pOpcode = &pOpcode[pCpu->opcode & 0xf];
     1838            pOpcode = g_apThreeByteMapX86_F20F38[pCpu->bOpCode >> 4];
     1839            pOpcode = &pOpcode[pCpu->bOpCode & 0xf];
    18401840
    18411841            if (pOpcode->opcode != OP_INVALID)
    … …  
    18621862
    18631863    /* 3rd byte */
    1864     pCpu->opcode = disReadByte(pCpu, uCodePtr);
     1864    pCpu->bOpCode = disReadByte(pCpu, uCodePtr);
    18651865
    18661866    /** @todo Should we take the first or last prefix byte in case of multiple prefix bytes??? */
    1867     Assert(pCpu->lastprefix == OP_OPSIZE);
     1867    Assert(pCpu->bLastPrefix == OP_OPSIZE);
    18681868
    18691869    /* default to the non-prefixed table. */
    1870     if (g_apThreeByteMapX86_660F3A[pCpu->opcode >> 4])
    1871     {
    1872         pOpcode = g_apThreeByteMapX86_660F3A[pCpu->opcode >> 4];
    1873         pOpcode = &pOpcode[pCpu->opcode & 0xf];
     1870    if (g_apThreeByteMapX86_660F3A[pCpu->bOpCode >> 4])
     1871    {
     1872        pOpcode = g_apThreeByteMapX86_660F3A[pCpu->bOpCode >> 4];
     1873        pOpcode = &pOpcode[pCpu->bOpCode & 0xf];
    18741874
    18751875        if (pOpcode->opcode != OP_INVALID)
    … …  
    19101910unsigned ParseImmGrpl(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
    19111911{
    1912     int idx = (pCpu->opcode - 0x80) * 8;
     1912    int idx = (pCpu->bOpCode - 0x80) * 8;
    19131913    unsigned size = 0, modrm, reg;
    19141914    NOREF(pParam);
    … …  
    19341934    NOREF(pParam);
    19351935
    1936     switch (pCpu->opcode)
     1936    switch (pCpu->bOpCode)
    19371937    {
    19381938    case 0xC0:
    19391939    case 0xC1:
    1940         idx = (pCpu->opcode - 0xC0)*8;
     1940        idx = (pCpu->bOpCode - 0xC0)*8;
    19411941        break;
    19421942
    … …  
    19451945    case 0xD2:
    19461946    case 0xD3:
    1947         idx = (pCpu->opcode - 0xD0 + 2)*8;
     1947        idx = (pCpu->bOpCode - 0xD0 + 2)*8;
    19481948        break;
    19491949
    … …  
    19701970unsigned ParseGrp3(RTUINTPTR uCodePtr, PCDISOPCODE pOp, PDISOPPARAM pParam, PDISCPUSTATE pCpu)
    19711971{
    1972     int idx = (pCpu->opcode - 0xF6) * 8;
     1972    int idx = (pCpu->bOpCode - 0xF6) * 8;
    19731973    unsigned size = 0, modrm, reg;
    19741974    NOREF(pParam);

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

    r41732 r41733  
    494494             */
    495495            case OP_NOP:
    496                 if (pCpu->opcode == 0x90)
     496                if (pCpu->bOpCode == 0x90)
    497497                    /* fine, fine */;
    498498                else if (pszFmt[sizeof("nop %Ev") - 1] == '/' && pszFmt[sizeof("nop %Ev")] == 'p')
    499499                    pszFmt = "prefetch %Eb";
    500                 else if (pCpu->opcode == 0x1f)
     500                else if (pCpu->bOpCode == 0x1f)
    501501                {
    502502                    Assert(pCpu->cbInstr >= 3);
    … …  
    542542             */
    543543            case OP_FLD:
    544                 if (pCpu->opcode == 0xdb) /* m80fp workaround. */
     544                if (pCpu->bOpCode == 0xdb) /* m80fp workaround. */
    545545                    *(int *)&pCpu->param1.param &= ~0x1f; /* make it pure OP_PARM_M */
    546546                break;
    … …  
    14221422
    14231423                /* 82 (see table A-6). */
    1424                 if (pCpu->opcode == 0x82)
     1424                if (pCpu->bOpCode == 0x82)
    14251425                    return true;
    14261426                break;
    … …  
    14331433            case OP_POP:
    14341434            case OP_PUSH:
    1435                 Assert(pCpu->opcode == 0x8f);
     1435                Assert(pCpu->bOpCode == 0x8f);
    14361436                return true;
    14371437
    14381438            case OP_MOV:
    1439                 if (   pCpu->opcode == 0x8a
    1440                     || pCpu->opcode == 0x8b)
     1439                if (   pCpu->bOpCode == 0x8a
     1440                    || pCpu->bOpCode == 0x8b)
    14411441                    return true;
    14421442                break;
    … …  
    14651465
    14661466    /* And some more - see table A-6. */
    1467     if (pCpu->opcode == 0x82)
     1467    if (pCpu->bOpCode == 0x82)
    14681468    {
    14691469        switch (pCpu->pCurInstr->opcode)
    … …  
    15051505        case OP_SETLE:
    15061506        case OP_SETNLE:
    1507             AssertMsg(pCpu->opcode >= 0x90 && pCpu->opcode <= 0x9f, ("%#x\n", pCpu->opcode));
     1507            AssertMsg(pCpu->bOpCode >= 0x90 && pCpu->bOpCode <= 0x9f, ("%#x\n", pCpu->bOpCode));
    15081508            if (pCpu->ModRM.Bits.Reg != 2)
    15091509                return true;
    … …  
    15161516     */
    15171517    if (    pCpu->pCurInstr->opcode == OP_MOVZX
    1518         &&  pCpu->opcode == 0xB7
     1518        &&  pCpu->bOpCode == 0xB7
    15191519        &&  (pCpu->mode == DISCPUMODE_16BIT) != !!(fPrefixes & DISPREFIX_OPSIZE))
    15201520        return true;

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

    r41675 r41733  
    144144         /* The 0x8f /0 variant of this instruction doesn't get its /r value verified. */
    145145        case OP_POP:
    146             if (    pCpu->opcode == 0x8f
     146            if (    pCpu->bOpCode == 0x8f
    147147                &&  pCpu->ModRM.Bits.Reg != 0)
    148148                return false;
    … …  
    151151        /* The 0xc6 /0 and 0xc7 /0 variants of this instruction don't get their /r values verified. */
    152152        case OP_MOV:
    153             if (    (   pCpu->opcode == 0xc6
    154                      || pCpu->opcode == 0xc7)
     153            if (    (   pCpu->bOpCode == 0xc6
     154                     || pCpu->bOpCode == 0xc7)
    155155                &&  pCpu->ModRM.Bits.Reg != 0)
    156156                return false;

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

    r41675 r41733  
    110110                &&  !(pDis->prefix & (DISPREFIX_REPNE | DISPREFIX_REP | DISPREFIX_SEG)))
    111111            {
    112                 switch (pDis->opcode)
     112                switch (pDis->bOpCode)
    113113                {
    114114                    /** @todo Find other instructions we can safely skip, possibly
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