VirtualBox

Changeset 8234 in vbox for trunk


Ignore:
Timestamp:
Apr 21, 2008 2:29:54 PM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
29963
Message:

MMIO: Cleanup up (removed duplicate code)
Disassembler: simplified general purpose register access

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/dis.h

    r8228 r8234  
    342342    union
    343343    {
    344         uint32_t    reg_gen8;
    345         uint32_t    reg_gen16;
    346         uint32_t    reg_gen32;
    347         uint32_t    reg_gen64;
     344        uint32_t    reg_gen;
    348345        /** ST(0) - ST(7) */
    349346        uint32_t    reg_fp;

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

    r8155 r8234  
    532532
    533533        pParam->flags |= USE_BASE | USE_REG_GEN32;
    534         pParam->base.reg_gen32 = base;
     534        pParam->base.reg_gen = base;
    535535    }
    536536    return;   /* Already fetched everything in ParseSIB; no size returned */
    … …  
    12401240        {
    12411241            /* Use 32-bit registers. */
    1242             pParam->base.reg_gen32 = pParam->param - OP_PARM_REG_GEN32_START;
     1242            pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN32_START;
    12431243            pParam->flags |= USE_REG_GEN32;
    12441244            pParam->size   = 4;
    … …  
    12471247        {
    12481248            /* Use 16-bit registers. */
    1249             pParam->base.reg_gen16 = pParam->param - OP_PARM_REG_GEN32_START;
     1249            pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN32_START;
    12501250            pParam->flags |= USE_REG_GEN16;
    12511251            pParam->size   = 2;
    … …  
    12651265    {
    12661266        /* 16-bit AX..DI registers. */
    1267         pParam->base.reg_gen16 = pParam->param - OP_PARM_REG_GEN16_START;
     1267        pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN16_START;
    12681268        pParam->flags |= USE_REG_GEN16;
    12691269        pParam->size   = 2;
    … …  
    12731273    {
    12741274        /* 8-bit AL..DL, AH..DH registers. */
    1275         pParam->base.reg_gen8 = pParam->param - OP_PARM_REG_GEN8_START;
     1275        pParam->base.reg_gen = pParam->param - OP_PARM_REG_GEN8_START;
    12761276        pParam->flags |= USE_REG_GEN8;
    12771277        pParam->size   = 1;
    … …  
    12991299    if (pCpu->addrmode == CPUMODE_32BIT)
    13001300    {
    1301         pParam->base.reg_gen32 = USE_REG_ESI;
     1301        pParam->base.reg_gen = USE_REG_ESI;
    13021302        pParam->flags |= USE_REG_GEN32;
    13031303    }
    13041304    else
    13051305    {
    1306         pParam->base.reg_gen16 = USE_REG_SI;
     1306        pParam->base.reg_gen = USE_REG_SI;
    13071307        pParam->flags |= USE_REG_GEN16;
    13081308    }
    … …  
    13181318    if (pCpu->addrmode == CPUMODE_32BIT)
    13191319    {
    1320         pParam->base.reg_gen32 = USE_REG_ESI;
     1320        pParam->base.reg_gen = USE_REG_ESI;
    13211321        pParam->flags |= USE_REG_GEN32;
    13221322    }
    13231323    else
    13241324    {
    1325         pParam->base.reg_gen16 = USE_REG_SI;
     1325        pParam->base.reg_gen = USE_REG_SI;
    13261326        pParam->flags |= USE_REG_GEN16;
    13271327    }
    … …  
    13381338    if (pCpu->addrmode == CPUMODE_32BIT)
    13391339    {
    1340         pParam->base.reg_gen32 = USE_REG_EDI;
     1340        pParam->base.reg_gen = USE_REG_EDI;
    13411341        pParam->flags |= USE_REG_GEN32;
    13421342    }
    13431343    else
    13441344    {
    1345         pParam->base.reg_gen16 = USE_REG_DI;
     1345        pParam->base.reg_gen = USE_REG_DI;
    13461346        pParam->flags |= USE_REG_GEN16;
    13471347    }
    … …  
    13571357    if (pCpu->addrmode == CPUMODE_32BIT)
    13581358    {
    1359         pParam->base.reg_gen32 = USE_REG_EDI;
     1359        pParam->base.reg_gen = USE_REG_EDI;
    13601360        pParam->flags |= USE_REG_GEN32;
    13611361    }
    13621362    else
    13631363    {
    1364         pParam->base.reg_gen16 = USE_REG_DI;
     1364        pParam->base.reg_gen = USE_REG_DI;
    13651365        pParam->flags |= USE_REG_GEN16;
    13661366    }
    … …  
    18261826        disasmAddString(pParam->szParam, szModRMReg8[idx]);
    18271827        pParam->flags |= USE_REG_GEN8;
    1828         pParam->base.reg_gen8 = idx;
     1828        pParam->base.reg_gen = idx;
    18291829        break;
    18301830
    … …  
    18321832        disasmAddString(pParam->szParam, szModRMReg16[idx]);
    18331833        pParam->flags |= USE_REG_GEN16;
    1834         pParam->base.reg_gen16 = idx;
     1834        pParam->base.reg_gen = idx;
    18351835        break;
    18361836
    … …  
    18381838        disasmAddString(pParam->szParam, szModRMReg32[idx]);
    18391839        pParam->flags |= USE_REG_GEN32;
    1840         pParam->base.reg_gen32 = idx;
     1840        pParam->base.reg_gen = idx;
    18411841        break;
    18421842
    … …  
    18601860    disasmAddString(pParam->szParam, szModRMReg1616[idx]);
    18611861    pParam->flags |= USE_REG_GEN16;
    1862     pParam->base.reg_gen16 = BaseModRMReg16[idx];
     1862    pParam->base.reg_gen = BaseModRMReg16[idx];
    18631863    if (idx < 4)
    18641864    {

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

    r8168 r8234  
    207207        return 8;
    208208
    209     case OP_PARM_p:
     209    case OP_PARM_p: /* far pointer */
    210210        if (pCpu->addrmode == CPUMODE_32BIT)
    211             return 8;
    212         else
    213             return 4;
     211            return 6;   /* 16:32 */
     212        else
     213        if (pCpu->addrmode == CPUMODE_64BIT)
     214            return 12;  /* 16:64 */
     215        else
     216            return 4;   /* 16:16 */
    214217
    215218    default:
    … …  
    232235    {
    233236        /* Guess segment register by parameter type. */
    234         if (pParam->flags & USE_REG_GEN32)
    235         {
    236             if (pParam->base.reg_gen32 == USE_REG_ESP || pParam->base.reg_gen32 == USE_REG_EBP)
    237                 return USE_REG_SS;
    238         }
    239         else
    240         if (pParam->flags & USE_REG_GEN16)
    241         {
    242             if (pParam->base.reg_gen16 == USE_REG_SP || pParam->base.reg_gen16 == USE_REG_BP)
     237        if (pParam->flags & (USE_REG_GEN32|USE_REG_GEN64|USE_REG_GEN16))
     238        {
     239            AssertCompile(USE_REG_ESP == USE_REG_RSP);
     240            AssertCompile(USE_REG_EBP == USE_REG_RBP);
     241            AssertCompile(USE_REG_ESP == USE_REG_SP);
     242            AssertCompile(USE_REG_EBP == USE_REG_BP);
     243            if (pParam->base.reg_gen == USE_REG_ESP || pParam->base.reg_gen == USE_REG_EBP)
    243244                return USE_REG_SS;
    244245        }
    … …  
    486487            {
    487488                pParamVal->flags |= PARAM_VAL8;
    488                 if (VBOX_FAILURE(DISFetchReg8(pCtx, pParam->base.reg_gen8, &pParamVal->val.val8))) return VERR_INVALID_PARAMETER;
     489                if (VBOX_FAILURE(DISFetchReg8(pCtx, pParam->base.reg_gen, &pParamVal->val.val8))) return VERR_INVALID_PARAMETER;
    489490            }
    490491            else
    … …  
    492493            {
    493494                pParamVal->flags |= PARAM_VAL16;
    494                 if (VBOX_FAILURE(DISFetchReg16(pCtx, pParam->base.reg_gen16, &pParamVal->val.val16))) return VERR_INVALID_PARAMETER;
     495                if (VBOX_FAILURE(DISFetchReg16(pCtx, pParam->base.reg_gen, &pParamVal->val.val16))) return VERR_INVALID_PARAMETER;
    495496            }
    496497            else
    … …  
    498499            {
    499500                pParamVal->flags |= PARAM_VAL32;
    500                 if (VBOX_FAILURE(DISFetchReg32(pCtx, pParam->base.reg_gen32, &pParamVal->val.val32))) return VERR_INVALID_PARAMETER;
     501                if (VBOX_FAILURE(DISFetchReg32(pCtx, pParam->base.reg_gen, &pParamVal->val.val32))) return VERR_INVALID_PARAMETER;
    501502            }
    502503            else
    … …  
    504505            {
    505506                pParamVal->flags |= PARAM_VAL64;
    506                 if (VBOX_FAILURE(DISFetchReg64(pCtx, pParam->base.reg_gen64, &pParamVal->val.val64))) return VERR_INVALID_PARAMETER;
     507                if (VBOX_FAILURE(DISFetchReg64(pCtx, pParam->base.reg_gen, &pParamVal->val.val64))) return VERR_INVALID_PARAMETER;
    507508            }
    508509            else {
    … …  
    581582            pParamVal->flags |= PARAM_VAL8;
    582583            pParamVal->size   = sizeof(uint8_t);
    583             if (VBOX_FAILURE(DISFetchReg8(pCtx, pParam->base.reg_gen8, &pParamVal->val.val8))) return VERR_INVALID_PARAMETER;
     584            if (VBOX_FAILURE(DISFetchReg8(pCtx, pParam->base.reg_gen, &pParamVal->val.val8))) return VERR_INVALID_PARAMETER;
    584585        }
    585586        else
    … …  
    588589            pParamVal->flags |= PARAM_VAL16;
    589590            pParamVal->size   = sizeof(uint16_t);
    590             if (VBOX_FAILURE(DISFetchReg16(pCtx, pParam->base.reg_gen16, &pParamVal->val.val16))) return VERR_INVALID_PARAMETER;
     591            if (VBOX_FAILURE(DISFetchReg16(pCtx, pParam->base.reg_gen, &pParamVal->val.val16))) return VERR_INVALID_PARAMETER;
    591592        }
    592593        else
    … …  
    595596            pParamVal->flags |= PARAM_VAL32;
    596597            pParamVal->size   = sizeof(uint32_t);
    597             if (VBOX_FAILURE(DISFetchReg32(pCtx, pParam->base.reg_gen32, &pParamVal->val.val32))) return VERR_INVALID_PARAMETER;
     598            if (VBOX_FAILURE(DISFetchReg32(pCtx, pParam->base.reg_gen, &pParamVal->val.val32))) return VERR_INVALID_PARAMETER;
    598599        }
    599600        else
    … …  
    602603            pParamVal->flags |= PARAM_VAL64;
    603604            pParamVal->size   = sizeof(uint64_t);
    604             if (VBOX_FAILURE(DISFetchReg64(pCtx, pParam->base.reg_gen64, &pParamVal->val.val64))) return VERR_INVALID_PARAMETER;
     605            if (VBOX_FAILURE(DISFetchReg64(pCtx, pParam->base.reg_gen, &pParamVal->val.val64))) return VERR_INVALID_PARAMETER;
    605606        }
    606607        else
    … …  
    698699        {
    699700            uint8_t *pu8Reg;
    700             if (VBOX_SUCCESS(DISPtrReg8(pCtx, pParam->base.reg_gen8, &pu8Reg)))
     701            if (VBOX_SUCCESS(DISPtrReg8(pCtx, pParam->base.reg_gen, &pu8Reg)))
    701702            {
    702703                *pcbSize = sizeof(uint8_t);
    … …  
    709710        {
    710711            uint16_t *pu16Reg;
    711             if (VBOX_SUCCESS(DISPtrReg16(pCtx, pParam->base.reg_gen16, &pu16Reg)))
     712            if (VBOX_SUCCESS(DISPtrReg16(pCtx, pParam->base.reg_gen, &pu16Reg)))
    712713            {
    713714                *pcbSize = sizeof(uint16_t);
    … …  
    720721        {
    721722            uint32_t *pu32Reg;
    722             if (VBOX_SUCCESS(DISPtrReg32(pCtx, pParam->base.reg_gen32, &pu32Reg)))
     723            if (VBOX_SUCCESS(DISPtrReg32(pCtx, pParam->base.reg_gen, &pu32Reg)))
    723724            {
    724725                *pcbSize = sizeof(uint32_t);
    … …  
    731732        {
    732733            uint64_t *pu64Reg;
    733             if (VBOX_SUCCESS(DISPtrReg64(pCtx, pParam->base.reg_gen64, &pu64Reg)))
     734            if (VBOX_SUCCESS(DISPtrReg64(pCtx, pParam->base.reg_gen, &pu64Reg)))
    734735            {
    735736                *pcbSize = sizeof(uint64_t);

  • trunk/src/VBox/VMM/IOMInternal.h

    r8155 r8234  
    514514#endif
    515515
     516/* Disassembly helpers used in IOMAll.cpp & IOMAllMMIO.cpp */
     517bool iomGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize);
     518bool iomSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, unsigned u32Data);
     519
    516520__END_DECLS
    517521
     522
    518523#ifdef IN_RING3
    519524

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

    r8155 r8234  
    11661166
    11671167        dbgreg = pCpu->param1.base.reg_dbg;
    1168         reg    = pCpu->param2.base.reg_gen32;
     1168        reg    = pCpu->param2.base.reg_gen;
    11691169    }
    11701170    else
    … …  
    11751175
    11761176        pPB[0] = 0x8B;      // mov GPR, disp32
    1177         reg    = pCpu->param1.base.reg_gen32;
     1177        reg    = pCpu->param1.base.reg_gen;
    11781178        dbgreg = pCpu->param2.base.reg_dbg;
    11791179    }
    … …  
    12421242        pPB[0] = 0x89;      //mov disp32, GPR
    12431243        ctrlreg = pCpu->param1.base.reg_ctrl;
    1244         reg     = pCpu->param2.base.reg_gen32;
     1244        reg     = pCpu->param2.base.reg_gen;
    12451245        Assert(pCpu->param1.flags & USE_REG_CR);
    12461246        Assert(pCpu->param2.flags & USE_REG_GEN32);
    … …  
    12531253
    12541254        pPB[0]  = 0x8B;      // mov GPR, disp32
    1255         reg     = pCpu->param1.base.reg_gen32;
     1255        reg     = pCpu->param1.base.reg_gen;
    12561256        ctrlreg = pCpu->param2.base.reg_ctrl;
    12571257    }
    … …  
    13191319    if (pCpu->prefix & PREFIX_OPSIZE)
    13201320        pPB[offset++] = 0x66; /* size override -> 16 bits pop */
    1321     pPB[offset++] = 0x58 + pCpu->param1.base.reg_gen32;
     1321    pPB[offset++] = 0x58 + pCpu->param1.base.reg_gen;
    13221322    PATCHGEN_EPILOG(pPatch, offset);
    13231323
    … …  
    13621362        pPB[offset++] = 0x8B;              // mov       destreg, CPUMCTX.tr/ldtr
    13631363        /* Modify REG part according to destination of original instruction */
    1364         pPB[offset++] = MAKE_MODRM(0, pCpu->param1.base.reg_gen32, 5);
     1364        pPB[offset++] = MAKE_MODRM(0, pCpu->param1.base.reg_gen, 5);
    13651365        if (pCpu->pCurInstr->opcode == OP_STR)
    13661366        {

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

    r8191 r8234  
    354354
    355355#if defined(VBOX_STRICT) || defined(LOG_ENABLED)
    356 # ifdef IN_GC
    357356/**
    358357 * Get the mnemonic for the disassembled instruction.
    … …  
    375374    }
    376375}
    377 # endif
    378376#endif
    379377
    … …  
    462460                {
    463461                case 1: //special case for AH etc
    464                         rc = DISWriteReg8(pRegFrame, pCpu->param1.base.reg_gen8, (uint8_t)valpar2); break;
    465                 case 2: rc = DISWriteReg16(pRegFrame, pCpu->param1.base.reg_gen32, (uint16_t)valpar2); break;
    466                 case 4: rc = DISWriteReg32(pRegFrame, pCpu->param1.base.reg_gen32, valpar2); break;
     462                        rc = DISWriteReg8(pRegFrame, pCpu->param1.base.reg_gen, (uint8_t)valpar2); break;
     463                case 2: rc = DISWriteReg16(pRegFrame, pCpu->param1.base.reg_gen, (uint16_t)valpar2); break;
     464                case 4: rc = DISWriteReg32(pRegFrame, pCpu->param1.base.reg_gen, valpar2); break;
    467465                default: AssertFailedReturn(VERR_EM_INTERPRETER);
    468466                }
    … …  
    487485                {
    488486                case 1: //special case for AH etc
    489                         rc = DISWriteReg8(pRegFrame, pCpu->param2.base.reg_gen8, (uint8_t)valpar1); break;
    490                 case 2: rc = DISWriteReg16(pRegFrame, pCpu->param2.base.reg_gen32, (uint16_t)valpar1); break;
    491                 case 4: rc = DISWriteReg32(pRegFrame, pCpu->param2.base.reg_gen32, valpar1); break;
     487                        rc = DISWriteReg8(pRegFrame, pCpu->param2.base.reg_gen, (uint8_t)valpar1); break;
     488                case 2: rc = DISWriteReg16(pRegFrame, pCpu->param2.base.reg_gen, (uint16_t)valpar1); break;
     489                case 4: rc = DISWriteReg32(pRegFrame, pCpu->param2.base.reg_gen, valpar1); break;
    492490                default: AssertFailedReturn(VERR_EM_INTERPRETER);
    493491                }
    … …  
    626624                if (    (pCpu->param1.flags & USE_BASE)
    627625                    &&  (pCpu->param1.flags & (USE_REG_GEN16|USE_REG_GEN32))
    628                     &&  pCpu->param1.base.reg_gen32 == USE_REG_ESP
     626                    &&  pCpu->param1.base.reg_gen == USE_REG_ESP
    629627                   )
    630628                   pParam1 = (RTGCPTR)((RTGCUINTPTR)pParam1 + param1.size);
    … …  
    12211219                switch(param1.size)
    12221220                {
    1223                 case 1: rc = DISWriteReg8(pRegFrame, pCpu->param1.base.reg_gen8, (uint8_t)val32); break;
    1224                 case 2: rc = DISWriteReg16(pRegFrame, pCpu->param1.base.reg_gen16, (uint16_t)val32); break;
    1225                 case 4: rc = DISWriteReg32(pRegFrame, pCpu->param1.base.reg_gen32, val32); break;
     1221                case 1: rc = DISWriteReg8(pRegFrame, pCpu->param1.base.reg_gen, (uint8_t)val32); break;
     1222                case 2: rc = DISWriteReg16(pRegFrame, pCpu->param1.base.reg_gen, (uint16_t)val32); break;
     1223                case 4: rc = DISWriteReg32(pRegFrame, pCpu->param1.base.reg_gen, val32); break;
    12261224                default:
    12271225                    return VERR_EM_INTERPRETER;
    … …  
    12521250
    12531251#ifdef LOG_ENABLED
    1254     const char *pszInstr;
     1252    char *pszInstr;
    12551253
    12561254    if (pCpu->prefix & PREFIX_LOCK)
    … …  
    13401338
    13411339#ifdef LOG_ENABLED
    1342     const char *pszInstr;
     1340    char *pszInstr;
    13431341
    13441342    if (pCpu->prefix & PREFIX_LOCK)
    … …  
    18141812{
    18151813    if (pCpu->param1.flags == USE_REG_GEN32 && pCpu->param2.flags == USE_REG_CR)
    1816         return EMInterpretCRxRead(pVM, pRegFrame, pCpu->param1.base.reg_gen32, pCpu->param2.base.reg_ctrl);
     1814        return EMInterpretCRxRead(pVM, pRegFrame, pCpu->param1.base.reg_gen, pCpu->param2.base.reg_ctrl);
    18171815    if (pCpu->param1.flags == USE_REG_CR && pCpu->param2.flags == USE_REG_GEN32)
    1818         return EMInterpretCRxWrite(pVM, pRegFrame, pCpu->param1.base.reg_ctrl, pCpu->param2.base.reg_gen32);
     1816        return EMInterpretCRxWrite(pVM, pRegFrame, pCpu->param1.base.reg_ctrl, pCpu->param2.base.reg_gen);
    18191817    AssertMsgFailedReturn(("Unexpected control register move\n"), VERR_EM_INTERPRETER);
    18201818    return VERR_EM_INTERPRETER;
    … …  
    18781876    if(pCpu->param1.flags == USE_REG_GEN32 && pCpu->param2.flags == USE_REG_DBG)
    18791877    {
    1880         rc = EMInterpretDRxRead(pVM, pRegFrame, pCpu->param1.base.reg_gen32, pCpu->param2.base.reg_dbg);
     1878        rc = EMInterpretDRxRead(pVM, pRegFrame, pCpu->param1.base.reg_gen, pCpu->param2.base.reg_dbg);
    18811879    }
    18821880    else
    18831881    if(pCpu->param1.flags == USE_REG_DBG && pCpu->param2.flags == USE_REG_GEN32)
    18841882    {
    1885         rc = EMInterpretDRxWrite(pVM, pRegFrame, pCpu->param1.base.reg_dbg, pCpu->param2.base.reg_gen32);
     1883        rc = EMInterpretDRxWrite(pVM, pRegFrame, pCpu->param1.base.reg_dbg, pCpu->param2.base.reg_gen);
    18861884    }
    18871885    else

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

    r8155 r8234  
    4646 * @param   pParam              Pointer to parameter of instruction to proccess.
    4747 */
    48 static unsigned iomGCGetRegSize(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam)
     48static unsigned iomGetRegSize(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam)
    4949{
    5050    if (pParam->flags & (USE_BASE | USE_INDEX | USE_SCALE | USE_DISPLACEMENT8 | USE_DISPLACEMENT16 | USE_DISPLACEMENT32 | USE_IMMEDIATE8 | USE_IMMEDIATE16 | USE_IMMEDIATE32 | USE_IMMEDIATE16_SX8 | USE_IMMEDIATE32_SX8))
    … …  
    5959    if (pParam->flags & USE_REG_GEN8)
    6060        return 1;
     61
     62    if (pParam->flags & USE_REG_GEN64)
     63        return 8;
    6164
    6265    if (pParam->flags & USE_REG_SEG)
    … …  
    7780 * @param   pcbSize             Where to store the size of data (1, 2, 4).
    7881 */
    79 static bool iomGCGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize)
     82bool iomGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize)
    8083{
    8184    if (pParam->flags & (USE_BASE | USE_INDEX | USE_SCALE | USE_DISPLACEMENT8 | USE_DISPLACEMENT16 | USE_DISPLACEMENT32))
    … …  
    8992    {
    9093        *pcbSize  = 4;
    91         DISFetchReg32(pRegFrame, pParam->base.reg_gen32, pu32Data);
     94        DISFetchReg32(pRegFrame, pParam->base.reg_gen, pu32Data);
    9295        return true;
    9396    }
    … …  
    9699    {
    97100        *pcbSize  = 2;
    98         DISFetchReg16(pRegFrame, pParam->base.reg_gen16, (uint16_t *)pu32Data);
     101        DISFetchReg16(pRegFrame, pParam->base.reg_gen, (uint16_t *)pu32Data);
    99102        return true;
    100103    }
    … …  
    103106    {
    104107        *pcbSize  = 1;
    105         DISFetchReg8(pRegFrame, pParam->base.reg_gen8, (uint8_t *)pu32Data);
     108        DISFetchReg8(pRegFrame, pParam->base.reg_gen, (uint8_t *)pu32Data);
     109        return true;
     110    }
     111
     112    if (pParam->flags & USE_REG_GEN64)
     113    {
     114        AssertFailed();
     115        *pcbSize  = 8;
     116        ///DISFetchReg64(pRegFrame, pParam->base.reg_gen, pu32Data);
     117        return true;
     118    }
     119
     120    if (pParam->flags & (USE_IMMEDIATE64))
     121    {
     122        AssertFailed();
     123        *pcbSize  = 8;
     124        *pu32Data = (uint32_t)pParam->parval;
    106125        return true;
    107126    }
    … …  
    110129    {
    111130        *pcbSize  = 4;
    112         *pu32Data = (uint32_t)pParam->parval;
     131        //*pu32Data = (uint32_t)pParam->parval;
    113132        return true;
    114133    }
    … …  
    135154    } /* Else - error. */
    136155
     156    AssertFailed();
    137157    *pcbSize  = 0;
    138158    *pu32Data = 0;
    … …  
    151171 * @param   u32Data             8/16/32 bit data to store.
    152172 */
    153 static bool iomGCSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, unsigned u32Data)
     173bool iomSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, unsigned u32Data)
    154174{
    155175    if (pParam->flags & (USE_BASE | USE_INDEX | USE_SCALE | USE_DISPLACEMENT8 | USE_DISPLACEMENT16 | USE_DISPLACEMENT32 | USE_IMMEDIATE8 | USE_IMMEDIATE16 | USE_IMMEDIATE32 | USE_IMMEDIATE32_SX8 | USE_IMMEDIATE16_SX8))
    … …  
    160180    if (pParam->flags & USE_REG_GEN32)
    161181    {
    162         DISWriteReg32(pRegFrame, pParam->base.reg_gen32, u32Data);
     182        DISWriteReg32(pRegFrame, pParam->base.reg_gen, u32Data);
    163183        return true;
    164184    }
    … …  
    166186    if (pParam->flags & USE_REG_GEN16)
    167187    {
    168         DISWriteReg16(pRegFrame, pParam->base.reg_gen16, (uint16_t)u32Data);
     188        DISWriteReg16(pRegFrame, pParam->base.reg_gen, (uint16_t)u32Data);
    169189        return true;
    170190    }
    … …  
    172192    if (pParam->flags & USE_REG_GEN8)
    173193    {
    174         DISWriteReg8(pRegFrame, pParam->base.reg_gen8, (uint8_t)u32Data);
     194        DISWriteReg8(pRegFrame, pParam->base.reg_gen, (uint8_t)u32Data);
    175195        return true;
    176196    }
    … …  
    189209 * Internal - statistics only.
    190210 */
    191 DECLINLINE(void) iomGCMMIOStatLength(PVM pVM, unsigned cb)
     211DECLINLINE(void) iomMMIOStatLength(PVM pVM, unsigned cb)
    192212{
    193213#ifdef VBOX_WITH_STATISTICS
    … …  
    857877    uint32_t    uPort = 0;
    858878    unsigned    cbSize = 0;
    859     bool fRc = iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uPort, &cbSize);
     879    bool fRc = iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uPort, &cbSize);
    860880    AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
    861881
    862     cbSize = iomGCGetRegSize(pCpu, &pCpu->param1);
     882    cbSize = iomGetRegSize(pCpu, &pCpu->param1);
    863883    Assert(cbSize > 0);
    864884    int rc = IOMInterpretCheckPortIOAccess(pVM, pRegFrame, uPort, cbSize);
    … …  
    875895             * Store the result in the AL|AX|EAX register.
    876896             */
    877             fRc = iomGCSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, u32Data);
     897            fRc = iomSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, u32Data);
    878898            AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
    879899        }
    … …  
    916936    uint32_t    uPort = 0;
    917937    unsigned    cbSize = 0;
    918     bool fRc = iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uPort, &cbSize);
     938    bool fRc = iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uPort, &cbSize);
    919939    AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
    920940
    … …  
    923943    {
    924944        uint32_t    u32Data = 0;
    925         fRc = iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cbSize);
     945        fRc = iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cbSize);
    926946        AssertMsg(fRc, ("Failed to get reg value!\n")); NOREF(fRc);
    927947

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

    r8155 r8234  
    4545#include <iprt/string.h>
    4646
    47 /*******************************************************************************
    48 *   Internal Functions                                                         *
    49 *******************************************************************************/
    50 static bool iomGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize);
    51 static bool iomSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t u32Data);
    5247
    5348
    … …  
    5550*   Global Variables                                                           *
    5651*******************************************************************************/
    57 /**
    58  * Array for accessing 32-bit general registers in VMMREGFRAME structure
    59  * by register's index from disasm.
    60  */
    61 static unsigned g_aReg32Index[] =
    62 {
    63     RT_OFFSETOF(CPUMCTXCORE, eax),        /* USE_REG_EAX */
    64     RT_OFFSETOF(CPUMCTXCORE, ecx),        /* USE_REG_ECX */
    65     RT_OFFSETOF(CPUMCTXCORE, edx),        /* USE_REG_EDX */
    66     RT_OFFSETOF(CPUMCTXCORE, ebx),        /* USE_REG_EBX */
    67     RT_OFFSETOF(CPUMCTXCORE, esp),        /* USE_REG_ESP */
    68     RT_OFFSETOF(CPUMCTXCORE, ebp),        /* USE_REG_EBP */
    69     RT_OFFSETOF(CPUMCTXCORE, esi),        /* USE_REG_ESI */
    70     RT_OFFSETOF(CPUMCTXCORE, edi)         /* USE_REG_EDI */
    71 };
    72 
    73 /**
    74  * Macro for accessing 32-bit general purpose registers in CPUMCTXCORE structure.
    75  */
    76 #define ACCESS_REG32(p, idx) (*((uint32_t *)((char *)(p) + g_aReg32Index[idx])))
    77 
    78 /**
    79  * Array for accessing 16-bit general registers in CPUMCTXCORE structure
    80  * by register's index from disasm.
    81  */
    82 static unsigned g_aReg16Index[] =
    83 {
    84     RT_OFFSETOF(CPUMCTXCORE, eax),        /* USE_REG_AX */
    85     RT_OFFSETOF(CPUMCTXCORE, ecx),        /* USE_REG_CX */
    86     RT_OFFSETOF(CPUMCTXCORE, edx),        /* USE_REG_DX */
    87     RT_OFFSETOF(CPUMCTXCORE, ebx),        /* USE_REG_BX */
    88     RT_OFFSETOF(CPUMCTXCORE, esp),        /* USE_REG_SP */
    89     RT_OFFSETOF(CPUMCTXCORE, ebp),        /* USE_REG_BP */
    90     RT_OFFSETOF(CPUMCTXCORE, esi),        /* USE_REG_SI */
    91     RT_OFFSETOF(CPUMCTXCORE, edi)         /* USE_REG_DI */
    92 };
    93 
    94 /**
    95  * Macro for accessing 16-bit general purpose registers in CPUMCTXCORE structure.
    96  */
    97 #define ACCESS_REG16(p, idx) (*((uint16_t *)((char *)(p) + g_aReg16Index[idx])))
    98 
    99 /**
    100  * Array for accessing 8-bit general registers in CPUMCTXCORE structure
    101  * by register's index from disasm.
    102  */
    103 static unsigned g_aReg8Index[] =
    104 {
    105     RT_OFFSETOF(CPUMCTXCORE, eax),        /* USE_REG_AL */
    106     RT_OFFSETOF(CPUMCTXCORE, ecx),        /* USE_REG_CL */
    107     RT_OFFSETOF(CPUMCTXCORE, edx),        /* USE_REG_DL */
    108     RT_OFFSETOF(CPUMCTXCORE, ebx),        /* USE_REG_BL */
    109     RT_OFFSETOF(CPUMCTXCORE, eax) + 1,    /* USE_REG_AH */
    110     RT_OFFSETOF(CPUMCTXCORE, ecx) + 1,    /* USE_REG_CH */
    111     RT_OFFSETOF(CPUMCTXCORE, edx) + 1,    /* USE_REG_DH */
    112     RT_OFFSETOF(CPUMCTXCORE, ebx) + 1     /* USE_REG_BH */
    113 };
    114 
    115 /**
    116  * Macro for accessing 8-bit general purpose registers in CPUMCTXCORE structure.
    117  */
    118 #define ACCESS_REG8(p, idx) (*((uint8_t *)((char *)(p) + g_aReg8Index[idx])))
    119 
    120 /**
    121  * Array for accessing segment registers in CPUMCTXCORE structure
    122  * by register's index from disasm.
    123  */
    124 static unsigned g_aRegSegIndex[] =
    125 {
    126     RT_OFFSETOF(CPUMCTXCORE, es),         /* USE_REG_ES */
    127     RT_OFFSETOF(CPUMCTXCORE, cs),         /* USE_REG_CS */
    128     RT_OFFSETOF(CPUMCTXCORE, ss),         /* USE_REG_SS */
    129     RT_OFFSETOF(CPUMCTXCORE, ds),         /* USE_REG_DS */
    130     RT_OFFSETOF(CPUMCTXCORE, fs),         /* USE_REG_FS */
    131     RT_OFFSETOF(CPUMCTXCORE, gs)          /* USE_REG_GS */
    132 };
    133 
    134 /**
    135  * Macro for accessing segment registers in CPUMCTXCORE structure.
    136  */
    137 #define ACCESS_REGSEG(p, idx) (*((uint16_t *)((char *)(p) + g_aRegSegIndex[idx])))
    13852
    13953/**
    … …  
    211125    return rc;
    212126}
    213 
    214 
    215 /**
    216  * Returns the contents of register or immediate data of instruction's parameter.
    217  *
    218  * @returns true on success.
    219  *
    220  * @param   pCpu                Pointer to current disassembler context.
    221  * @param   pParam              Pointer to parameter of instruction to proccess.
    222  * @param   pRegFrame           Pointer to CPUMCTXCORE guest structure.
    223  * @param   pu32Data            Where to store retrieved data.
    224  * @param   pcbSize             Where to store the size of data (1, 2, 4).
    225  */
    226 static bool iomGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize)
    227 {
    228     if (pParam->flags & (USE_BASE | USE_INDEX | USE_SCALE | USE_DISPLACEMENT8 | USE_DISPLACEMENT16 | USE_DISPLACEMENT32))
    229     {
    230         *pcbSize  = 0;
    231         *pu32Data = 0;
    232         return false;
    233     }
    234 
    235     if (pParam->flags & USE_REG_GEN32)
    236     {
    237         *pcbSize  = 4;
    238         *pu32Data = ACCESS_REG32(pRegFrame, pParam->base.reg_gen32);
    239         return true;
    240     }
    241 
    242     if (pParam->flags & USE_REG_GEN16)
    243     {
    244         *pcbSize  = 2;
    245         *pu32Data = ACCESS_REG16(pRegFrame, pParam->base.reg_gen16);
    246         return true;
    247     }
    248 
    249     if (pParam->flags & USE_REG_GEN8)
    250     {
    251         *pcbSize  = 1;
    252         *pu32Data = ACCESS_REG8(pRegFrame, pParam->base.reg_gen8);
    253         return true;
    254     }
    255 
    256     if (pParam->flags & (USE_IMMEDIATE32|USE_IMMEDIATE32_SX8))
    257     {
    258         *pcbSize  = 4;
    259         *pu32Data = (uint32_t)pParam->parval;
    260         return true;
    261     }
    262 
    263     if (pParam->flags & (USE_IMMEDIATE16|USE_IMMEDIATE16_SX8))
    264     {
    265         *pcbSize  = 2;
    266         *pu32Data = (uint16_t)pParam->parval;
    267         return true;
    268     }
    269 
    270     if (pParam->flags & USE_IMMEDIATE8)
    271     {
    272         *pcbSize  = 1;
    273         *pu32Data = (uint8_t)pParam->parval;
    274         return true;
    275     }
    276 
    277     if (pParam->flags & USE_REG_SEG)
    278     {
    279         *pcbSize  = 2;
    280         *pu32Data = ACCESS_REGSEG(pRegFrame, pParam->base.reg_seg);
    281         return true;
    282     } /* Else - error. */
    283 
    284     *pcbSize  = 0;
    285     *pu32Data = 0;
    286     return false;
    287 }
    288 
    289 
    290 /**
    291  * Saves data to 8/16/32 general purpose or segment register defined by
    292  * instruction's parameter.
    293  *
    294  * @returns true on success.
    295  * @param   pCpu                Pointer to current disassembler context.
    296  * @param   pParam              Pointer to parameter of instruction to proccess.
    297  * @param   pRegFrame           Pointer to CPUMCTXCORE guest structure.
    298  * @param   u32Data             8/16/32 bit data to store.
    299  */
    300 static bool iomSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, unsigned u32Data)
    301 {
    302     if (pParam->flags & (USE_BASE | USE_INDEX | USE_SCALE | USE_DISPLACEMENT8 | USE_DISPLACEMENT16 | USE_DISPLACEMENT32 | USE_IMMEDIATE8 | USE_IMMEDIATE16 | USE_IMMEDIATE32 | USE_IMMEDIATE32_SX8 | USE_IMMEDIATE16_SX8))
    303     {
    304         return false;
    305     }
    306 
    307     if (pParam->flags & USE_REG_GEN32)
    308     {
    309         ACCESS_REG32(pRegFrame, pParam->base.reg_gen32) = u32Data;
    310         return true;
    311     }
    312 
    313     if (pParam->flags & USE_REG_GEN16)
    314     {
    315         ACCESS_REG16(pRegFrame, pParam->base.reg_gen16) = (uint16_t)u32Data;
    316         return true;
    317     }
    318 
    319     if (pParam->flags & USE_REG_GEN8)
    320     {
    321         ACCESS_REG8(pRegFrame, pParam->base.reg_gen8) = (uint8_t)u32Data;
    322         return true;
    323     }
    324 
    325     if (pParam->flags & USE_REG_SEG)
    326     {
    327         ACCESS_REGSEG(pRegFrame, pParam->base.reg_seg) = (uint16_t)u32Data;
    328         return true;
    329     }
    330 
    331     /* Else - error. */
    332     return false;
    333 }
    334 
    335127
    336128/*

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

    r8155 r8234  
    563563    }
    564564    if (    (pCpu->param1.flags & USE_REG_GEN32)
    565         &&  (pCpu->param1.base.reg_gen32 == USE_REG_ESP))
     565        &&  (pCpu->param1.base.reg_gen == USE_REG_ESP))
    566566    {
    567567        Log4(("pgmPoolMonitorIsReused: ESP\n"));
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