VirtualBox

Changeset 8234

Show
Ignore:
Timestamp:
04/21/08 16:29:54 (9 months ago)
Author:
vboxsync
Message:

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

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • 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")); 

© 2008 Sun Microsystems, Inc.
ContactPrivacy policy