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

Timestamp:

Jun 15, 2012 3:56:20 PM (12 years ago)

Author:

vboxsync

Message:

DIS: Chagned FNDISREADBYTES to permit reading more bytes that the immeidate request. Not using the read-ahead feature in any important code path yet, that's comming next, bit by bit.

Location:

trunk/src/VBox/Disassembler

Files:

• DisasmCore.cpp (modified) (3 diffs)
• testcase/tstDisasm-2.cpp (modified) (3 diffs)

trunk/src/VBox/Disassembler/DisasmCore.cpp

@@ -65 +65 @@
 static uint32_t disReadDWord(PDISCPUSTATE pCpu, RTUINTPTR pAddress);
 static uint64_t disReadQWord(PDISCPUSTATE pCpu, RTUINTPTR pAddress);
-static DECLCALLBACK(int) disReadBytesDefault(PDISCPUSTATE pCpu, uint8_t *pbDst, RTUINTPTR uSrcAddr, uint32_t cbToRead);
+static DECLCALLBACK(int) disReadBytesDefault(PDISCPUSTATE pDis, uint8_t offInstr, uint8_t cbMinRead, uint8_t cbMaxRead);
 
 
@@ -2390 +2390 @@
 
 
-static DECLCALLBACK(int) disReadBytesDefault(PDISCPUSTATE pCpu, uint8_t *pbDst, RTUINTPTR uSrcAddr, uint32_t cbToRead)
+static DECLCALLBACK(int) disReadBytesDefault(PDISCPUSTATE pDis, uint8_t offInstr, uint8_t cbMinRead, uint8_t cbMaxRead)
 {
 #ifdef IN_RING0
     AssertMsgFailed(("disReadWord with no read callback in ring 0!!\n"));
-    RT_BZERO(pbDst, cbToRead);
+    RT_BZERO(&pDis->abInstr[offInstr], cbMaxRead);
+    pDis->cbCachedInstr = offInstr + cbMaxRead;
     return VERR_DIS_NO_READ_CALLBACK;
 #else
-    memcpy(pbDst, (void const *)(uintptr_t)uSrcAddr, cbToRead);
+    memcpy(&pDis->abInstr[offInstr], (uint8_t const *)(uintptr_t)pDis->uInstrAddr + offInstr, cbMaxRead);
+    pDis->cbCachedInstr = offInstr + cbMaxRead;
     return VINF_SUCCESS;
 #endif
@@ -2437 +2439 @@
 
     /*
-     * Do the read.  No need to zero anything, abInstr is already zeroed by the
-     * DISInstrEx API.
+     * Do the read.
+     * (No need to zero anything on failure as abInstr is already zeroed by the
+     * DISInstrEx API.)
      */
-    /** @todo Change the callback API so it can read more, thus avoid lots of
-     *        calls or it doing its own caching. */
-    int rc = pCpu->pfnReadBytes(pCpu, &pCpu->abInstr[off], pCpu->uInstrAddr + off, cbMin);
-    if (RT_FAILURE(rc))
+    int rc = pCpu->pfnReadBytes(pCpu, off, cbMin, sizeof(pCpu->abInstr) - off);
+    if (RT_SUCCESS(rc))
+    {
+        Assert(pCpu->cbCachedInstr >= off + cbMin);
+        Assert(pCpu->cbCachedInstr <= sizeof(pCpu->abInstr));
+    }
+    else
     {
         Log(("disReadMore failed with rc=%Rrc!!\n", rc));
         pCpu->rc = VERR_DIS_MEM_READ;
     }
-    pCpu->cbCachedInstr = off + cbMin;
 }
 

trunk/src/VBox/Disassembler/testcase/tstDisasm-2.cpp

@@ -167 +167 @@
 /**
  * Callback for reading bytes.
- *
- * @todo This should check that the disassembler doesn't do unnecessary reads,
- *       however the current doesn't do this and is just complicated...
- */
-static DECLCALLBACK(int) MyDisasInstrRead(PDISCPUSTATE pDisState, uint8_t *pbDst, RTUINTPTR uSrcAddr, uint32_t cbToRead)
-{
-    PMYDISSTATE pState = (PMYDISSTATE)pDisState;
+ */
+static DECLCALLBACK(int) MyDisasInstrRead(PDISCPUSTATE pDis, uint8_t offInstr, uint8_t cbMinRead, uint8_t cbMaxRead)
+{
+    PMYDISSTATE pState   = (PMYDISSTATE)pDis;
+    RTUINTPTR   uSrcAddr = pState->Cpu.uInstrAddr + offInstr;
     if (RT_LIKELY(   pState->uNextAddr == uSrcAddr
-                  && pState->cbLeft >= cbToRead))
+                  && pState->cbLeft >= cbMinRead))
     {
         /*
          * Straight forward reading.
          */
-        if (cbToRead == 1)
+        //size_t cbToRead    = cbMaxRead;
+        size_t cbToRead    = cbMinRead;
+        memcpy(&pState->Cpu.abInstr[offInstr], pState->pbNext, cbToRead);
+        pState->Cpu.cbCachedInstr = offInstr + cbToRead;
+        pState->pbNext    += cbToRead;
+        pState->cbLeft    -= cbToRead;
+        pState->uNextAddr += cbToRead;
+        return VINF_SUCCESS;
+    }
+
+    if (pState->uNextAddr == uSrcAddr)
+    {
+        /*
+         * Reading too much.
+         */
+        if (pState->cbLeft > 0)
         {
-            pState->cbLeft--;
-            *pbDst = *pState->pbNext++;
-            pState->uNextAddr++;
+            memcpy(&pState->Cpu.abInstr[offInstr], pState->pbNext, pState->cbLeft);
+            offInstr          += (uint8_t)pState->cbLeft;
+            cbMinRead         -= (uint8_t)pState->cbLeft;
+            pState->pbNext    += pState->cbLeft;
+            pState->uNextAddr += pState->cbLeft;
+            pState->cbLeft     = 0;
         }
-        else
-        {
-            memcpy(pbDst, pState->pbNext, cbToRead);
-            pState->pbNext += cbToRead;
-            pState->cbLeft -= cbToRead;
-            pState->uNextAddr += cbToRead;
-        }
+        memset(&pState->Cpu.abInstr[offInstr], 0xcc, cbMinRead);
+        pState->rc = VERR_EOF;
     }
     else
     {
         /*
-         * Jumping up the stream.
-         * This occurs when the byte sequence is added to the output string.
+         * Non-sequential read, that's an error.
          */
-        uint64_t offReq64 = uSrcAddr - pState->uAddress;
-        if (offReq64 < 32)
-        {
-            uint32_t offReq = offReq64;
-            uintptr_t off = pState->pbNext - pState->pbInstr;
-            if (off + pState->cbLeft <= offReq)
-            {
-                pState->pbNext += pState->cbLeft;
-                pState->uNextAddr += pState->cbLeft;
-                pState->cbLeft = 0;
-
-                memset(pbDst, 0xcc, cbToRead);
-                pState->rc = VERR_EOF;
-                return VERR_EOF;
-            }
-
-            /* reset the stream. */
-            pState->cbLeft += off;
-            pState->pbNext = pState->pbInstr;
-            pState->uNextAddr = pState->uAddress;
-
-            /* skip ahead. */
-            pState->cbLeft -= offReq;
-            pState->pbNext += offReq;
-            pState->uNextAddr += offReq;
-
-            /* do the reading. */
-            if (pState->cbLeft >= cbToRead)
-            {
-                memcpy(pbDst, pState->pbNext, cbToRead);
-                pState->cbLeft -= cbToRead;
-                pState->pbNext += cbToRead;
-                pState->uNextAddr += cbToRead;
-            }
-            else
-            {
-                if (pState->cbLeft > 0)
-                {
-                    memcpy(pbDst, pState->pbNext, pState->cbLeft);
-                    pbDst += pState->cbLeft;
-                    cbToRead -= (uint32_t)pState->cbLeft;
-                    pState->pbNext += pState->cbLeft;
-                    pState->uNextAddr += pState->cbLeft;
-                    pState->cbLeft = 0;
-                }
-                memset(pbDst, 0xcc, cbToRead);
-                pState->rc = VERR_EOF;
-                return VERR_EOF;
-            }
-        }
-        else
-        {
-            RTStrmPrintf(g_pStdErr, "Reading before current instruction!\n");
-            memset(pbDst, 0x90, cbToRead);
-            pState->rc = VERR_INTERNAL_ERROR;
-            return VERR_INTERNAL_ERROR;
-        }
-    }
-
-    return VINF_SUCCESS;
+        RTStrmPrintf(g_pStdErr, "Reading before current instruction!\n");
+        memset(&pState->Cpu.abInstr[offInstr], 0x90, cbMinRead);
+        pState->rc = VERR_INTERNAL_ERROR;
+    }
+    pState->Cpu.cbCachedInstr = offInstr + cbMinRead;
+    return pState->rc;
 }
 
@@ -340 +296 @@
                           || State.Cpu.pCurInstr->uOpcode == OP_INVALID
                           || State.Cpu.pCurInstr->uOpcode == OP_ILLUD2
-                          || (    State.enmUndefOp == kUndefOp_DefineByte
+                          || (   State.enmUndefOp == kUndefOp_DefineByte
                               && !MyDisasIsValidInstruction(&State.Cpu));
             if (State.fUndefOp && State.enmUndefOp == kUndefOp_DefineByte)
@@ -347 +303 @@
                 {
                     State.Cpu.abInstr[0] = 0;
-                    State.Cpu.pfnReadBytes(&State.Cpu, &State.Cpu.abInstr[0], State.uAddress, 1);
+                    State.Cpu.pfnReadBytes(&State.Cpu, 0, 1, 1);
                     State.cbInstr = 1;
                 }