Add Relaxed_Memcmp

This is in preparation for supporting concurrent access in
String::SlowEquals, which will need to compare character buffers with
relaxed ordering.

Bug: v8:12007
Change-Id: Ie8ac62c15df48ebd605985c35b843b510c7ad167
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3313467
Commit-Queue: Shu-yu Guo <syg@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Cr-Commit-Position: refs/heads/main@{#78231}

src/base/atomicops.h

@@ -378,6 +378,64 @@ inline void Relaxed_Memmove(volatile Atomic8* dst, volatile const Atomic8* src,
   }
 }
 
+namespace helper {
+inline int MemcmpNotEqualFundamental(Atomic8 u1, Atomic8 u2) {
+  DCHECK_NE(u1, u2);
+  return u1 < u2 ? -1 : 1;
+}
+inline int MemcmpNotEqualFundamental(AtomicWord u1, AtomicWord u2) {
+  DCHECK_NE(u1, u2);
+#if defined(V8_TARGET_BIG_ENDIAN)
+  return u1 < u2 ? -1 : 1;
+#else
+  for (size_t i = 0; i < sizeof(AtomicWord); ++i) {
+    uint8_t byte1 = u1 & 0xFF;
+    uint8_t byte2 = u2 & 0xFF;
+    if (byte1 != byte2) return byte1 < byte2 ? -1 : 1;
+    u1 >>= 8;
+    u2 >>= 8;
+  }
+  UNREACHABLE();
+#endif
+}
+}  // namespace helper
+
+inline int Relaxed_Memcmp(volatile const Atomic8* s1,
+                          volatile const Atomic8* s2, size_t len) {
+  constexpr size_t kAtomicWordSize = sizeof(AtomicWord);
+  while (len > 0 &&
+         !(IsAligned(reinterpret_cast<uintptr_t>(s1), kAtomicWordSize) &&
+           IsAligned(reinterpret_cast<uintptr_t>(s2), kAtomicWordSize))) {
+    Atomic8 u1 = Relaxed_Load(s1++);
+    Atomic8 u2 = Relaxed_Load(s2++);
+    if (u1 != u2) return helper::MemcmpNotEqualFundamental(u1, u2);
+    --len;
+  }
+
+  if (IsAligned(reinterpret_cast<uintptr_t>(s1), kAtomicWordSize) &&
+      IsAligned(reinterpret_cast<uintptr_t>(s2), kAtomicWordSize)) {
+    while (len >= kAtomicWordSize) {
+      AtomicWord u1 =
+          Relaxed_Load(reinterpret_cast<const volatile AtomicWord*>(s1));
+      AtomicWord u2 =
+          Relaxed_Load(reinterpret_cast<const volatile AtomicWord*>(s2));
+      if (u1 != u2) return helper::MemcmpNotEqualFundamental(u1, u2);
+      s1 += kAtomicWordSize;
+      s2 += kAtomicWordSize;
+      len -= kAtomicWordSize;
+    }
+  }
+
+  while (len > 0) {
+    Atomic8 u1 = Relaxed_Load(s1++);
+    Atomic8 u2 = Relaxed_Load(s2++);
+    if (u1 != u2) return helper::MemcmpNotEqualFundamental(u1, u2);
+    --len;
+  }
+
+  return 0;
+}
+
 }  // namespace base
 }  // namespace v8
 

test/cctest/test-atomicops.cc

@@ -303,5 +303,27 @@ TEST(Relaxed_Memmove) {
   }
 }
 
+TEST(Relaxed_Memcmp) {
+  constexpr size_t kLen = 50;
+  Atomic8 arr1[kLen];
+  Atomic8 arr1_same[kLen];
+  Atomic8 arr2[kLen];
+  for (size_t i = 0; i < kLen; ++i) {
+    arr1[i] = arr1_same[i] = i;
+    arr2[i] = i + 1;
+  }
+
+  for (size_t offset = 0; offset < kLen; offset++) {
+    const Atomic8* arr1p = arr1 + offset;
+    const Atomic8* arr1_samep = arr1_same + offset;
+    const Atomic8* arr2p = arr2 + offset;
+    const size_t len = kLen - offset;
+    CHECK_EQ(0, Relaxed_Memcmp(arr1p, arr1p, len));
+    CHECK_EQ(0, Relaxed_Memcmp(arr1p, arr1_samep, len));
+    CHECK_LT(Relaxed_Memcmp(arr1p, arr2p, len), 0);
+    CHECK_GT(Relaxed_Memcmp(arr2p, arr1p, len), 0);
+  }
+}
+
 }  // namespace base
 }  // namespace v8