VirtualBox

Changeset 7686 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
Apr 1, 2008 2:42:17 PM (17 years ago)
Author:
vboxsync
Message:

Wrong prefix

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r5999 r7686  
    4444*   Internal Functions                                                         *
    4545*******************************************************************************/
    46 static bool iomGCGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize);
    47 static bool iomGCSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t u32Data);
     46static bool iomGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize);
     47static bool iomSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t u32Data);
    4848
    4949
    … …  
    159159 * @warning VBOX_SUCCESS(rc=VINF_IOM_HC_MMIO_WRITE) is TRUE!
    160160 */
    161 inline int iomGCMMIODoWrite(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cbSize)
     161inline int iomMMIODoWrite(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, const void *pvData, unsigned cbSize)
    162162{
    163163#ifdef VBOX_WITH_STATISTICS
    … …  
    180180 * Wrapper which does the read and updates range statistics when such are enabled.
    181181 */
    182 inline int iomGCMMIODoRead(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, void *pvData, unsigned cbSize)
     182inline int iomMMIODoRead(PVM pVM, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault, void *pvData, unsigned cbSize)
    183183{
    184184#ifdef VBOX_WITH_STATISTICS
    … …  
    210210 * @param   pcbSize             Where to store the size of data (1, 2, 4).
    211211 */
    212 static bool iomGCGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize)
     212static bool iomGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint32_t *pu32Data, unsigned *pcbSize)
    213213{
    214214    if (pParam->flags & (USE_BASE | USE_INDEX | USE_SCALE | USE_DISPLACEMENT8 | USE_DISPLACEMENT16 | USE_DISPLACEMENT32))
    … …  
    284284 * @param   u32Data             8/16/32 bit data to store.
    285285 */
    286 static bool iomGCSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, unsigned u32Data)
     286static bool iomSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, unsigned u32Data)
    287287{
    288288    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))
    … …  
    323323 * Internal - statistics only.
    324324 */
    325 inline void iomGCMMIOStatLength(PVM pVM, unsigned cb)
     325inline void iomMMIOStatLength(PVM pVM, unsigned cb)
    326326{
    327327#ifdef VBOX_WITH_STATISTICS
    … …  
    361361 * @param   GCPhysFault The GC physical address corresponding to pvFault.
    362362 */
    363 static int iomGCInterpretMOVxXRead(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault)
     363static int iomInterpretMOVxXRead(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault)
    364364{
    365365    /*
    … …  
    377377
    378378    uint32_t u32Data = 0;
    379     int rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &u32Data, cbSize);
     379    int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &u32Data, cbSize);
    380380    if (rc == VINF_SUCCESS)
    381381    {
    … …  
    403403         * Store the result to register (parameter 1).
    404404         */
    405         bool fRc = iomGCSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, u32Data);
     405        bool fRc = iomSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, u32Data);
    406406        AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
    407407    }
    408408
    409409    if (rc == VINF_SUCCESS)
    410         iomGCMMIOStatLength(pVM, cbSize);
     410        iomMMIOStatLength(pVM, cbSize);
    411411    return rc;
    412412}
    … …  
    424424 * @param   GCPhysFault The GC physical address corresponding to pvFault.
    425425 */
    426 static int iomGCInterpretMOVxXWrite(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault)
     426static int iomInterpretMOVxXWrite(PVM pVM, PCPUMCTXCORE pRegFrame, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange, RTGCPHYS GCPhysFault)
    427427{
    428428    /*
    … …  
    438438    unsigned cbSize = 0;
    439439    uint32_t u32Data  = 0;
    440     bool fRc = iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cbSize);
     440    bool fRc = iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &u32Data, &cbSize);
    441441    AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
    442442
    443     int rc = iomGCMMIODoWrite(pVM, pRange, GCPhysFault, &u32Data, cbSize);
     443    int rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &u32Data, cbSize);
    444444    if (rc == VINF_SUCCESS)
    445         iomGCMMIOStatLength(pVM, cbSize);
     445        iomMMIOStatLength(pVM, cbSize);
    446446    return rc;
    447447}
    … …  
    491491 * @param   pRange      Pointer MMIO range.
    492492 */
    493 #ifdef IOMGC_MOVS_SUPPORT
    494 static int iomGCInterpretMOVS(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
     493#ifdef iom_MOVS_SUPPORT
     494static int iomInterpretMOVS(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
    495495{
    496496    STAM_PROFILE_START(&pVM->iom.s.StatGCInstMovs, a);
    … …  
    577577                if (rc != VINF_SUCCESS)
    578578                    break;
    579                 rc = iomGCMMIODoWrite(pVM, pRange, Phys, &u32Data, cbSize);
     579                rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cbSize);
    580580                if (rc != VINF_SUCCESS)
    581581                    break;
    … …  
    642642            {
    643643                uint32_t u32Data;
    644                 rc = iomGCMMIODoRead(pVM, pRange, Phys, &u32Data, cbSize);
     644                rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cbSize);
    645645                if (rc != VINF_SUCCESS)
    646646                    break;
    647                 rc = iomGCMMIODoWrite(pVM, pMMIODst, PhysDst, &u32Data, cbSize);
     647                rc = iomMMIODoWrite(pVM, pMMIODst, PhysDst, &u32Data, cbSize);
    648648                if (rc != VINF_SUCCESS)
    649649                    break;
    … …  
    681681            {
    682682                uint32_t u32Data;
    683                 rc = iomGCMMIODoRead(pVM, pRange, Phys, &u32Data, cbSize);
     683                rc = iomMMIODoRead(pVM, pRange, Phys, &u32Data, cbSize);
    684684                if (rc != VINF_SUCCESS)
    685685                    break;
    … …  
    712712    {
    713713        STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMovs, a);
    714         iomGCMMIOStatLength(pVM, cbSize);
     714        iomMMIOStatLength(pVM, cbSize);
    715715    }
    716716    return rc;
    … …  
    736736 * @param   pRange      Pointer MMIO range.
    737737 */
    738 static int iomGCInterpretSTOS(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
     738static int iomInterpretSTOS(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
    739739{
    740740    STAM_PROFILE_START(&pVM->iom.s.StatGCInstStos, a);
    … …  
    819819        do
    820820        {
    821             rc = iomGCMMIODoWrite(pVM, pRange, Phys, &u32Data, cbSize);
     821            rc = iomMMIODoWrite(pVM, pRange, Phys, &u32Data, cbSize);
    822822            if (rc != VINF_SUCCESS)
    823823                break;
    … …  
    839839    {
    840840        STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstStos, a);
    841         iomGCMMIOStatLength(pVM, cbSize);
     841        iomMMIOStatLength(pVM, cbSize);
    842842    }
    843843    return rc;
    … …  
    861861 * @param   pRange      Pointer MMIO range.
    862862 */
    863 static int iomGCInterpretLODS(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
     863static int iomInterpretLODS(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
    864864{
    865865    STAM_PROFILE_START(&pVM->iom.s.StatGCInstLods, a1);
    … …  
    885885     * Perform read.
    886886     */
    887     int rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &pRegFrame->eax, cbSize);
     887    int rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &pRegFrame->eax, cbSize);
    888888    if (rc == VINF_SUCCESS)
    889889        pRegFrame->esi += offIncrement;
    … …  
    895895    {
    896896        STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstLods, a1);
    897         iomGCMMIOStatLength(pVM, cbSize);
     897        iomMMIOStatLength(pVM, cbSize);
    898898    }
    899899    return rc;
    … …  
    916916 * @param   pRange      Pointer MMIO range.
    917917 */
    918 static int iomGCInterpretCMP(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
     918static int iomInterpretCMP(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
    919919{
    920920    STAM_PROFILE_START(&pVM->iom.s.StatGCInstCmp, a1);
    … …  
    931931    uint32_t uData2;
    932932    int rc;
    933     if (iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
     933    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
    934934        /* cmp reg, [MMIO]. */
    935         rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
    936     else if (iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
     935        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
     936    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
    937937        /* cmp [MMIO], reg|imm. */
    938         rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
     938        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
    939939    else
    940940    {
    … …  
    951951
    952952        STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstCmp, a1);
    953         iomGCMMIOStatLength(pVM, cbSize);
     953        iomMMIOStatLength(pVM, cbSize);
    954954    }
    955955
    … …  
    973973 * @param   pRange      Pointer MMIO range.
    974974 */
    975 static int iomGCInterpretAND(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
     975static int iomInterpretAND(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
    976976{
    977977    STAM_PROFILE_START(&pVM->iom.s.StatGCInstAnd, a1);
    … …  
    984984    bool        fAndWrite;
    985985    int         rc;
    986     if (iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
     986    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
    987987    {
    988988        /* and reg, [MMIO]. */
    989989        fAndWrite = false;
    990990        if (pRange->pfnReadCallback)
    991             rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
     991            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
    992992        else
    993993            rc = VINF_IOM_HC_MMIO_READ;
    994994    }
    995     else if (iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
     995    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
    996996    {
    997997        /* and [MMIO], reg|imm. */
    998998        fAndWrite = true;
    999999        if (pRange->pfnReadCallback && pRange->pfnWriteCallback)
    1000             rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
     1000            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
    10011001        else
    10021002            rc = VINF_IOM_HC_MMIO_READ_WRITE;
    … …  
    10141014        if (fAndWrite)
    10151015            /* Store result to MMIO. */
    1016             rc = iomGCMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cbSize);
     1016            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cbSize);
    10171017        else
    10181018        {
    10191019            /* Store result to register. */
    1020             bool fRc = iomGCSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, uData1);
     1020            bool fRc = iomSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, uData1);
    10211021            AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
    10221022        }
    … …  
    10271027                                  | (eflags                &  (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
    10281028            STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstAnd, a1);
    1029             iomGCMMIOStatLength(pVM, cbSize);
     1029            iomMMIOStatLength(pVM, cbSize);
    10301030        }
    10311031    }
    … …  
    10511051 * @param   pRange      Pointer MMIO range.
    10521052 */
    1053 static int iomGCInterpretTEST(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
     1053static int iomInterpretTEST(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
    10541054{
    10551055    STAM_PROFILE_START(&pVM->iom.s.StatGCInstTest, a1);
    … …  
    10621062    int         rc;
    10631063
    1064     if (iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
     1064    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
    10651065    {
    10661066        /* and test, [MMIO]. */
    10671067        if (pRange->pfnReadCallback)
    1068             rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
     1068            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
    10691069        else
    10701070            rc = VINF_IOM_HC_MMIO_READ;
    10711071    }
    1072     else if (iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
     1072    else if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
    10731073    {
    10741074        /* test [MMIO], reg|imm. */
    10751075        if (pRange->pfnReadCallback)
    1076             rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
     1076            rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
    10771077        else
    10781078            rc = VINF_IOM_HC_MMIO_READ;
    … …  
    10911091                              | (eflags                &  (X86_EFL_CF | X86_EFL_PF | X86_EFL_AF | X86_EFL_ZF | X86_EFL_SF | X86_EFL_OF));
    10921092        STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstTest, a1);
    1093         iomGCMMIOStatLength(pVM, cbSize);
     1093        iomMMIOStatLength(pVM, cbSize);
    10941094    }
    10951095
    … …  
    11121112 * @param   pRange      Pointer MMIO range.
    11131113 */
    1114 static int iomGCInterpretXCHG(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
     1114static int iomInterpretXCHG(PVM pVM, PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, PDISCPUSTATE pCpu, CTXALLSUFF(PIOMMMIORANGE) pRange)
    11151115{
    11161116    STAM_PROFILE_START(&pVM->iom.s.StatGCInstTest, a1);
    … …  
    11281128    }
    11291129
    1130     if (iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
     1130    if (iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uData1, &cbSize))
    11311131    {
    11321132        /* xchg reg, [MMIO]. */
    1133         rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
     1133        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData2, cbSize);
    11341134        if (rc == VINF_SUCCESS)
    11351135        {
    11361136            /* Store result to MMIO. */
    1137             rc = iomGCMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cbSize);
     1137            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData1, cbSize);
    11381138
    11391139            if (rc == VINF_SUCCESS)
    11401140            {
    11411141                /* Store result to register. */
    1142                 bool fRc = iomGCSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, uData2);
     1142                bool fRc = iomSaveDataToReg(pCpu, &pCpu->param1, pRegFrame, uData2);
    11431143                AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
    11441144            }
    … …  
    11501150    }
    11511151    else
    1152     if (iomGCGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
     1152    if (iomGetRegImmData(pCpu, &pCpu->param2, pRegFrame, &uData2, &cbSize))
    11531153    {
    11541154        /* xchg [MMIO], reg. */
    1155         rc = iomGCMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
     1155        rc = iomMMIODoRead(pVM, pRange, GCPhysFault, &uData1, cbSize);
    11561156        if (rc == VINF_SUCCESS)
    11571157        {
    11581158            /* Store result to MMIO. */
    1159             rc = iomGCMMIODoWrite(pVM, pRange, GCPhysFault, &uData2, cbSize);
     1159            rc = iomMMIODoWrite(pVM, pRange, GCPhysFault, &uData2, cbSize);
    11601160
    11611161            if (rc == VINF_SUCCESS)
    11621162            {
    11631163                /* Store result to register. */
    1164                 bool fRc = iomGCSaveDataToReg(pCpu, &pCpu->param2, pRegFrame, uData1);
     1164                bool fRc = iomSaveDataToReg(pCpu, &pCpu->param2, pRegFrame, uData1);
    11651165                AssertMsg(fRc, ("Failed to store register value!\n")); NOREF(fRc);
    11661166            }
    … …  
    12961296                STAM_PROFILE_START(&pVM->iom.s.StatGCInstMov, b);
    12971297                if (uErrorCode & X86_TRAP_PF_RW)
    1298                     rc = iomGCInterpretMOVxXWrite(pVM, pRegFrame, &cpu, pRange, GCPhysFault);
     1298                    rc = iomInterpretMOVxXWrite(pVM, pRegFrame, &cpu, pRange, GCPhysFault);
    12991299                else
    1300                     rc = iomGCInterpretMOVxXRead(pVM, pRegFrame, &cpu, pRange, GCPhysFault);
     1300                    rc = iomInterpretMOVxXRead(pVM, pRegFrame, &cpu, pRange, GCPhysFault);
    13011301                if (rc == VINF_SUCCESS)
    13021302                    STAM_PROFILE_STOP(&pVM->iom.s.StatGCInstMov, b);
    … …  
    13051305
    13061306
    1307 #ifdef IOMGC_MOVS_SUPPORT
     1307#ifdef iom_MOVS_SUPPORT
    13081308            case OP_MOVSB:
    13091309            case OP_MOVSWD:
    1310                 rc = iomGCInterpretMOVS(pVM, uErrorCode, pRegFrame, GCPhysFault, &cpu, pRange);
     1310                rc = iomInterpretMOVS(pVM, uErrorCode, pRegFrame, GCPhysFault, &cpu, pRange);
    13111311                break;
    13121312#endif
    … …  
    13151315            case OP_STOSWD:
    13161316                Assert(uErrorCode & X86_TRAP_PF_RW);
    1317                 rc = iomGCInterpretSTOS(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
     1317                rc = iomInterpretSTOS(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
    13181318                break;
    13191319
    … …  
    13211321            case OP_LODSWD:
    13221322                Assert(!(uErrorCode & X86_TRAP_PF_RW));
    1323                 rc = iomGCInterpretLODS(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
     1323                rc = iomInterpretLODS(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
    13241324                break;
    13251325
    … …  
    13271327            case OP_CMP:
    13281328                Assert(!(uErrorCode & X86_TRAP_PF_RW));
    1329                 rc = iomGCInterpretCMP(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
     1329                rc = iomInterpretCMP(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
    13301330                break;
    13311331
    13321332            case OP_AND:
    1333                 rc = iomGCInterpretAND(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
     1333                rc = iomInterpretAND(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
    13341334                break;
    13351335
    13361336            case OP_TEST:
    13371337                Assert(!(uErrorCode & X86_TRAP_PF_RW));
    1338                 rc = iomGCInterpretTEST(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
     1338                rc = iomInterpretTEST(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
    13391339                break;
    13401340
    13411341            case OP_XCHG:
    1342                 rc = iomGCInterpretXCHG(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
     1342                rc = iomInterpretXCHG(pVM, pRegFrame, GCPhysFault, &cpu, pRange);
    13431343                break;
    13441344
    … …  
    18671867    uint32_t    uPort = 0;
    18681868    unsigned    cbSize = 0;
    1869     bool fRc = iomGCGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uPort, &cbSize);
     1869    bool fRc = iomGetRegImmData(pCpu, &pCpu->param1, pRegFrame, &uPort, &cbSize);
    18701870    AssertMsg(fRc, ("Failed to get reg/imm port number!\n")); NOREF(fRc);
    18711871    if (pCpu->pCurInstr->opcode == OP_OUTSB)
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