VirtualBox

Ignore:
Timestamp:
Feb 2, 2012 4:48:02 PM (13 years ago)
Author:
vboxsync
Message:

IEM: String fixes; invlpg.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/VMM/VMMAll/IEMAllCImplStrInstr.cpp.h

    r38092 r39958  
    6464     * Setup.
    6565     */
    66     ADDR_TYPE       uCounterReg = pCtx->ADDR_rCX;
     66    ADDR_TYPE       uCounterReg  = pCtx->ADDR_rCX;
    6767    if (uCounterReg == 0)
    6868    {
    … …  
    7171    }
    7272
    73     PCCPUMSELREGHID pSrc1Hid = iemSRegGetHid(pIemCpu, iEffSeg);
    74     VBOXSTRICTRC rcStrict = iemMemSegCheckReadAccessEx(pIemCpu, pSrc1Hid, iEffSeg);
     73    PCCPUMSELREGHID pSrc1Hid     = iemSRegGetHid(pIemCpu, iEffSeg);
     74    VBOXSTRICTRC    rcStrict    = iemMemSegCheckReadAccessEx(pIemCpu, pSrc1Hid, iEffSeg);
    7575    if (rcStrict != VINF_SUCCESS)
    7676        return rcStrict;
    … …  
    8080        return rcStrict;
    8181
    82     int8_t const    cbIncr      = pCtx->eflags.Bits.u1DF ? -(OP_SIZE / 8) : (OP_SIZE / 8);
     82    int8_t const    cbIncr       = pCtx->eflags.Bits.u1DF ? -(OP_SIZE / 8) : (OP_SIZE / 8);
    8383    ADDR_TYPE       uSrc1AddrReg = pCtx->ADDR_rSI;
    8484    ADDR_TYPE       uSrc2AddrReg = pCtx->ADDR_rDI;
    85     uint32_t        uEFlags     = pCtx->eflags.u;
     85    uint32_t        uEFlags      = pCtx->eflags.u;
    8686
    8787    /*
    … …  
    104104            cLeftSrc1Page = uCounterReg;
    105105        uint32_t    cLeftSrc2Page = (PAGE_SIZE - (uVirtSrc2Addr & PAGE_OFFSET_MASK)) / (OP_SIZE / 8);
    106         uint32_t    cLeftPage = RT_MIN(cLeftSrc1Page, cLeftSrc2Page);
     106        uint32_t    cLeftPage     = RT_MIN(cLeftSrc1Page, cLeftSrc2Page);
    107107
    108108        if (   cLeftPage > 0 /* can be null if unaligned, do one fallback round. */
    … …  
    119119            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtSrc1Addr, IEM_ACCESS_DATA_R, &GCPhysSrc1Mem);
    120120            if (rcStrict != VINF_SUCCESS)
    121                 break;
     121                return rcStrict;
    122122
    123123            RTGCPHYS GCPhysSrc2Mem;
    124124            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtSrc2Addr, IEM_ACCESS_DATA_R, &GCPhysSrc2Mem);
    125125            if (rcStrict != VINF_SUCCESS)
    126                 break;
     126                return rcStrict;
    127127
    128128            /*
    … …  
    144144                        uSrc1AddrReg += cLeftPage * cbIncr;
    145145                        uSrc2AddrReg += cLeftPage * cbIncr;
    146                         uCounterReg -= cLeftPage;
     146                        uCounterReg  -= cLeftPage;
    147147                    }
    148148                    else
    … …  
    150150                        /* Some mismatch, compare each item (and keep volatile
    151151                           memory in mind). */
     152                        uint32_t off = 0;
    152153                        do
    153154                        {
    154                             RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)((OP_TYPE *)puSrc1Mem, *puSrc2Mem, &uEFlags);
    155                             uSrc1AddrReg += cbIncr;
    156                             uSrc2AddrReg += cbIncr;
    157                             uCounterReg--;
    158                             puSrc1Mem++;
    159                             puSrc2Mem++;
    160                             cLeftPage--;
    161                         } while (   (int32_t)cLeftPage > 0
     155                            RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)((OP_TYPE *)&puSrc1Mem[off], puSrc2Mem[off], &uEFlags);
     156                            off++;
     157                        } while (   off < cLeftPage
    162158                                 && (uEFlags & X86_EFL_ZF));
     159                        uSrc1AddrReg += cbIncr * off;
     160                        uSrc2AddrReg += cbIncr * off;
     161                        uCounterReg  -= off;
    163162                    }
     163
     164                    /* Update the registers before looping. */
     165                    pCtx->ADDR_rCX = uCounterReg;
     166                    pCtx->ADDR_rSI = uSrc1AddrReg;
     167                    pCtx->ADDR_rDI = uSrc2AddrReg;
     168                    pCtx->eflags.u = uEFlags;
     169
     170                    iemMemPageUnmap(pIemCpu, GCPhysSrc1Mem, IEM_ACCESS_DATA_R, puSrc1Mem);
     171                    iemMemPageUnmap(pIemCpu, GCPhysSrc2Mem, IEM_ACCESS_DATA_R, puSrc2Mem);
    164172                    continue;
    165173                }
    166174            }
     175            iemMemPageUnmap(pIemCpu, GCPhysSrc2Mem, IEM_ACCESS_DATA_R, puSrc2Mem);
    167176        }
    168177
    … …  
    177186            rcStrict = RT_CONCAT(iemMemFetchDataU,OP_SIZE)(pIemCpu, &uValue1, iEffSeg, uSrc1AddrReg);
    178187            if (rcStrict != VINF_SUCCESS)
    179                 break;
     188                return rcStrict;
    180189            OP_TYPE uValue2;
    181190            rcStrict = RT_CONCAT(iemMemFetchDataU,OP_SIZE)(pIemCpu, &uValue2, X86_SREG_ES, uSrc2AddrReg);
    182191            if (rcStrict != VINF_SUCCESS)
    183                 break;
     192                return rcStrict;
    184193            RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)(&uValue1, uValue2, &uEFlags);
    185194
    186             uSrc1AddrReg += cbIncr;
    187             uSrc2AddrReg += cbIncr;
    188             uCounterReg--;
     195            pCtx->ADDR_rSI = uSrc1AddrReg += cbIncr;
     196            pCtx->ADDR_rDI = uSrc2AddrReg += cbIncr;
     197            pCtx->ADDR_rCX = --uCounterReg;
     198            pCtx->eflags.u = uEFlags;
    189199            cLeftPage--;
    190200        } while (   (int32_t)cLeftPage > 0
    191201                 && (uEFlags & X86_EFL_ZF));
    192         if (rcStrict != VINF_SUCCESS)
    193             break;
    194202    } while (   uCounterReg != 0
    195203             && (uEFlags & X86_EFL_ZF));
    196204
    197205    /*
    198      * Update the registers.
    199      */
    200     pCtx->ADDR_rCX = uCounterReg;
    201     pCtx->ADDR_rSI = uSrc1AddrReg;
    202     pCtx->ADDR_rDI = uSrc2AddrReg;
    203     pCtx->eflags.u = uEFlags;
    204     if (rcStrict == VINF_SUCCESS)
    205         iemRegAddToRip(pIemCpu, cbInstr);
    206 
    207     return rcStrict;
     206     * Done.
     207     */
     208    iemRegAddToRip(pIemCpu, cbInstr);
     209    return VINF_SUCCESS;
    208210}
    209211
    … …  
    274276            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtSrc1Addr, IEM_ACCESS_DATA_R, &GCPhysSrc1Mem);
    275277            if (rcStrict != VINF_SUCCESS)
    276                 break;
     278                return rcStrict;
    277279
    278280            RTGCPHYS GCPhysSrc2Mem;
    279281            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtSrc2Addr, IEM_ACCESS_DATA_R, &GCPhysSrc2Mem);
    280282            if (rcStrict != VINF_SUCCESS)
    281                 break;
     283                return rcStrict;
    282284
    283285            /*
    … …  
    295297                    if (memcmp(puSrc2Mem, puSrc1Mem, cLeftPage * (OP_SIZE / 8)))
    296298                    {
    297                         /* All matches, only compare the last itme to get the right eflags. */
     299                        /* All matches, only compare the last item to get the right eflags. */
    298300                        RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)((OP_TYPE *)&puSrc1Mem[cLeftPage-1], puSrc2Mem[cLeftPage-1], &uEFlags);
    299301                        uSrc1AddrReg += cLeftPage * cbIncr;
    300302                        uSrc2AddrReg += cLeftPage * cbIncr;
    301                         uCounterReg -= cLeftPage;
     303                        uCounterReg  -= cLeftPage;
    302304                    }
    303305                    else
    … …  
    305307                        /* Some mismatch, compare each item (and keep volatile
    306308                           memory in mind). */
     309                        uint32_t off = 0;
    307310                        do
    308311                        {
    309                             RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)((OP_TYPE *)puSrc1Mem, *puSrc2Mem, &uEFlags);
    310                             uSrc1AddrReg += cbIncr;
    311                             uSrc2AddrReg += cbIncr;
    312                             uCounterReg--;
    313                             puSrc1Mem++;
    314                             puSrc2Mem++;
    315                             cLeftPage--;
    316                         } while (   (int32_t)cLeftPage > 0
     312                            RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)((OP_TYPE *)&puSrc1Mem[off], puSrc2Mem[off], &uEFlags);
     313                            off++;
     314                        } while (   off < cLeftPage
    317315                                 && !(uEFlags & X86_EFL_ZF));
     316                        uSrc1AddrReg += cbIncr * off;
     317                        uSrc2AddrReg += cbIncr * off;
     318                        uCounterReg  -= off;
    318319                    }
     320
     321                    /* Update the registers before looping. */
     322                    pCtx->ADDR_rCX = uCounterReg;
     323                    pCtx->ADDR_rSI = uSrc1AddrReg;
     324                    pCtx->ADDR_rDI = uSrc2AddrReg;
     325                    pCtx->eflags.u = uEFlags;
     326
     327                    iemMemPageUnmap(pIemCpu, GCPhysSrc1Mem, IEM_ACCESS_DATA_R, puSrc1Mem);
     328                    iemMemPageUnmap(pIemCpu, GCPhysSrc2Mem, IEM_ACCESS_DATA_R, puSrc2Mem);
    319329                    continue;
    320330                }
     331                iemMemPageUnmap(pIemCpu, GCPhysSrc2Mem, IEM_ACCESS_DATA_R, puSrc2Mem);
    321332            }
    322333        }
    … …  
    332343            rcStrict = RT_CONCAT(iemMemFetchDataU,OP_SIZE)(pIemCpu, &uValue1, iEffSeg, uSrc1AddrReg);
    333344            if (rcStrict != VINF_SUCCESS)
    334                 break;
     345                return rcStrict;
    335346            OP_TYPE uValue2;
    336347            rcStrict = RT_CONCAT(iemMemFetchDataU,OP_SIZE)(pIemCpu, &uValue2, X86_SREG_ES, uSrc2AddrReg);
    337348            if (rcStrict != VINF_SUCCESS)
    338                 break;
     349                return rcStrict;
    339350            RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)(&uValue1, uValue2, &uEFlags);
    340351
    341             uSrc1AddrReg += cbIncr;
    342             uSrc2AddrReg += cbIncr;
    343             uCounterReg--;
     352            pCtx->ADDR_rSI = uSrc1AddrReg += cbIncr;
     353            pCtx->ADDR_rDI = uSrc2AddrReg += cbIncr;
     354            pCtx->ADDR_rCX = --uCounterReg;
     355            pCtx->eflags.u = uEFlags;
    344356            cLeftPage--;
    345357        } while (   (int32_t)cLeftPage > 0
    346358                 && !(uEFlags & X86_EFL_ZF));
    347         if (rcStrict != VINF_SUCCESS)
    348             break;
    349359    } while (   uCounterReg != 0
    350360             && !(uEFlags & X86_EFL_ZF));
    351361
    352362    /*
    353      * Update the registers.
    354      */
    355     pCtx->ADDR_rCX = uCounterReg;
    356     pCtx->ADDR_rSI = uSrc1AddrReg;
    357     pCtx->ADDR_rDI = uSrc2AddrReg;
    358     pCtx->eflags.u = uEFlags;
    359     if (rcStrict == VINF_SUCCESS)
    360         iemRegAddToRip(pIemCpu, cbInstr);
    361 
    362     return rcStrict;
     363     * Done.
     364     */
     365    iemRegAddToRip(pIemCpu, cbInstr);
     366    return VINF_SUCCESS;
    363367}
    364368
    … …  
    417421            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtAddr, IEM_ACCESS_DATA_R, &GCPhysMem);
    418422            if (rcStrict != VINF_SUCCESS)
    419                 break;
     423                return rcStrict;
    420424
    421425            /*
    … …  
    439443                /* Update the regs. */
    440444                RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)((OP_TYPE *)&uValueReg, uTmpValue, &uEFlags);
    441                 uCounterReg -= i;
    442                 uAddrReg    += i * cbIncr;
     445                pCtx->ADDR_rCX = uCounterReg -= i;
     446                pCtx->ADDR_rDI = uAddrReg    += i * cbIncr;
     447                pCtx->eflags.u = uEFlags;
    443448                Assert(!(uEFlags & X86_EFL_ZF) == (i < cLeftPage));
     449                iemMemPageUnmap(pIemCpu, GCPhysMem, IEM_ACCESS_DATA_R, puMem);
    444450                if (fQuit)
    445451                    break;
    … …  
    466472            rcStrict = RT_CONCAT(iemMemFetchDataU,OP_SIZE)(pIemCpu, &uTmpValue, X86_SREG_ES, uAddrReg);
    467473            if (rcStrict != VINF_SUCCESS)
    468                 break;
     474                return rcStrict;
    469475            RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)((OP_TYPE *)&uValueReg, uTmpValue, &uEFlags);
    470476
    471             uAddrReg += cbIncr;
    472             uCounterReg--;
     477            pCtx->ADDR_rDI = uAddrReg += cbIncr;
     478            pCtx->ADDR_rCX = --uCounterReg;
     479            pCtx->eflags.u = uEFlags;
    473480            cLeftPage--;
    474481        } while (   (int32_t)cLeftPage > 0
    475482                 && (uEFlags & X86_EFL_ZF));
    476         if (rcStrict != VINF_SUCCESS)
    477             break;
    478483    } while (   uCounterReg != 0
    479484             && (uEFlags & X86_EFL_ZF));
    480485
    481486    /*
    482      * Update the registers.
    483      */
    484     pCtx->ADDR_rCX = uCounterReg;
    485     pCtx->ADDR_rDI = uAddrReg;
    486     pCtx->eflags.u = uEFlags;
    487     if (rcStrict == VINF_SUCCESS)
    488         iemRegAddToRip(pIemCpu, cbInstr);
    489 
    490     return rcStrict;
     487     * Done.
     488     */
     489    iemRegAddToRip(pIemCpu, cbInstr);
     490    return VINF_SUCCESS;
    491491}
    492492
    … …  
    545545            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtAddr, IEM_ACCESS_DATA_R, &GCPhysMem);
    546546            if (rcStrict != VINF_SUCCESS)
    547                 break;
     547                return rcStrict;
    548548
    549549            /*
    … …  
    567567                /* Update the regs. */
    568568                RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)((OP_TYPE *)&uValueReg, uTmpValue, &uEFlags);
    569                 uCounterReg -= i;
    570                 uAddrReg    += i * cbIncr;
     569                pCtx->ADDR_rCX = uCounterReg -= i;
     570                pCtx->ADDR_rDI = uAddrReg    += i * cbIncr;
     571                pCtx->eflags.u = uEFlags;
    571572                Assert((!(uEFlags & X86_EFL_ZF) != (i < cLeftPage)) || (i == cLeftPage));
     573                iemMemPageUnmap(pIemCpu, GCPhysMem, IEM_ACCESS_DATA_R, puMem);
    572574                if (fQuit)
    573575                    break;
    … …  
    594596            rcStrict = RT_CONCAT(iemMemFetchDataU,OP_SIZE)(pIemCpu, &uTmpValue, X86_SREG_ES, uAddrReg);
    595597            if (rcStrict != VINF_SUCCESS)
    596                 break;
     598                return rcStrict;
    597599            RT_CONCAT(iemAImpl_cmp_u,OP_SIZE)((OP_TYPE *)&uValueReg, uTmpValue, &uEFlags);
    598600
    599             uAddrReg += cbIncr;
    600             uCounterReg--;
     601            pCtx->ADDR_rDI = uAddrReg += cbIncr;
     602            pCtx->ADDR_rCX = --uCounterReg;
     603            pCtx->eflags.u = uEFlags;
    601604            cLeftPage--;
    602605        } while (   (int32_t)cLeftPage > 0
    603606                 && !(uEFlags & X86_EFL_ZF));
    604         if (rcStrict != VINF_SUCCESS)
    605             break;
    606607    } while (   uCounterReg != 0
    607608             && !(uEFlags & X86_EFL_ZF));
    608609
    609610    /*
    610      * Update the registers.
    611      */
    612     pCtx->ADDR_rCX = uCounterReg;
    613     pCtx->ADDR_rDI = uAddrReg;
    614     pCtx->eflags.u = uEFlags;
    615     if (rcStrict == VINF_SUCCESS)
    616         iemRegAddToRip(pIemCpu, cbInstr);
    617 
    618     return rcStrict;
     611     * Done.
     612     */
     613    iemRegAddToRip(pIemCpu, cbInstr);
     614    return VINF_SUCCESS;
    619615}
    620616
    … …  
    686682            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtSrcAddr, IEM_ACCESS_DATA_R, &GCPhysSrcMem);
    687683            if (rcStrict != VINF_SUCCESS)
    688                 break;
     684                return rcStrict;
    689685
    690686            RTGCPHYS GCPhysDstMem;
    691687            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtDstAddr, IEM_ACCESS_DATA_W, &GCPhysDstMem);
    692688            if (rcStrict != VINF_SUCCESS)
    693                 break;
     689                return rcStrict;
    694690
    695691            /*
    … …  
    709705
    710706                    /* Update the registers. */
    711                     uSrcAddrReg += cLeftPage * cbIncr;
    712                     uDstAddrReg += cLeftPage * cbIncr;
    713                     uCounterReg -= cLeftPage;
     707                    pCtx->ADDR_rSI = uSrcAddrReg += cLeftPage * cbIncr;
     708                    pCtx->ADDR_rDI = uDstAddrReg += cLeftPage * cbIncr;
     709                    pCtx->ADDR_rCX = uCounterReg -= cLeftPage;
     710
     711                    iemMemPageUnmap(pIemCpu, GCPhysSrcMem, IEM_ACCESS_DATA_R, puSrcMem);
     712                    iemMemPageUnmap(pIemCpu, GCPhysDstMem, IEM_ACCESS_DATA_W, puDstMem);
    714713                    continue;
    715714                }
     715                iemMemPageUnmap(pIemCpu, GCPhysDstMem, IEM_ACCESS_DATA_W, puDstMem);
    716716            }
    717717        }
    … …  
    727727            rcStrict = RT_CONCAT(iemMemFetchDataU,OP_SIZE)(pIemCpu, &uValue, iEffSeg, uSrcAddrReg);
    728728            if (rcStrict != VINF_SUCCESS)
    729                 break;
     729                return rcStrict;
    730730            rcStrict = RT_CONCAT(iemMemStoreDataU,OP_SIZE)(pIemCpu, X86_SREG_ES, uDstAddrReg, uValue);
    731731            if (rcStrict != VINF_SUCCESS)
    732                 break;
    733 
    734             uSrcAddrReg += cbIncr;
    735             uDstAddrReg += cbIncr;
    736             uCounterReg--;
     732                return rcStrict;
     733
     734            pCtx->ADDR_rSI = uSrcAddrReg += cbIncr;
     735            pCtx->ADDR_rDI = uDstAddrReg += cbIncr;
     736            pCtx->ADDR_rCX = --uCounterReg;
    737737            cLeftPage--;
    738738        } while ((int32_t)cLeftPage > 0);
    739         if (rcStrict != VINF_SUCCESS)
    740             break;
    741739    } while (uCounterReg != 0);
    742740
    743741    /*
    744      * Update the registers.
    745      */
    746     pCtx->ADDR_rCX = uCounterReg;
    747     pCtx->ADDR_rDI = uDstAddrReg;
    748     pCtx->ADDR_rSI = uSrcAddrReg;
    749     if (rcStrict == VINF_SUCCESS)
    750         iemRegAddToRip(pIemCpu, cbInstr);
    751 
    752     return rcStrict;
     742     * Done.
     743     */
     744    iemRegAddToRip(pIemCpu, cbInstr);
     745    return VINF_SUCCESS;
    753746}
    754747
    … …  
    806799            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtAddr, IEM_ACCESS_DATA_W, &GCPhysMem);
    807800            if (rcStrict != VINF_SUCCESS)
    808                 break;
     801                return rcStrict;
    809802
    810803            /*
    … …  
    817810            {
    818811                /* Update the regs first so we can loop on cLeftPage. */
    819                 uCounterReg -= cLeftPage;
    820                 uAddrReg    += cLeftPage * cbIncr;
     812                pCtx->ADDR_rCX = uCounterReg -= cLeftPage;
     813                pCtx->ADDR_rDI = uAddrReg    += cLeftPage * cbIncr;
    821814
    822815                /* Do the memsetting. */
    … …  
    829822                    *puMem++ = uValue;
    830823#endif
     824
     825                iemMemPageUnmap(pIemCpu, GCPhysMem, IEM_ACCESS_DATA_W, puMem);
    831826
    832827                /* If unaligned, we drop thru and do the page crossing access
    … …  
    849844            rcStrict = RT_CONCAT(iemMemStoreDataU,OP_SIZE)(pIemCpu, X86_SREG_ES, uAddrReg, uValue);
    850845            if (rcStrict != VINF_SUCCESS)
    851                 break;
    852             uAddrReg += cbIncr;
    853             uCounterReg--;
     846                return rcStrict;
     847            pCtx->ADDR_rDI = uAddrReg += cbIncr;
     848            pCtx->ADDR_rCX = --uCounterReg;
    854849            cLeftPage--;
    855850        } while ((int32_t)cLeftPage > 0);
    856         if (rcStrict != VINF_SUCCESS)
    857             break;
    858851    } while (uCounterReg != 0);
    859852
    860853    /*
    861      * Update the registers.
    862      */
    863     pCtx->ADDR_rCX = uCounterReg;
    864     pCtx->ADDR_rDI = uAddrReg;
    865     if (rcStrict == VINF_SUCCESS)
    866         iemRegAddToRip(pIemCpu, cbInstr);
    867 
    868     return rcStrict;
     854     * Done.
     855     */
     856    iemRegAddToRip(pIemCpu, cbInstr);
     857    return VINF_SUCCESS;
    869858}
    870859
    … …  
    893882
    894883    int8_t const    cbIncr      = pCtx->eflags.Bits.u1DF ? -(OP_SIZE / 8) : (OP_SIZE / 8);
    895     OP_TYPE         uValueReg   = pCtx->OP_rAX;
    896884    ADDR_TYPE       uAddrReg    = pCtx->ADDR_rSI;
    897885
    … …  
    923911            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtAddr, IEM_ACCESS_DATA_R, &GCPhysMem);
    924912            if (rcStrict != VINF_SUCCESS)
    925                 break;
     913                return rcStrict;
    926914
    927915            /*
    … …  
    934922            {
    935923                /* Only get the last byte, the rest doesn't matter in direct access mode. */
    936                 uValueReg = puMem[cLeftPage - 1];
    937 
    938                 /* Update the regs. */
    939                 uCounterReg -= cLeftPage;
    940                 uAddrReg    += cLeftPage * cbIncr;
     924#if OP_SIZE == 32
     925                pCtx->rax      = puMem[cLeftPage - 1];
     926#else
     927                pCtx->OP_rAX   = puMem[cLeftPage - 1];
     928#endif
     929                pCtx->ADDR_rCX = uCounterReg -= cLeftPage;
     930                pCtx->ADDR_rSI = uAddrReg    += cLeftPage * cbIncr;
     931                iemMemPageUnmap(pIemCpu, GCPhysMem, IEM_ACCESS_DATA_R, puMem);
    941932
    942933                /* If unaligned, we drop thru and do the page crossing access
    … …  
    960951            rcStrict = RT_CONCAT(iemMemFetchDataU,OP_SIZE)(pIemCpu, &uTmpValue, iEffSeg, uAddrReg);
    961952            if (rcStrict != VINF_SUCCESS)
    962                 break;
    963             uValueReg = uTmpValue;
    964             uAddrReg += cbIncr;
    965             uCounterReg--;
     953                return rcStrict;
     954#if OP_SIZE == 32
     955            pCtx->rax      = uTmpValue;
     956#else
     957            pCtx->OP_rAX   = uTmpValue;
     958#endif
     959            pCtx->ADDR_rSI = uAddrReg += cbIncr;
     960            pCtx->ADDR_rCX = --uCounterReg;
    966961            cLeftPage--;
    967962        } while ((int32_t)cLeftPage > 0);
    … …  
    971966
    972967    /*
    973      * Update the registers.
    974      */
    975     pCtx->ADDR_rCX = uCounterReg;
    976     pCtx->ADDR_rDI = uAddrReg;
    977 #if OP_SIZE == 32
    978     pCtx->rax     = uValueReg;
    979 #else
    980     pCtx->OP_rAX  = uValueReg;
    981 #endif
    982     if (rcStrict == VINF_SUCCESS)
    983         iemRegAddToRip(pIemCpu, cbInstr);
    984 
    985     return rcStrict;
     968     * Done.
     969     */
     970    iemRegAddToRip(pIemCpu, cbInstr);
     971    return VINF_SUCCESS;
    986972}
    987973
    … …  
    10331019           we fail with an internal error here instead. */
    10341020        else
    1035             AssertLogRelFailedReturn(VERR_INTERNAL_ERROR_3);
     1021            AssertLogRelFailedReturn(VERR_IEM_IPE_1);
    10361022    }
    10371023    return rcStrict;
    … …  
    10961082            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtAddr, IEM_ACCESS_DATA_W, &GCPhysMem);
    10971083            if (rcStrict != VINF_SUCCESS)
    1098                 break;
     1084                return rcStrict;
    10991085
    11001086            /*
    … …  
    11111097            if (rcStrict == VINF_SUCCESS)
    11121098            {
    1113                 while (cLeftPage-- > 0)
     1099                uint32_t off = 0;
     1100                while (off < cLeftPage)
    11141101                {
    11151102                    uint32_t u32Value;
    … …  
    11181105                    else
    11191106                        rcStrict = iemVerifyFakeIOPortRead(pIemCpu, u16Port, &u32Value, OP_SIZE / 8);
    1120                     if (!IOM_SUCCESS(rcStrict))
    1121                         break;
    1122                     *puMem++     = (OP_TYPE)u32Value;
    1123                     uAddrReg    += cbIncr;
    1124                     uCounterReg -= 1;
    1125 
     1107                    if (IOM_SUCCESS(rcStrict))
     1108                    {
     1109                        puMem[off]     = (OP_TYPE)u32Value;
     1110                        pCtx->ADDR_rDI = uAddrReg += cbIncr;
     1111                        pCtx->ADDR_rCX = --uCounterReg;
     1112                    }
    11261113                    if (rcStrict != VINF_SUCCESS)
    11271114                    {
    11281115                        /** @todo massage rc */
    1129                         break;
     1116                        if (uCounterReg == 0)
     1117                            iemRegAddToRip(pIemCpu, cbInstr);
     1118                        iemMemPageUnmap(pIemCpu, GCPhysMem, IEM_ACCESS_DATA_W, puMem);
     1119                        return rcStrict;
    11301120                    }
     1121                    off++;
    11311122                }
    1132                 if (rcStrict != VINF_SUCCESS)
    1133                     break;
     1123                iemMemPageUnmap(pIemCpu, GCPhysMem, IEM_ACCESS_DATA_W, puMem);
    11341124
    11351125                /* If unaligned, we drop thru and do the page crossing access
    … …  
    11581148            rcStrict = iemMemMap(pIemCpu, (void **)&puMem, OP_SIZE / 8, X86_SREG_ES, uAddrReg, IEM_ACCESS_DATA_W);
    11591149            if (rcStrict != VINF_SUCCESS)
    1160                 break;
     1150                return rcStrict;
    11611151
    11621152            uint32_t u32Value;
    … …  
    11661156                rcStrict = iemVerifyFakeIOPortRead(pIemCpu, u16Port, &u32Value, OP_SIZE / 8);
    11671157            if (!IOM_SUCCESS(rcStrict))
    1168                 break;
    1169 
     1158                return rcStrict;
     1159
     1160            *puMem = u32Value;
    11701161            VBOXSTRICTRC rcStrict2 = iemMemCommitAndUnmap(pIemCpu, puMem, IEM_ACCESS_DATA_W);
    1171             AssertLogRelBreakStmt(rcStrict2 == VINF_SUCCESS, rcStrict = VERR_INTERNAL_ERROR_3); /* See non-rep version. */
    1172 
    1173             uAddrReg += cbIncr;
    1174             uCounterReg--;
     1162            AssertLogRelReturn(rcStrict2 == VINF_SUCCESS, VERR_IEM_IPE_1); /* See non-rep version. */
     1163
     1164            pCtx->ADDR_rDI = uAddrReg += cbIncr;
     1165            pCtx->ADDR_rCX = --uCounterReg;
     1166
    11751167            cLeftPage--;
    11761168            if (rcStrict != VINF_SUCCESS)
    11771169            {
    11781170                /** @todo massage IOM status codes! */
    1179                 break;
     1171                if (uCounterReg == 0)
     1172                    iemRegAddToRip(pIemCpu, cbInstr);
     1173                return rcStrict;
    11801174            }
    11811175        } while ((int32_t)cLeftPage > 0);
    1182         if (rcStrict != VINF_SUCCESS)
    1183             break;
    11841176    } while (uCounterReg != 0);
    11851177
    11861178    /*
    1187      * Update the registers.
    1188      */
    1189     pCtx->ADDR_rCX = uCounterReg;
    1190     pCtx->ADDR_rDI = uAddrReg;
    1191     if (rcStrict == VINF_SUCCESS)
    1192         iemRegAddToRip(pIemCpu, cbInstr);
    1193 
    1194     return rcStrict;
     1179     * Done.
     1180     */
     1181    iemRegAddToRip(pIemCpu, cbInstr);
     1182    return VINF_SUCCESS;
    11951183}
    11961184
    … …  
    12941282            rcStrict = iemMemPageTranslateAndCheckAccess(pIemCpu, uVirtAddr, IEM_ACCESS_DATA_R, &GCPhysMem);
    12951283            if (rcStrict != VINF_SUCCESS)
    1296                 break;
     1284                return rcStrict;
    12971285
    12981286            /*
    … …  
    13091297            if (rcStrict == VINF_SUCCESS)
    13101298            {
    1311                 while (cLeftPage-- > 0)
     1299                uint32_t off = 0;
     1300                while (off < cLeftPage)
    13121301                {
    13131302                    uint32_t u32Value = *puMem++;
    … …  
    13161305                    else
    13171306                        rcStrict = iemVerifyFakeIOPortWrite(pIemCpu, u16Port, u32Value, OP_SIZE / 8);
    1318                     if (!IOM_SUCCESS(rcStrict))
    1319                         break;
    1320                     uAddrReg    += cbIncr;
    1321                     uCounterReg -= 1;
    1322 
     1307                    if (IOM_SUCCESS(rcStrict))
     1308                    {
     1309                        pCtx->ADDR_rSI = uAddrReg += cbIncr;
     1310                        pCtx->ADDR_rCX = --uCounterReg;
     1311                    }
    13231312                    if (rcStrict != VINF_SUCCESS)
    13241313                    {
    13251314                        /** @todo massage IOM rc */
    1326                         break;
     1315                        if (uCounterReg == 0)
     1316                            iemRegAddToRip(pIemCpu, cbInstr);
     1317                        iemMemPageUnmap(pIemCpu, GCPhysMem, IEM_ACCESS_DATA_R, puMem);
     1318                        return rcStrict;
    13271319                    }
     1320                    off++;
    13281321                }
    1329                 if (rcStrict != VINF_SUCCESS)
    1330                     break;
     1322                iemMemPageUnmap(pIemCpu, GCPhysMem, IEM_ACCESS_DATA_R, puMem);
    13311323
    13321324                /* If unaligned, we drop thru and do the page crossing access
    … …  
    13551347            rcStrict = RT_CONCAT(iemMemFetchDataU,OP_SIZE)(pIemCpu, &uValue, iEffSeg, uAddrReg);
    13561348            if (rcStrict != VINF_SUCCESS)
    1357                 break;
     1349                return rcStrict;
    13581350
    13591351            if (!IEM_VERIFICATION_ENABLED(pIemCpu))
    … …  
    13611353            else
    13621354                rcStrict = iemVerifyFakeIOPortWrite(pIemCpu, u16Port, uValue, OP_SIZE / 8);
    1363             if (!IOM_SUCCESS(rcStrict))
    1364                 break;
    1365 
    1366             uAddrReg += cbIncr;
    1367             uCounterReg--;
    1368             cLeftPage--;
     1355            if (IOM_SUCCESS(rcStrict))
     1356            {
     1357                pCtx->ADDR_rSI = uAddrReg += cbIncr;
     1358                pCtx->ADDR_rCX = --uCounterReg;
     1359                cLeftPage--;
     1360            }
    13691361            if (rcStrict != VINF_SUCCESS)
    13701362            {
    13711363                /** @todo massage IOM status codes! */
    1372                 break;
     1364                if (uCounterReg == 0)
     1365                    iemRegAddToRip(pIemCpu, cbInstr);
     1366                return rcStrict;
    13731367            }
    13741368        } while ((int32_t)cLeftPage > 0);
    1375         if (rcStrict != VINF_SUCCESS)
    1376             break;
    13771369    } while (uCounterReg != 0);
    13781370
    13791371    /*
    1380      * Update the registers.
    1381      */
    1382     pCtx->ADDR_rCX = uCounterReg;
    1383     pCtx->ADDR_rSI = uAddrReg;
    1384     if (rcStrict == VINF_SUCCESS)
    1385         iemRegAddToRip(pIemCpu, cbInstr);
    1386 
    1387     return rcStrict;
     1372     * Done.
     1373     */
     1374    iemRegAddToRip(pIemCpu, cbInstr);
     1375    return VINF_SUCCESS;
    13881376}
    13891377
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