Changeset 59747 in vbox

Timestamp:

Feb 19, 2016 11:18:18 PM (9 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

105617

Message:

iprt/asm.h: Cleaned up the ASMMemIsAll8/U32 mess and implmeneted the former in assembly. (Found inverted usage due to bad naming in copyUtf8Block, but it is fortunately an unused method.) Replaces the complicated ASMBitFirstSet based scanning in RTSgBufIsZero with a simple call to the new ASMMemIsZero function.

Location:

trunk

Files:

• include/VBox/intnetinline.h (modified) (1 diff)
• include/iprt/asm.h (modified) (5 diffs)
• include/iprt/mangling.h (modified) (1 diff)
• src/VBox/Debugger/DBGPlugInCommonELFTmpl.cpp.h (modified) (1 diff)
• src/VBox/Debugger/DBGPlugInSolaris.cpp (modified) (2 diffs)
• src/VBox/Devices/BiosCommonCode/MakeAlternativeSource.cpp (modified) (2 diffs)
• src/VBox/Devices/Graphics/DevVGA-SVGA3d-info.cpp (modified) (1 diff)
• src/VBox/HostDrivers/Support/SUPR3HardenedVerify.cpp (modified) (1 diff)
• src/VBox/Main/include/GuestCtrlImplPrivate.h (modified) (1 diff)
• src/VBox/Runtime/Makefile.kmk (modified) (2 diffs)
• src/VBox/Runtime/common/asm/ASMMemFirstMismatchingU8.asm (added)
• src/VBox/Runtime/common/ldr/ldrPE.cpp (modified) (1 diff)
• src/VBox/Runtime/common/math/bignum.cpp (modified) (5 diffs)
• src/VBox/Runtime/common/misc/sg.cpp (modified) (2 diffs)
• src/VBox/Runtime/common/vfs/vfsmemory.cpp (modified) (1 diff)
• src/VBox/Runtime/common/zip/tarvfs.cpp (modified) (1 diff)
• src/VBox/Runtime/r0drv/alloc-ef-r0drv.cpp (modified) (1 diff)
• src/VBox/Runtime/r3/alloc-ef.cpp (modified) (1 diff)
• src/VBox/Runtime/testcase/tstRTInlineAsm.cpp (modified) (3 diffs)
• src/VBox/Runtime/testcase/tstRTMemCache.cpp (modified) (1 diff)
• src/VBox/Runtime/testcase/tstRTMemPool.cpp (modified) (7 diffs)
• src/VBox/Runtime/testcase/tstRTMemSafer.cpp (modified) (1 diff)
• src/VBox/Runtime/testcase/tstRTStrAlloc.cpp (modified) (2 diffs)
• src/VBox/Runtime/testcase/tstRTStrCache.cpp (modified) (4 diffs)
• src/VBox/VMM/VMMAll/MMAllHyper.cpp (modified) (1 diff)
• src/VBox/VMM/VMMR0/GVMMR0.cpp (modified) (1 diff)
• src/VBox/VMM/VMMR3/PGMDbg.cpp (modified) (2 diffs)
• src/VBox/VMM/testcase/tstCompressionBenchmark.cpp (modified) (1 diff)
• src/VBox/ValidationKit/bootsectors/bs3kit/Makefile.kmk (modified) (1 diff)

trunk/include/VBox/intnetinline.h

@@ -794 +794 @@
     Assert(RT_ALIGN_32(cbRecv, INTNETRINGBUF_ALIGNMENT) == cbRecv);
     Assert(RT_ALIGN_32(cbSend, INTNETRINGBUF_ALIGNMENT) == cbSend);
-    Assert(ASMMemIsAll8(pIntBuf, cbBuf, '\0') == NULL);
+    Assert(ASMMemIsZero(pIntBuf, cbBuf));
 
     pIntBuf->u32Magic  = INTNETBUF_MAGIC;

trunk/include/iprt/asm.h

@@ -3833 +3833 @@
 
 /**
+ * Checks if a memory block is all zeros.
+ *
+ * @returns Pointer to the first non-zero byte.
+ * @returns NULL if all zero.
+ *
+ * @param   pv      Pointer to the memory block.
+ * @param   cb      Number of bytes in the block.
+ *
+ * @todo Fix name, it is a predicate function but it's not returning boolean!
+ */
+#if !defined(RT_OS_LINUX) || !defined(__KERNEL__)
+DECLASM(void *) ASMMemFirstNonZero(void const *pv, size_t cb);
+#else
+DECLINLINE(void *) ASMMemFirstNonZero(void const *pv, size_t cb)
+{
+    uint8_t const *pb = (uint8_t const *)pv;
+    for (; cb; cb--, pb++)
+        if (RT_LIKELY(*pb == u8))
+        { /* likely */ }
+        else
+            return (void *)pb;
+    return NULL;
+}
+#endif
+
+
+/**
+ * Checks if a memory block is all zeros.
+ *
+ * @returns true if zero, false if not.
+ *
+ * @param   pv      Pointer to the memory block.
+ * @param   cb      Number of bytes in the block.
+ *
+ * @sa      ASMMemFirstNonZero
+ */
+DECLINLINE(bool) ASMMemIsZero(void const *pv, size_t cb)
+{
+    return ASMMemFirstNonZero(pv, cb) == NULL;
+}
+
+
+/**
  * Checks if a memory page is all zeros.
  *
@@ -3893 +3936 @@
 
 /**
- * Checks if a memory block is filled with the specified byte.
- *
- * This is a sort of inverted memchr.
+ * Checks if a memory block is filled with the specified byte, returning the
+ * first mismatch.
+ *
+ * This is sort of an inverted memchr.
  *
  * @returns Pointer to the byte which doesn't equal u8.
@@ -3901 +3945 @@
  *
  * @param   pv      Pointer to the memory block.
- * @param   cb      Number of bytes in the block. This MUST be aligned on 32-bit!
+ * @param   cb      Number of bytes in the block.
  * @param   u8      The value it's supposed to be filled with.
  *
- * @todo Fix name, it is a predicate function but it's not returning boolean!
- */
-DECLINLINE(void *) ASMMemIsAll8(void const *pv, size_t cb, uint8_t u8)
-{
-/** @todo rewrite this in inline assembly? */
+ * @remarks No alignment requirements.
+ */
+#if !defined(RT_OS_LINUX) || !defined(__KERNEL__)
+DECLASM(void *) ASMMemFirstMismatchingU8(void const *pv, size_t cb, uint8_t u8);
+#else
+DECLINLINE(void *) ASMMemFirstMismatchingU8(void const *pv, size_t cb, uint8_t u8)
+{
     uint8_t const *pb = (uint8_t const *)pv;
     for (; cb; cb--, pb++)
@@ -3917 +3963 @@
     return NULL;
 }
+#endif
+
+
+/**
+ * Checks if a memory block is filled with the specified byte.
+ *
+ * @returns true if all matching, false if not.
+ *
+ * @param   pv      Pointer to the memory block.
+ * @param   cb      Number of bytes in the block.
+ * @param   u8      The value it's supposed to be filled with.
+ *
+ * @remarks No alignment requirements.
+ */
+DECLINLINE(bool) ASMMemIsAllU8(void const *pv, size_t cb, uint8_t u8)
+{
+    return ASMMemFirstMismatchingU8(pv, cb, u8) == NULL;
+}
 
 
@@ -3930 +3994 @@
  * @param   cb      Number of bytes in the block. This MUST be aligned on 32-bit!
  * @param   u32     The value it's supposed to be filled with.
- *
- * @todo Fix name, it is a predicate function but it's not returning boolean!
- */
-DECLINLINE(uint32_t *) ASMMemIsAllU32(void const *pv, size_t cb, uint32_t u32)
+ */
+DECLINLINE(uint32_t *) ASMMemFirstMismatchingU32(void const *pv, size_t cb, uint32_t u32)
 {
 /** @todo rewrite this in inline assembly? */

trunk/include/iprt/mangling.h

@@ -265 +265 @@
 # define ASMMemFill32                                   RT_MANGLER(ASMMemFill32)
 # define ASMMemFill32_EndProc                           RT_MANGLER(ASMMemFill32_EndProc)
+# define ASMMemFirstNonZero                             RT_MANGLER(ASMMemFirstNonZero)
+# define ASMMemFirstNonZero_EndProc                     RT_MANGLER(ASMMemFirstNonZero_EndProc)
+# define ASMMemFirstMismatchingU8                       RT_MANGLER(ASMMemFirstMismatchingU8)
+# define ASMMemFirstMismatchingU8_EndProc               RT_MANGLER(ASMMemFirstMismatchingU8_EndProc)
+# define ASMMemFirstMismatchingU32                      RT_MANGLER(ASMMemFirstMismatchingU32)
+# define ASMMemFirstMismatchingU32_EndProc              RT_MANGLER(ASMMemFirstMismatchingU32_EndProc)
+# define ASMMemIsZero                                   RT_MANGLER(ASMMemIsZero)
+# define ASMMemIsZero_EndProc                           RT_MANGLER(ASMMemIsZero_EndProc)
+# define ASMMemIsAllU8                                  RT_MANGLER(ASMMemIsAllU8)
+# define ASMMemIsAllU8_EndProc                          RT_MANGLER(ASMMemIsAllU8_EndProc)
 # define ASMMemZero32                                   RT_MANGLER(ASMMemZero32)
 # define ASMMemZero32_EndProc                           RT_MANGLER(ASMMemZero32_EndProc)

trunk/src/VBox/Debugger/DBGPlugInCommonELFTmpl.cpp.h

@@ -125 +125 @@
     if (pEhdr->e_shentsize != sizeof(Elf_Shdr))
         return VERR_BAD_EXE_FORMAT;
-    if (ASMMemIsAll8(&pEhdr->e_ident[EI_PAD], EI_NIDENT - EI_PAD, 0) != NULL) //??
+    if (!ASMMemIsZero(&pEhdr->e_ident[EI_PAD], EI_NIDENT - EI_PAD)) //??
         return VERR_BAD_EXE_FORMAT;
 

trunk/src/VBox/Debugger/DBGPlugInSolaris.cpp

@@ -475 +475 @@
         ||  Module.hdr.e_ident[EI_DATA] != ELFDATA2LSB
         ||  Module.hdr.e_ident[EI_VERSION] != EV_CURRENT
-        ||  ASMMemIsAll8(&Module.hdr.e_ident[EI_PAD], EI_NIDENT - EI_PAD, 0) != NULL
+        ||  !ASMMemIsZero(&Module.hdr.e_ident[EI_PAD], EI_NIDENT - EI_PAD)
         )
         return;
@@ -622 +622 @@
         ||  Module.hdr.e_ident[EI_DATA] != ELFDATA2LSB
         ||  Module.hdr.e_ident[EI_VERSION] != EV_CURRENT
-        ||  ASMMemIsAll8(&Module.hdr.e_ident[EI_PAD], EI_NIDENT - EI_PAD, 0) != NULL
+        ||  !ASMMemIsZero(&Module.hdr.e_ident[EI_PAD], EI_NIDENT - EI_PAD)
         )
         return;

trunk/src/VBox/Devices/BiosCommonCode/MakeAlternativeSource.cpp

@@ -612 +612 @@
                      "  ; Padding %#x bytes at %#x\n", cbPadding, uFlatAddr);
     uint8_t const  *pb = &g_pbImg[uFlatAddr - g_uBiosFlatBase];
-    if (!ASMMemIsAll8(pb, cbPadding, 0))
+    if (ASMMemIsZero(pb, cbPadding))
         return outputPrintf("  times %u db 0\n", cbPadding);
 
@@ -955 +955 @@
         /* Trailing zero padding detection. */
         if (   *pb == '\0'
-            && ASMMemIsAll8(pb, RT_MIN(cb, 8), 0) == NULL)
-        {
-            void    *pv      = ASMMemIsAll8(pb, cb, 0);
+            && ASMMemIsZero(pb, RT_MIN(cb, 8)))
+        {
+            void    *pv      = ASMMemFirstNonZero(pb, cb);
             uint32_t cbZeros = pv ? (uint32_t)((uint8_t const *)pv - pb) : cb;
             if (!outputPrintf("    times %#x db 0\n", cbZeros))

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-info.cpp

@@ -1878 +1878 @@
                 if (pSurface->pMipmapLevels[iMipmap].pSurfaceData)
                 {
-                    if (  ASMMemIsAll8(pSurface->pMipmapLevels[iMipmap].pSurfaceData,
-                                       pSurface->pMipmapLevels[iMipmap].cbSurface, 0) == NULL)
+                    if (ASMMemIsZero(pSurface->pMipmapLevels[iMipmap].pSurfaceData,
+                                     pSurface->pMipmapLevels[iMipmap].cbSurface))
                         pHlp->pfnPrintf(pHlp, "--- Face #%u, mipmap #%u[%u]: all zeros ---\n", iFace, iLevel, iMipmap);
                     else

trunk/src/VBox/HostDrivers/Support/SUPR3HardenedVerify.cpp

@@ -1823 +1823 @@
      * If dynamic linking it screwed up, we may end up here.
      */
-    if (    ASMMemIsAll8(&g_aSupVerifiedFiles[0], sizeof(g_aSupVerifiedFiles), 0) != NULL
-        ||  ASMMemIsAll8(&g_aSupVerifiedDirs[0], sizeof(g_aSupVerifiedDirs), 0) != NULL)
+    if (   !ASMMemIsZero(&g_aSupVerifiedFiles[0], sizeof(g_aSupVerifiedFiles))
+        || !ASMMemIsZero(&g_aSupVerifiedDirs[0], sizeof(g_aSupVerifiedDirs)))
         return VERR_WRONG_ORDER;
 

trunk/src/VBox/Main/include/GuestCtrlImplPrivate.h

@@ -280 +280 @@
         if (RT_SUCCESS(rc))
         {
-            if (ASMMemIsAll8(pszzBlock, cbBlock, 0))
+            if (ASMMemIsZero(pszzBlock, cbBlock))
                 return VINF_SUCCESS;
             return VERR_TOO_MUCH_DATA;

trunk/src/VBox/Runtime/Makefile.kmk

@@ -691 +691 @@
         common/asm/ASMAtomicUoOrU64.asm \
         common/asm/ASMAtomicUoOrU32.asm \
+        common/asm/ASMMemFirstMismatchingU8.asm \
         common/asm/ASMRdMsrEx.asm \
         common/asm/ASMWrMsrEx.asm \
@@ -709 +710 @@
         common/asm/ASMAtomicUoOrU64.asm \
         common/asm/ASMAtomicUoOrU32.asm \
+        common/asm/ASMMemFirstMismatchingU8.asm \
         common/asm/ASMRdMsrEx.asm \
         common/asm/ASMWrMsrEx.asm \

trunk/src/VBox/Runtime/common/ldr/ldrPE.cpp

@@ -2633 +2633 @@
      * Check that the last table entry has a hash value of zero.
      */
-    if (ASMMemIsAll8(pbHashTab + 4, cbHash, 0) != NULL)
+    if (!ASMMemIsZero(pbHashTab + 4, cbHash))
         return RTErrInfoSetF(pErrInfo, VERR_LDRVI_PAGE_HASH_TAB_TOO_LONG,
                              "Maltform final page hash table entry: #%u %#010x %.*Rhxs",

trunk/src/VBox/Runtime/common/math/bignum.cpp

@@ -67 +67 @@
         Assert(!(a_pBigNum)->fCurScrambled); \
         Assert(   (a_pBigNum)->cUsed == (a_pBigNum)->cAllocated \
-               || ASMMemIsAllU32(&(a_pBigNum)->pauElements[(a_pBigNum)->cUsed], \
-                                 ((a_pBigNum)->cAllocated - (a_pBigNum)->cUsed) * RTBIGNUM_ELEMENT_SIZE, 0) == NULL); \
+               || ASMMemIsZero(&(a_pBigNum)->pauElements[(a_pBigNum)->cUsed], \
+                               ((a_pBigNum)->cAllocated - (a_pBigNum)->cUsed) * RTBIGNUM_ELEMENT_SIZE)); \
     } while (0)
 #else
@@ -414 +414 @@
 #ifdef RT_STRICT
         else if (pBigNum->cUsed != cNewUsed)
-            Assert(ASMMemIsAllU32(&pBigNum->pauElements[pBigNum->cUsed],
-                                  (cNewUsed - pBigNum->cUsed) * RTBIGNUM_ELEMENT_SIZE, 0) == NULL);
+            Assert(ASMMemIsZero(&pBigNum->pauElements[pBigNum->cUsed], (cNewUsed - pBigNum->cUsed) * RTBIGNUM_ELEMENT_SIZE));
 #endif
         pBigNum->cUsed = cNewUsed;
@@ -444 +443 @@
 #ifdef RT_STRICT
         else if (pBigNum->cUsed != cNewUsed)
-            Assert(ASMMemIsAllU32(&pBigNum->pauElements[pBigNum->cUsed],
-                                  (cNewUsed - pBigNum->cUsed) * RTBIGNUM_ELEMENT_SIZE, 0) == NULL);
+            Assert(ASMMemIsZero(&pBigNum->pauElements[pBigNum->cUsed], (cNewUsed - pBigNum->cUsed) * RTBIGNUM_ELEMENT_SIZE));
 #endif
         pBigNum->cUsed = cNewUsed;
@@ -469 +467 @@
     {
         Assert(   pBigNum->cAllocated == pBigNum->cUsed
-               || ASMMemIsAllU32(&pBigNum->pauElements[pBigNum->cUsed],
-                                 (pBigNum->cAllocated - pBigNum->cUsed) * RTBIGNUM_ELEMENT_SIZE, 0) == NULL);
+               || ASMMemIsZero(&pBigNum->pauElements[pBigNum->cUsed],
+                                  (pBigNum->cAllocated - pBigNum->cUsed) * RTBIGNUM_ELEMENT_SIZE));
         return VINF_SUCCESS;
     }
@@ -1768 +1766 @@
                     PRTBIGNUMELEMENT    pauDst = pResult->pauElements;
 
-                    Assert(ASMMemIsAllU32(pauDst, (cBits / RTBIGNUM_ELEMENT_BITS) * RTBIGNUM_ELEMENT_SIZE, 0) == NULL);
+                    Assert(ASMMemIsZero(pauDst, (cBits / RTBIGNUM_ELEMENT_BITS) * RTBIGNUM_ELEMENT_SIZE));
                     pauDst += cBits / RTBIGNUM_ELEMENT_BITS;
 

trunk/src/VBox/Runtime/common/misc/sg.cpp

@@ -407 +407 @@
 }
 
+
 RTDECL(bool) RTSgBufIsZero(PRTSGBUF pSgBuf, size_t cbCheck)
 {
@@ -420 +421 @@
         if (!cbThisCheck)
             break;
-
-/** @todo fix this after asm.h gets updated.    */
-        /* Use optimized inline assembler if possible. */
-        if (   !(cbThisCheck % 4)
-            && cbThisCheck * 8 <= UINT32_MAX)
-        {
-            if (ASMBitFirstSet((volatile void *)pvBuf, (uint32_t)cbThisCheck * 8) != -1)
-            {
-                fIsZero = false;
-                break;
-            }
-        }
-        else
-        {
-            for (size_t i = 0; i < cbThisCheck; i++)
-            {
-                char *pbBuf = (char *)pvBuf;
-                if (*pbBuf)
-                {
-                    fIsZero = false;
-                    break;
-                }
-                pvBuf = pbBuf + 1;
-            }
-
-            if (!fIsZero)
-                break;
-        }
-
+        fIsZero = ASMMemIsZero(pvBuf, cbThisCheck);
+        if (!fIsZero)
+            break;
         cbLeft -= cbThisCheck;
     }

trunk/src/VBox/Runtime/common/vfs/vfsmemory.cpp

@@ -475 +475 @@
 
             /* Skip leading zeros if there is a whole bunch of them. */
-            uint8_t const *pbSrcNZ = (uint8_t const *)ASMMemIsAll8(pbSrc, cbLeftToWrite, 0);
+            uint8_t const *pbSrcNZ = (uint8_t const *)ASMMemFirstNonZero(pbSrc, cbLeftToWrite);
             size_t         cbZeros = pbSrcNZ ? pbSrcNZ - pbSrc            : cbLeftToWrite;
             if (cbZeros)

trunk/src/VBox/Runtime/common/zip/tarvfs.cpp

@@ -622 +622 @@
          */
         case RTZIPTARREADERSTATE_ZERO:
-            if (ASMMemIsAllU32(pHdr, sizeof(*pHdr), 0) != NULL)
+            if (!ASMMemIsZero(pHdr, sizeof(*pHdr)))
                 return VERR_TAR_ZERO_HEADER;
             pThis->cZeroHdrs++;

trunk/src/VBox/Runtime/r0drv/alloc-ef-r0drv.cpp

@@ -672 +672 @@
          */
 # ifdef RTR0MEM_EF_IN_FRONT
-        void *pvWrong = ASMMemIsAll8((char *)pv + pBlock->cbUnaligned,
-                                     RT_ALIGN_Z(pBlock->cbAligned, PAGE_SIZE) - pBlock->cbUnaligned,
-                                     RTR0MEM_EF_NOMAN_FILLER);
+        void *pvWrong = ASMMemFirstMismatchingU8((char *)pv + pBlock->cbUnaligned,
+                                                 RT_ALIGN_Z(pBlock->cbAligned, PAGE_SIZE) - pBlock->cbUnaligned,
+                                                 RTR0MEM_EF_NOMAN_FILLER);
 # else
         /* Alignment must match allocation alignment in rtMemAlloc(). */
-        void *pvWrong = ASMMemIsAll8((char *)pv + pBlock->cbUnaligned,
-                                     pBlock->cbAligned - pBlock->cbUnaligned,
-                                     RTR0MEM_EF_NOMAN_FILLER);
+        void *pvWrong = ASMMemFirstMismatchingU8((char *)pv + pBlock->cbUnaligned,
+                                                 pBlock->cbAligned - pBlock->cbUnaligned,
+                                                 RTR0MEM_EF_NOMAN_FILLER);
         if (pvWrong)
             RTAssertDoPanic();
-        pvWrong = ASMMemIsAll8((void *)((uintptr_t)pv & ~(uintptr_t)PAGE_OFFSET_MASK),
-                               RT_ALIGN_Z(pBlock->cbAligned, PAGE_SIZE) - pBlock->cbAligned,
-                               RTR0MEM_EF_NOMAN_FILLER);
+        pvWrong = ASMMemFirstMismatchingU8((void *)((uintptr_t)pv & ~(uintptr_t)PAGE_OFFSET_MASK),
+                                           RT_ALIGN_Z(pBlock->cbAligned, PAGE_SIZE) - pBlock->cbAligned,
+                                           RTR0MEM_EF_NOMAN_FILLER);
 # endif
         if (pvWrong)

trunk/src/VBox/Runtime/r3/alloc-ef.cpp

@@ -681 +681 @@
          */
 #  ifdef RTALLOC_EFENCE_IN_FRONT
-        void *pvWrong = ASMMemIsAll8((char *)pv + pBlock->cbUnaligned,
-                                     RT_ALIGN_Z(pBlock->cbAligned, PAGE_SIZE) - pBlock->cbUnaligned,
-                                     RTALLOC_EFENCE_NOMAN_FILLER);
+        void *pvWrong = ASMMemFirstMismatchingU8((char *)pv + pBlock->cbUnaligned,
+                                                 RT_ALIGN_Z(pBlock->cbAligned, PAGE_SIZE) - pBlock->cbUnaligned,
+                                                 RTALLOC_EFENCE_NOMAN_FILLER);
 #  else
         /* Alignment must match allocation alignment in rtMemAlloc(). */
-        void  *pvWrong   = ASMMemIsAll8((char *)pv + pBlock->cbUnaligned,
-                                        pBlock->cbAligned - pBlock->cbUnaligned,
-                                        RTALLOC_EFENCE_NOMAN_FILLER);
+        void  *pvWrong = ASMMemFirstMismatchingU8((char *)pv + pBlock->cbUnaligned,
+                                                  pBlock->cbAligned - pBlock->cbUnaligned,
+                                                  RTALLOC_EFENCE_NOMAN_FILLER);
         if (pvWrong)
             RTAssertDoPanic();
-        pvWrong = ASMMemIsAll8((void *)((uintptr_t)pv & ~(uintptr_t)PAGE_OFFSET_MASK),
-                               RT_ALIGN_Z(pBlock->cbAligned, PAGE_SIZE) - pBlock->cbAligned,
-                               RTALLOC_EFENCE_NOMAN_FILLER);
+        pvWrong = ASMMemFirstMismatchingU8((void *)((uintptr_t)pv & ~(uintptr_t)PAGE_OFFSET_MASK),
+                                           RT_ALIGN_Z(pBlock->cbAligned, PAGE_SIZE) - pBlock->cbAligned,
+                                           RTALLOC_EFENCE_NOMAN_FILLER);
 #  endif
         if (pvWrong)

trunk/src/VBox/Runtime/testcase/tstRTInlineAsm.cpp

@@ -47 +47 @@
 # include <iprt/time.h>
 #endif
+#include <iprt/rand.h>
 #include <iprt/stream.h>
 #include <iprt/string.h>
@@ -1322 +1323 @@
         RTTESTI_CHECK(!ASMMemIsZeroPage(pvPage2));
         ((uint8_t *)pvPage2)[off] = 0;
+    }
+
+    RTTestSubDone(hTest);
+}
+
+
+void tstASMMemFirstMismatchingU8(RTTEST hTest)
+{
+    RTTestSub(hTest, "ASMMemFirstMismatchingU8");
+
+    uint8_t *pbPage1 = (uint8_t *)RTTestGuardedAllocHead(hTest, PAGE_SIZE);
+    uint8_t *pbPage2 = (uint8_t *)RTTestGuardedAllocTail(hTest, PAGE_SIZE);
+    RTTESTI_CHECK_RETV(pbPage1 && pbPage2);
+
+    memset(pbPage1, 0, PAGE_SIZE);
+    memset(pbPage2, 0, PAGE_SIZE);
+    RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage1, PAGE_SIZE, 0) == NULL);
+    RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage2, PAGE_SIZE, 0) == NULL);
+    RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage1, PAGE_SIZE, 1) == pbPage1);
+    RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage2, PAGE_SIZE, 1) == pbPage2);
+    RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage1, PAGE_SIZE, 0x87) == pbPage1);
+    RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage2, PAGE_SIZE, 0x87) == pbPage2);
+    RTTESTI_CHECK(ASMMemIsZero(pbPage1, PAGE_SIZE));
+    RTTESTI_CHECK(ASMMemIsZero(pbPage2, PAGE_SIZE));
+    RTTESTI_CHECK(ASMMemIsAllU8(pbPage1, PAGE_SIZE, 0));
+    RTTESTI_CHECK(ASMMemIsAllU8(pbPage2, PAGE_SIZE, 0));
+    RTTESTI_CHECK(!ASMMemIsAllU8(pbPage1, PAGE_SIZE, 0x34));
+    RTTESTI_CHECK(!ASMMemIsAllU8(pbPage2, PAGE_SIZE, 0x88));
+    unsigned cbSub = 32;
+    while (cbSub-- > 0)
+    {
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(&pbPage1[PAGE_SIZE - cbSub], cbSub, 0) == NULL);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(&pbPage2[PAGE_SIZE - cbSub], cbSub, 0) == NULL);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage1, cbSub, 0) == NULL);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage2, cbSub, 0) == NULL);
+
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(&pbPage1[PAGE_SIZE - cbSub], cbSub, 0x34) == &pbPage1[PAGE_SIZE - cbSub] || !cbSub);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(&pbPage2[PAGE_SIZE - cbSub], cbSub, 0x99) == &pbPage2[PAGE_SIZE - cbSub] || !cbSub);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage1, cbSub, 0x42) == pbPage1 || !cbSub);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage2, cbSub, 0x88) == pbPage2 || !cbSub);
+    }
+
+    memset(pbPage1, 0xff, PAGE_SIZE);
+    memset(pbPage2, 0xff, PAGE_SIZE);
+    RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage1, PAGE_SIZE, 0xff) == NULL);
+    RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage2, PAGE_SIZE, 0xff) == NULL);
+    RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage1, PAGE_SIZE, 0xfe) == pbPage1);
+    RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage2, PAGE_SIZE, 0xfe) == pbPage2);
+    RTTESTI_CHECK(!ASMMemIsZero(pbPage1, PAGE_SIZE));
+    RTTESTI_CHECK(!ASMMemIsZero(pbPage2, PAGE_SIZE));
+    RTTESTI_CHECK(ASMMemIsAllU8(pbPage1, PAGE_SIZE, 0xff));
+    RTTESTI_CHECK(ASMMemIsAllU8(pbPage2, PAGE_SIZE, 0xff));
+    RTTESTI_CHECK(!ASMMemIsAllU8(pbPage1, PAGE_SIZE, 0));
+    RTTESTI_CHECK(!ASMMemIsAllU8(pbPage2, PAGE_SIZE, 0));
+    cbSub = 32;
+    while (cbSub-- > 0)
+    {
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(&pbPage1[PAGE_SIZE - cbSub], cbSub, 0xff) == NULL);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(&pbPage2[PAGE_SIZE - cbSub], cbSub, 0xff) == NULL);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage1, cbSub, 0xff) == NULL);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage2, cbSub, 0xff) == NULL);
+
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(&pbPage1[PAGE_SIZE - cbSub], cbSub, 0xfe) == &pbPage1[PAGE_SIZE - cbSub] || !cbSub);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(&pbPage2[PAGE_SIZE - cbSub], cbSub, 0xfe) == &pbPage2[PAGE_SIZE - cbSub] || !cbSub);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage1, cbSub, 0xfe) == pbPage1 || !cbSub);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU8(pbPage2, cbSub, 0xfe) == pbPage2 || !cbSub);
+    }
+
+
+    /*
+     * Various alignments and sizes.
+     */
+    uint8_t const  bFiller1 = 0x00;
+    uint8_t const  bFiller2 = 0xf6;
+    size_t const   cbBuf    = 128;
+    uint8_t       *pbBuf1   = pbPage1;
+    uint8_t       *pbBuf2   = &pbPage2[PAGE_SIZE - cbBuf]; /* Put it up against the tail guard */
+    memset(pbPage1, ~bFiller1, PAGE_SIZE);
+    memset(pbPage2, ~bFiller2, PAGE_SIZE);
+    memset(pbBuf1, bFiller1, cbBuf);
+    memset(pbBuf2, bFiller2, cbBuf);
+    for (size_t offNonZero = 0; offNonZero < cbBuf; offNonZero++)
+    {
+        uint8_t bRand = (uint8_t)RTRandU32();
+        pbBuf1[offNonZero] = bRand | 1;
+        pbBuf2[offNonZero] = (0x80 | bRand) ^ 0xf6;
+
+        for (size_t offStart = 0; offStart < 32; offStart++)
+        {
+            size_t const  cbMax = cbBuf - offStart;
+            for (size_t cb = 0; cb < cbMax; cb++)
+            {
+                size_t const offEnd = offStart + cb;
+                uint8_t bSaved1, bSaved2;
+                if (offEnd < PAGE_SIZE)
+                {
+                    bSaved1 = pbBuf1[offEnd];
+                    bSaved2 = pbBuf2[offEnd];
+                    pbBuf1[offEnd] = 0xff;
+                    pbBuf2[offEnd] = 0xff;
+                }
+
+                uint8_t *pbRet = (uint8_t *)ASMMemFirstMismatchingU8(pbBuf1 + offStart, cb, bFiller1);
+                RTTESTI_CHECK(offNonZero - offStart < cb ? pbRet == &pbBuf1[offNonZero] : pbRet == NULL);
+
+                pbRet = (uint8_t *)ASMMemFirstMismatchingU8(pbBuf2 + offStart, cb, bFiller2);
+                if (!(offNonZero - offStart < cb ? pbRet == &pbBuf2[offNonZero] : pbRet == NULL))
+                    __debugbreak();
+                RTTESTI_CHECK(offNonZero - offStart < cb ? pbRet == &pbBuf2[offNonZero] : pbRet == NULL);
+
+                if (offEnd < PAGE_SIZE)
+                {
+                    pbBuf1[offEnd] = bSaved1;
+                    pbBuf2[offEnd] = bSaved2;
+                }
+            }
+        }
+
+        pbBuf1[offNonZero] = 0;
+        pbBuf2[offNonZero] = 0xf6;
     }
 
@@ -1791 +1912 @@
     tstASMMemZeroPage();
     tstASMMemIsZeroPage(g_hTest);
+    tstASMMemFirstMismatchingU8(g_hTest);
     tstASMMemZero32();
     tstASMMemFill32();

trunk/src/VBox/Runtime/testcase/tstRTMemCache.cpp

@@ -133 +133 @@
 {
     RTTESTI_CHECK(hMemCache == g_hMemCache);
-    RTTESTI_CHECK(ASMMemIsAll8(pvObj, 256, 0) == NULL);
+    RTTESTI_CHECK(ASMMemIsZero(pvObj, 256));
 
     if (*(bool *)pvUser)

trunk/src/VBox/Runtime/testcase/tstRTMemPool.cpp

@@ -68 +68 @@
     {
         RTTESTI_CHECK_RETV(pv = RTMemPoolAllocZ(hMemPool, 1024));
-        RTTESTI_CHECK(ASMMemIsAllU32(pv, 1024, 0) == NULL);
+        RTTESTI_CHECK(ASMMemFirstMismatchingU32(pv, 1024, 0) == NULL);
         memset(pv, 'a', 1024);
         RTTESTI_CHECK_RETV(RTMemPoolRefCount(pv) == 1);
@@ -88 +88 @@
         RTTESTI_CHECK_RETV(pv = RTMemPoolDupEx(hMemPool, szTest, sizeof(szTest), cb));
         RTTESTI_CHECK(memcmp(pv, szTest, sizeof(szTest)) == 0);
-        RTTESTI_CHECK(ASMMemIsAll8((uint8_t *)pv + sizeof(szTest), cb, 0) == NULL);
+        RTTESTI_CHECK(ASMMemIsZero((uint8_t *)pv + sizeof(szTest), cb));
         memset(pv, 'b', sizeof(szTest) + cb);
         RTTESTI_CHECK_RETV(RTMemPoolRefCount(pv) == 1);
@@ -118 +118 @@
         RTTESTI_CHECK(RTMemPoolRefCount(pv) == 1);
         memset(pv, 'a', i);
-        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv));
+        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv,(uintptr_t)pv2 - (uintptr_t)pv));
         RTTESTI_CHECK(RTMemPoolRetain(pv) == 2);
         RTTESTI_CHECK(RTMemPoolRefCount(pv) == 2);
@@ -125 +125 @@
         RTTESTI_CHECK(RTMemPoolRetain(pv) == 4);
         RTTESTI_CHECK(RTMemPoolRefCount(pv) == 4);
-        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv));
+        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv));
         RTTESTI_CHECK(RTMemPoolRelease(hMemPool, pv) == 3);
         RTTESTI_CHECK(RTMemPoolRefCount(pv) == 3);
-        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv));
+        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv));
         RTTESTI_CHECK(RTMemPoolRetain(pv) == 4);
         RTTESTI_CHECK(RTMemPoolRefCount(pv) == 4);
@@ -137 +137 @@
         RTTESTI_CHECK(RTMemPoolRelease(NIL_RTMEMPOOL, pv) == 5);
         RTTESTI_CHECK(RTMemPoolRelease(NIL_RTMEMPOOL, pv) == 4);
-        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv));
+        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv));
 
         for (uint32_t cRefs = 3;; cRefs--)
@@ -145 +145 @@
                 break;
             RTTESTI_CHECK(RTMemPoolRefCount(pv) == cRefs);
-            RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x cRefs=%d\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv, cRefs));
+            RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x cRefs=%d\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv, cRefs));
             for (uint32_t j = 0; j < 42; j++)
             {
@@ -152 +152 @@
                 memset(pv2, 'f', i);
                 RTTESTI_CHECK(RTMemPoolRelease(hMemPool, pv2) == 0);
-                RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x cRefs=%d\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv, cRefs));
+                RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(pv, i, 'a')) == NULL, ("i=%#x pv=%p off=%#x cRefs=%d\n", i, pv, (uintptr_t)pv2 - (uintptr_t)pv, cRefs));
             }
         }

trunk/src/VBox/Runtime/testcase/tstRTMemSafer.cpp

@@ -129 +129 @@
         RTTESTI_CHECK_RC_OK_RETV(RTMemSaferReallocZEx(cbAlloc, pvBuf, cbNew, &pvBuf, 0));
 
-        RTTESTI_CHECK(ASMMemIsAll8(pvBuf, RT_MIN(cbAlloc, cbNew), chFiller) == NULL);
+        RTTESTI_CHECK(ASMMemIsAllU8(pvBuf, RT_MIN(cbAlloc, cbNew), chFiller));
 
         chFiller += 0x31;

trunk/src/VBox/Runtime/testcase/tstRTStrAlloc.cpp

@@ -96 +96 @@
             RTTESTI_CHECK(!psz[127]);
             RTTESTI_CHECK(!psz[159]);
-            RTTESTI_CHECK(ASMMemIsAll8(psz, 127, 'a') == NULL);
+            RTTESTI_CHECK(ASMMemIsAllU8(psz, 127, 'a'));
             memset(psz, 'b', 159);
 
@@ -103 +103 @@
             {
                 RTTESTI_CHECK(!psz[78]);
-                RTTESTI_CHECK(ASMMemIsAll8(psz, 78, 'b') == NULL);
+                RTTESTI_CHECK(ASMMemIsAllU8(psz, 78, 'b'));
 
                 RTTESTI_CHECK_RC(rc = RTStrRealloc(&psz, 0), VINF_SUCCESS);

trunk/src/VBox/Runtime/testcase/tstRTStrCache.cpp

@@ -175 +175 @@
         void *pv2;
         RTTESTI_CHECK_RETV(psz = RTStrCacheEnterN(hStrCache, szTest, i));
-        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz));
+        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz));
         RTTESTI_CHECK(RTStrCacheRetain(psz) == 2);
         RTTESTI_CHECK(RTStrCacheRetain(psz) == 3);
         RTTESTI_CHECK(RTStrCacheRetain(psz) == 4);
-        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz));
+        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz));
         RTTESTI_CHECK(RTStrCacheRelease(hStrCache, psz) == 3);
-        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz));
+        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz));
         RTTESTI_CHECK(RTStrCacheRetain(psz) == 4);
         RTTESTI_CHECK(RTStrCacheRetain(psz) == 5);
@@ -187 +187 @@
         RTTESTI_CHECK(RTStrCacheRelease(hStrCache, psz) == 5);
         RTTESTI_CHECK(RTStrCacheRelease(hStrCache, psz) == 4);
-        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz));
+        RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz));
 
         for (uint32_t cRefs = 3;; cRefs--)
@@ -194 +194 @@
             if (cRefs == 0)
                 break;
-            RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x cRefs=%d\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz, cRefs));
+            RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x cRefs=%d\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz, cRefs));
             for (uint32_t j = 0; j < 42; j++)
             {
@@ -201 +201 @@
                 RTTESTI_CHECK_RETV(psz2 != psz);
                 RTTESTI_CHECK(RTStrCacheRelease(hStrCache, psz2) == 0);
-                RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemIsAll8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x cRefs=%d\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz, cRefs));
+                RTTESTI_CHECK_MSG_RETV((pv2 = ASMMemFirstMismatchingU8(psz, i, 'a')) == NULL && !psz[i], ("i=%#x psz=%p off=%#x cRefs=%d\n", i, psz, (uintptr_t)pv2 - (uintptr_t)psz, cRefs));
             }
         }

trunk/src/VBox/VMM/VMMAll/MMAllHyper.cpp

@@ -1190 +1190 @@
             }
 
-            uint32_t *pu32Bad = ASMMemIsAllU32((uint8_t *)pu32End - cbFence, cbFence - sizeof(uint32_t), MMHYPER_HEAP_STRICT_FENCE_U32);
+            uint32_t *pu32Bad = ASMMemFirstMismatchingU32((uint8_t *)pu32End - cbFence, cbFence - sizeof(uint32_t), MMHYPER_HEAP_STRICT_FENCE_U32);
             if (RT_UNLIKELY(pu32Bad))
             {

trunk/src/VBox/VMM/VMMR0/GVMMR0.cpp

@@ -2655 +2655 @@
      * Enumerate the VMs and add the ones visible to the statistics.
      */
-    if (ASMMemIsAll8(&pStats->SchedSum, sizeof(pStats->SchedSum), 0))
+    if (!ASMMemIsZero(&pStats->SchedSum, sizeof(pStats->SchedSum)))
     {
         for (unsigned i = pGVMM->iUsedHead;

trunk/src/VBox/VMM/VMMR3/PGMDbg.cpp

@@ -677 +677 @@
     }
 
-    const bool      fAllZero   = ASMMemIsAll8(pabNeedle, cbNeedle, 0) == NULL;
+    const bool      fAllZero   = ASMMemIsZero(pabNeedle, cbNeedle);
     const uint32_t  cIncPages  = GCPhysAlign <= PAGE_SIZE
                                ? 1
@@ -850 +850 @@
      * Search the memory - ignore MMIO, zero and not-present pages.
      */
-    const bool      fAllZero  = ASMMemIsAll8(pabNeedle, cbNeedle, 0) == NULL;
+    const bool      fAllZero  = ASMMemIsZero(pabNeedle, cbNeedle);
     RTGCPTR         GCPtrMask = PGMMODE_IS_LONG_MODE(enmMode) ? UINT64_MAX : UINT32_MAX;
     uint8_t         abPrev[MAX_NEEDLE_SIZE];

trunk/src/VBox/VMM/testcase/tstCompressionBenchmark.cpp

@@ -610 +610 @@
     for (size_t iPage = 0; iPage < g_cPages; iPage++)
     {
-        if (!ASMMemIsAllU32(&g_pabSrc[iPage * PAGE_SIZE], PAGE_SIZE, 0))
+        if (ASMMemIsZeroPage(&g_pabSrc[iPage * PAGE_SIZE]))
             cZeroPages++;
     }

trunk/src/VBox/ValidationKit/bootsectors/bs3kit/Makefile.kmk

@@ -119 +119 @@
        ../../../Runtime/common/asm/ASMBitLastSetU32.asm \
        ../../../Runtime/common/asm/ASMBitLastSetU64.asm \
+       ../../../Runtime/common/asm/ASMMemFirstMismatchingU8.asm \
        ../../../Runtime/common/asm/ASMSerializeInstruction-cpuid.asm \
        ../../../Runtime/common/asm/ASMSerializeInstruction-iret.asm \