deps: V8: cherry-pick c135d5e81f82

Original commit message:

    [api][strings] Optimize ContainsOnlyOneByte with SIMD

    Add Highway-based SIMD implementation for checking if strings contain
    only one-byte (Latin-1) characters. Highway provides portable SIMD
    abstraction across different architectures with automatic target
    selection at runtime.

    The SIMD implementation processes 8 uint16_t values (128 bits) at
    once,checking if any character has the high byte set. This provides
    significant speedup over the previous implementation which processed 2-4
    values per iteration and only checked every 16 iterations.

    The optimization applies to both String::ContainsOnlyOneByte() in the
    public API and the internal IsOnly8Bit() helper used during string
    hashing. This improves performance for string validation, encoding
    decisions, and UTF-8/UTF-16 conversion operations.

    Additionally, it resolves a TODO by leszeks.

    Change-Id: I41f519339fb96f3bf3f4fa30283f84ccbb5115d0
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/7159233
    Reviewed-by: Erik Corry <erikcorry@chromium.org>
    Commit-Queue: Erik Corry <erikcorry@chromium.org>
    Reviewed-by: Leszek Swirski <leszeks@chromium.org>
    Cr-Commit-Position: refs/heads/main@{#104120}

Refs: v8/v8@c135d5e

Author: rmagrin

common.gypi

@@ -38,7 +38,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.13',
+    'v8_embedder_string': '-node.14',
 
     ##### V8 defaults for Node.js #####
 

deps/v8/src/api/api.cc

@@ -159,6 +159,8 @@
 #include "src/objects/intl-objects.h"
 #endif  // V8_INTL_SUPPORT
 
+#include "src/strings/string-hasher-inl.h"
+
 #if V8_OS_LINUX || V8_OS_DARWIN || V8_OS_FREEBSD
 #include <signal.h>
 #include <unistd.h>
@@ -5575,28 +5577,6 @@ bool String::IsOneByte() const {
   return Utils::OpenDirectHandle(this)->IsOneByteRepresentation();
 }
 
-// Helpers for ContainsOnlyOneByteHelper
-template <size_t size>
-struct OneByteMask;
-template <>
-struct OneByteMask<4> {
-  static const uint32_t value = 0xFF00FF00;
-};
-template <>
-struct OneByteMask<8> {
-  static const uint64_t value = 0xFF00'FF00'FF00'FF00;
-};
-static const uintptr_t kOneByteMask = OneByteMask<sizeof(uintptr_t)>::value;
-static const uintptr_t kAlignmentMask = sizeof(uintptr_t) - 1;
-static inline bool Unaligned(const uint16_t* chars) {
-  return reinterpret_cast<const uintptr_t>(chars) & kAlignmentMask;
-}
-
-static inline const uint16_t* Align(const uint16_t* chars) {
-  return reinterpret_cast<uint16_t*>(reinterpret_cast<uintptr_t>(chars) &
-                                     ~kAlignmentMask);
-}
-
 class ContainsOnlyOneByteHelper {
  public:
   ContainsOnlyOneByteHelper() : is_one_byte_(true) {}
@@ -5613,35 +5593,7 @@ class ContainsOnlyOneByteHelper {
     // Nothing to do.
   }
   void VisitTwoByteString(const uint16_t* chars, int length) {
-    // Accumulated bits.
-    uintptr_t acc = 0;
-    // Align to uintptr_t.
-    const uint16_t* end = chars + length;
-    while (Unaligned(chars) && chars != end) {
-      acc |= *chars++;
-    }
-    // Read word aligned in blocks,
-    // checking the return value at the end of each block.
-    const uint16_t* aligned_end = Align(end);
-    const int increment = sizeof(uintptr_t) / sizeof(uint16_t);
-    const int inner_loops = 16;
-    while (chars + inner_loops * increment < aligned_end) {
-      for (int i = 0; i < inner_loops; i++) {
-        acc |= *reinterpret_cast<const uintptr_t*>(chars);
-        chars += increment;
-      }
-      // Check for early return.
-      if ((acc & kOneByteMask) != 0) {
-        is_one_byte_ = false;
-        return;
-      }
-    }
-    // Read the rest.
-    while (chars != end) {
-      acc |= *chars++;
-    }
-    // Check result.
-    if ((acc & kOneByteMask) != 0) is_one_byte_ = false;
+    is_one_byte_ = internal::detail::IsOnly8Bit(chars, length);
   }
 
  private:

deps/v8/src/strings/string-hasher-inl.h

@@ -11,12 +11,6 @@
 #include "src/common/globals.h"
 #include "src/utils/utils.h"
 
-#ifdef __SSE2__
-#include <emmintrin.h>
-#elif defined(__ARM_NEON__)
-#include <arm_neon.h>
-#endif
-
 // Comment inserted to prevent header reordering.
 #include <type_traits>
 
@@ -43,14 +37,18 @@ uint32_t ConvertRawHashToUsableHash(T raw_hash) {
 }
 
 V8_INLINE bool IsOnly8Bit(const uint16_t* chars, unsigned len) {
-  // TODO(leszeks): This could be SIMD for efficiency on large strings, if we
-  // need it.
-  for (unsigned i = 0; i < len; ++i) {
-    if (chars[i] > 255) {
-      return false;
+  // For small strings, use a simple scalar loop to avoid SIMD overhead.
+  // Threshold of 16 is chosen to balance setup cost vs benefit.
+  if (len <= 16) {
+    for (unsigned i = 0; i < len; i++) {
+      if (chars[i] > 0xFF) {
+        return false;
+      }
     }
+    return true;
   }
-  return true;
+  // For larger strings, use the non-inlined SIMD implementation.
+  return IsOnly8BitSIMD(chars, len);
 }
 
 V8_INLINE uint64_t GetRapidHash(const uint8_t* chars, uint32_t length,

deps/v8/src/strings/string-hasher.cc

@@ -5,6 +5,7 @@
 
 #include "src/strings/string-hasher.h"
 
+#include "hwy/highway.h"
 #include "src/strings/string-hasher-inl.h"
 
 namespace v8::internal {
@@ -73,6 +74,33 @@ uint64_t HashConvertingTo8Bit(const uint16_t* chars, uint32_t length,
   return rapidhash<ConvertTo8BitHashReader>(
       reinterpret_cast<const uint8_t*>(chars), length, seed, secret);
 }
+
+bool IsOnly8BitSIMD(const uint16_t* chars, unsigned len) {
+  namespace hw = hwy::HWY_NAMESPACE;
+  hw::FixedTag<uint16_t, 8> tag;
+  const size_t stride = hw::Lanes(tag);
+  const auto high_byte_mask = hw::Set(tag, static_cast<uint16_t>(0xFF00));
+  const auto zero = hw::Zero(tag);
+
+  const uint16_t* end = chars + len;
+  while (chars + stride <= end) {
+    const auto data = hw::LoadU(tag, chars);
+    const auto high_bytes = hw::And(data, high_byte_mask);
+    const auto cmp = hw::Eq(high_bytes, zero);
+    if (!hw::AllTrue(tag, cmp)) {
+      return false;
+    }
+    chars += stride;
+  }
+  // Handle remaining characters.
+  while (chars < end) {
+    if (*chars > 0xFF) {
+      return false;
+    }
+    chars++;
+  }
+  return true;
+}
 }  // namespace detail
 
 }  // namespace v8::internal

deps/v8/src/strings/string-hasher.h

@@ -17,6 +17,12 @@ class Vector;
 
 namespace internal {
 
+namespace detail {
+// Non-inlined SIMD implementation for checking if a uint16_t string contains
+// only Latin1 characters. Used by the inline IsOnly8Bit wrapper.
+V8_EXPORT_PRIVATE bool IsOnly8BitSIMD(const uint16_t* chars, unsigned len);
+}  // namespace detail
+
 // A simple incremental string hasher. Slow but allows for special casing each
 // individual character.
 class RunningStringHasher final {