VirtualBox

Changeset 41732 in vbox for trunk/src/VBox/Disassembler


Ignore:
Timestamp:
Jun 14, 2012 11:57:45 PM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
78540
Message:

DISCPUSTATE::opsize -> cbInstr.

Location:
trunk/src/VBox/Disassembler
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r41731 r41732  
    231231 * @param   pcbInstr        Where to store the size of the instruction.
    232232 *                          NULL is allowed.  This is also stored in
    233  *                          PDISCPUSTATE::opsize.
     233 *                          PDISCPUSTATE::cbInstr.
    234234 */
    235235DISDECL(int) DISInstr(const void *pvInstr, DISCPUMODE enmCpuMode, PDISCPUSTATE pCpu, uint32_t *pcbInstr)
    … …  
    253253 * @param   pcbInstr        Where to store the size of the instruction.
    254254 *                          NULL is allowed.  This is also stored in
    255  *                          PDISCPUSTATE::opsize.
     255 *                          PDISCPUSTATE::cbInstr.
    256256 */
    257257DISDECL(int) DISInstrWithReader(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, PFNDISREADBYTES pfnReadBytes, void *pvUser,
    … …  
    277277 *                          taken from it.
    278278 * @param   pcbInstr        Where to store the size of the instruction.  (This
    279  *                          is also stored in PDISCPUSTATE::opsize.)  Optional.
     279 *                          is also stored in PDISCPUSTATE::cbInstr.)  Optional.
    280280 */
    281281DISDECL(int) DISInstEx(RTUINTPTR uInstrAddr, DISCPUMODE enmCpuMode, uint32_t fFilter,
    … …  
    433433    }
    434434
    435     AssertMsg(pCpu->opsize == iByte || RT_FAILURE_NP(pCpu->rc), ("%u %u\n", pCpu->opsize, iByte));
    436     pCpu->opsize = iByte;
     435    AssertMsg(pCpu->cbInstr == iByte || RT_FAILURE_NP(pCpu->rc), ("%u %u\n", pCpu->cbInstr, iByte));
     436    pCpu->cbInstr = iByte;
    437437    if (pcbInstr)
    438438        *pcbInstr = iByte;
    … …  
    24142414     * Figure out which case it is.
    24152415     */
    2416     uint32_t  cbInstr = pCpu->opsize;
     2416    uint32_t  cbInstr = pCpu->cbInstr;
    24172417    RTUINTPTR off     = uAddress - pCpu->uInstrAddr;
    24182418    if (off < cbInstr)
    … …  
    24502450            RT_BZERO(&pCpu->abInstr[cbInstr], cbGap);
    24512451        }
    2452         pCpu->opsize = cbInstr = off;
     2452        pCpu->cbInstr = cbInstr = off;
    24532453    }
    24542454
    … …  
    24592459    {
    24602460        memcpy(&pCpu->abInstr[cbInstr], pbSrc, cbSrc);
    2461         pCpu->opsize = cbInstr + (uint32_t)cbSrc;
     2461        pCpu->cbInstr = cbInstr + (uint32_t)cbSrc;
    24622462    }
    24632463    else
    … …  
    24652465        size_t cbToCopy = sizeof(pCpu->abInstr) - off;
    24662466        memcpy(&pCpu->abInstr[cbInstr], pbSrc, cbToCopy);
    2467         pCpu->opsize = sizeof(pCpu->abInstr);
     2467        pCpu->cbInstr = sizeof(pCpu->abInstr);
    24682468        AssertMsgFailed(("%RTptr LB %zx off=%RTptr (%.*Rhxs)", uAddress, cbSrc, off, sizeof(pCpu->abInstr), pCpu->abInstr));
    24692469    }
    … …  
    24972497/** @todo change this into reading directly into abInstr and use it as a
    24982498 *        cache. */
    2499     if (RT_LIKELY(   pCpu->uInstrAddr + pCpu->opsize == uAddress
    2500                   && pCpu->opsize + sizeof(bTemp) < sizeof(pCpu->abInstr)))
    2501         pCpu->abInstr[pCpu->opsize++] = bTemp;
     2499    if (RT_LIKELY(   pCpu->uInstrAddr + pCpu->cbInstr == uAddress
     2500                  && pCpu->cbInstr + sizeof(bTemp) < sizeof(pCpu->abInstr)))
     2501        pCpu->abInstr[pCpu->cbInstr++] = bTemp;
    25022502    else
    25032503        disStoreInstrBytesSlow(pCpu, uAddress, &bTemp, sizeof(bTemp));
    … …  
    25182518    }
    25192519
    2520     if (RT_LIKELY(   pCpu->uInstrAddr + pCpu->opsize == uAddress
    2521                   && pCpu->opsize + sizeof(uTemp) < sizeof(pCpu->abInstr)))
    2522     {
    2523         pCpu->abInstr[pCpu->opsize    ] = uTemp.au8[0];
    2524         pCpu->abInstr[pCpu->opsize + 1] = uTemp.au8[1];
    2525         pCpu->opsize += 2;
     2520    if (RT_LIKELY(   pCpu->uInstrAddr + pCpu->cbInstr == uAddress
     2521                  && pCpu->cbInstr + sizeof(uTemp) < sizeof(pCpu->abInstr)))
     2522    {
     2523        pCpu->abInstr[pCpu->cbInstr    ] = uTemp.au8[0];
     2524        pCpu->abInstr[pCpu->cbInstr + 1] = uTemp.au8[1];
     2525        pCpu->cbInstr += 2;
    25262526    }
    25272527    else
    … …  
    25432543    }
    25442544
    2545     if (RT_LIKELY(   pCpu->uInstrAddr + pCpu->opsize == uAddress
    2546                   && pCpu->opsize + sizeof(uTemp) < sizeof(pCpu->abInstr)))
    2547     {
    2548         pCpu->abInstr[pCpu->opsize    ] = uTemp.au8[0];
    2549         pCpu->abInstr[pCpu->opsize + 1] = uTemp.au8[1];
    2550         pCpu->abInstr[pCpu->opsize + 2] = uTemp.au8[2];
    2551         pCpu->abInstr[pCpu->opsize + 3] = uTemp.au8[3];
    2552         pCpu->opsize += 4;
     2545    if (RT_LIKELY(   pCpu->uInstrAddr + pCpu->cbInstr == uAddress
     2546                  && pCpu->cbInstr + sizeof(uTemp) < sizeof(pCpu->abInstr)))
     2547    {
     2548        pCpu->abInstr[pCpu->cbInstr    ] = uTemp.au8[0];
     2549        pCpu->abInstr[pCpu->cbInstr + 1] = uTemp.au8[1];
     2550        pCpu->abInstr[pCpu->cbInstr + 2] = uTemp.au8[2];
     2551        pCpu->abInstr[pCpu->cbInstr + 3] = uTemp.au8[3];
     2552        pCpu->cbInstr += 4;
    25532553    }
    25542554    else
    … …  
    25702570    }
    25712571
    2572     if (RT_LIKELY(   pCpu->uInstrAddr + pCpu->opsize == uAddress
    2573                   && pCpu->opsize + sizeof(uTemp) < sizeof(pCpu->abInstr)))
    2574     {
    2575         pCpu->abInstr[pCpu->opsize    ] = uTemp.au8[0];
    2576         pCpu->abInstr[pCpu->opsize + 1] = uTemp.au8[1];
    2577         pCpu->abInstr[pCpu->opsize + 2] = uTemp.au8[2];
    2578         pCpu->abInstr[pCpu->opsize + 3] = uTemp.au8[3];
    2579         pCpu->abInstr[pCpu->opsize + 4] = uTemp.au8[4];
    2580         pCpu->abInstr[pCpu->opsize + 5] = uTemp.au8[5];
    2581         pCpu->abInstr[pCpu->opsize + 6] = uTemp.au8[6];
    2582         pCpu->abInstr[pCpu->opsize + 7] = uTemp.au8[7];
    2583         pCpu->opsize += 8;
     2572    if (RT_LIKELY(   pCpu->uInstrAddr + pCpu->cbInstr == uAddress
     2573                  && pCpu->cbInstr + sizeof(uTemp) < sizeof(pCpu->abInstr)))
     2574    {
     2575        pCpu->abInstr[pCpu->cbInstr    ] = uTemp.au8[0];
     2576        pCpu->abInstr[pCpu->cbInstr + 1] = uTemp.au8[1];
     2577        pCpu->abInstr[pCpu->cbInstr + 2] = uTemp.au8[2];
     2578        pCpu->abInstr[pCpu->cbInstr + 3] = uTemp.au8[3];
     2579        pCpu->abInstr[pCpu->cbInstr + 4] = uTemp.au8[4];
     2580        pCpu->abInstr[pCpu->cbInstr + 5] = uTemp.au8[5];
     2581        pCpu->abInstr[pCpu->cbInstr + 6] = uTemp.au8[6];
     2582        pCpu->abInstr[pCpu->cbInstr + 7] = uTemp.au8[7];
     2583        pCpu->cbInstr += 8;
    25842584    }
    25852585    else

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

    r41658 r41732  
    3939{
    4040    size_t      cchOutput = 0;
    41     uint32_t    cb        = pCpu->opsize;
     41    uint32_t    cb        = pCpu->cbInstr;
    4242    AssertStmt(cb <= 16, cb = 16);
    4343

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

    r41730 r41732  
    500500                else if (pCpu->opcode == 0x1f)
    501501                {
    502                     Assert(pCpu->opsize >= 3);
     502                    Assert(pCpu->cbInstr >= 3);
    503503                    PUT_SZ("db 00fh, 01fh,");
    504504                    PUT_NUM_8(pCpu->ModRM.u);
    505                     for (unsigned i = 3; i < pCpu->opsize; i++)
     505                    for (unsigned i = 3; i < pCpu->cbInstr; i++)
    506506                    {
    507507                        PUT_C(',');
    … …  
    907907                            PUT_SZ(" (");
    908908
    909                         RTUINTPTR uTrgAddr = pCpu->uInstrAddr + pCpu->opsize + offDisplacement;
     909                        RTUINTPTR uTrgAddr = pCpu->uInstrAddr + pCpu->cbInstr + offDisplacement;
    910910                        if (pCpu->mode == DISCPUMODE_16BIT)
    911911                            PUT_NUM_16(uTrgAddr);

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

    r41729 r41732  
    625625            Assert(pCpu->mode == DISCPUMODE_64BIT);
    626626            /* Relative to the RIP of the next instruction. */
    627             pParamVal->val.val64 += pParam->uDisp.i32 + pCtx->rip + pCpu->opsize;
     627            pParamVal->val.val64 += pParam->uDisp.i32 + pCtx->rip + pCpu->cbInstr;
    628628        }
    629629        return VINF_SUCCESS;

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

    r41718 r41732  
    11/* $Id$ */
    22/** @file
    3  * VBox disassembler - Test application 
     3 * VBox disassembler - Test application
    44 */
    55
    … …  
    4747
    4848        RTTESTI_CHECK_RC(rc, VINF_SUCCESS);
    49         RTTESTI_CHECK(cb == Cpu.opsize);
     49        RTTESTI_CHECK(cb == Cpu.cbInstr);
    5050        RTTESTI_CHECK(cb > 0);
    5151        RTTESTI_CHECK(cb <= 16);
    … …  
    6969        if (cErrBefore != RTTestIErrorCount())
    7070            RTTestIFailureDetails("rc=%Rrc, off=%#x (%u) cbInstr=%u enmDisCpuMode=%d\n",
    71                                   rc, off, Cpu.opsize, enmDisCpuMode);
     71                                  rc, off, Cpu.cbInstr, enmDisCpuMode);
    7272        RTTestIPrintf(RTTESTLVL_ALWAYS, "%s\n", szOutput);
    7373        off += cb;
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