fix: remove suimdutf atomic requirement

Signed-off-by: Matt Leon <[email protected]>

Author: leonm1

bazel/external/v8.patch

@@ -1,7 +1,7 @@
 From bc2a85e39fd55879b9baed51429c08b27d5514c8 Mon Sep 17 00:00:00 2001
 From: Matt Leon <[email protected]>
 Date: Wed, 16 Jul 2025 16:55:02 -0400
-Subject: [PATCH 1/6] Disable pointer compression
+Subject: [PATCH 1/7] Disable pointer compression
 
 Pointer compression limits the maximum number of WasmVMs.
 
@@ -30,7 +30,7 @@ index 3f5a87d054e..0a693b7ee10 100644
 From 61898e9a63ac89a37261c081b84714cfc400a4b1 Mon Sep 17 00:00:00 2001
 From: Matt Leon <[email protected]>
 Date: Wed, 16 Jul 2025 16:56:31 -0400
-Subject: [PATCH 2/6] Restore _allowlist_function_transition
+Subject: [PATCH 2/7] Restore _allowlist_function_transition
 
 Reverts v8 commit b26554ec368e9553782012c96aa5e99b163eaff2, which removed use of
 _allowlist_function_transition from v8 bazel/defs.bzl, since it is still required
@@ -85,7 +85,7 @@ index 8c929454840..57336154cf7 100644
 From 4a6e7158fd4ca48c75c8e33ea15760c9beea1d2f Mon Sep 17 00:00:00 2001
 From: Matt Leon <[email protected]>
 Date: Wed, 16 Jul 2025 16:56:52 -0400
-Subject: [PATCH 3/6] Don't expose Wasm C API (only Wasm C++ API).
+Subject: [PATCH 3/7] Don't expose Wasm C API (only Wasm C++ API).
 
 Signed-off-by: Matt Leon <[email protected]>
 ---
@@ -118,7 +118,7 @@ index 05e4029f183..d705be96a16 100644
 From 7b593eb8086dcfe9012d4fa694d622f21dadb731 Mon Sep 17 00:00:00 2001
 From: Matt Leon <[email protected]>
 Date: Wed, 16 Jul 2025 16:58:02 -0400
-Subject: [PATCH 4/6] Stub out fast_float for bazel-supplied version
+Subject: [PATCH 4/7] Stub out fast_float for bazel-supplied version
 
 Signed-off-by: Matt Leon <[email protected]>
 ---
@@ -145,7 +145,7 @@ index 0a693b7ee10..eafd9dad20c 100644
 From b442d34b12dd513946f509d9db86839ce8aa4d7f Mon Sep 17 00:00:00 2001
 From: Matt Leon <[email protected]>
 Date: Wed, 16 Jul 2025 20:04:05 -0400
-Subject: [PATCH 5/6] Stub out vendored dependencies for bazel-sourced versions
+Subject: [PATCH 5/7] Stub out vendored dependencies for bazel-sourced versions
 
 Signed-off-by: Matt Leon <[email protected]>
 ---
@@ -177,7 +177,7 @@ index eafd9dad20c..ce36666e36e 100644
 From e0b8f32cc057a3c0875437d5d54d012cabcab458 Mon Sep 17 00:00:00 2001
 From: Matt Leon <[email protected]>
 Date: Wed, 16 Jul 2025 20:29:10 -0400
-Subject: [PATCH 6/6] Add build flags to make V8 compile with GCC
+Subject: [PATCH 6/7] Add build flags to make V8 compile with GCC
 
 Signed-off-by: Matt Leon <[email protected]>
 ---
@@ -201,3 +201,143 @@ index 14d7ace5e59..c7a48d4e805 100644
 -- 
 2.50.0.727.gbf7dc18ff4-goog
 
+
+From 9ae93dd8bccd0519a3b16498af0191693ea5a670 Mon Sep 17 00:00:00 2001
+From: Matt Leon <[email protected]>
+Date: Fri, 18 Jul 2025 17:28:42 -0400
+Subject: [PATCH 7/7] Hack out atomic simd support in V8.
+
+Atomic simdutf requires __cpp_lib_atomic_ref >= 201806, which is only
+supported in clang libc++ 19+. The version of LLVM used in Envoy as of
+2025-07-18 is libc++ 18, so this is not supported.
+
+The simdutf documentation indicates this atomic form is not tested and
+is not recommended for use:
+https://github.com/simdutf/simdutf/blob/5d1b6248f29a8ed0eb90f79be268be41730e39f8/include/simdutf/implementation.h#L3066-L3068
+
+In addition, this is in the implementation of a JS array buffer. Since
+proxy-wasm-cpp-host does not make use of JS array buffers or shared
+memory between web workers, we're stubbing it out.
+
+Mostly reverts
+https://github.com/v8/v8/commit/6d6c1e680c7b8ea5f62a76e9c3d88d3fb0a88df0.
+
+Signed-off-by: Matt Leon <[email protected]>
+---
+ src/builtins/builtins-typed-array.cc |  8 ++++++++
+ src/objects/simd.cc                  | 14 ++++++++++++++
+ 2 files changed, 22 insertions(+)
+
+diff --git a/src/builtins/builtins-typed-array.cc b/src/builtins/builtins-typed-array.cc
+index 918cb873481..a71cb7d70e0 100644
+--- a/src/builtins/builtins-typed-array.cc
++++ b/src/builtins/builtins-typed-array.cc
+@@ -520,17 +520,21 @@ simdutf::result ArrayBufferSetFromBase64(
+     DirectHandle<JSTypedArray> typed_array, size_t& output_length) {
+   output_length = array_length;
+   simdutf::result simd_result;
++#ifdef __cpp_lib_atomic_ref
+   if (typed_array->buffer()->is_shared()) {
+     simd_result = simdutf::atomic_base64_to_binary_safe(
+         reinterpret_cast<const T>(input_vector), input_length,
+         reinterpret_cast<char*>(typed_array->DataPtr()), output_length,
+         alphabet, last_chunk_handling, /*decode_up_to_bad_char*/ true);
+   } else {
++#endif
+     simd_result = simdutf::base64_to_binary_safe(
+         reinterpret_cast<const T>(input_vector), input_length,
+         reinterpret_cast<char*>(typed_array->DataPtr()), output_length,
+         alphabet, last_chunk_handling, /*decode_up_to_bad_char*/ true);
++#ifdef __cpp_lib_atomic_ref
+   }
++#endif
+ 
+   return simd_result;
+ }
+@@ -833,15 +837,19 @@ BUILTIN(Uint8ArrayPrototypeToBase64) {
+     // 11. Return CodePointsToString(outAscii).
+ 
+     size_t simd_result_size;
++#ifdef __cpp_lib_atomic_ref
+     if (uint8array->buffer()->is_shared()) {
+       simd_result_size = simdutf::atomic_binary_to_base64(
+           std::bit_cast<const char*>(uint8array->DataPtr()), length,
+           reinterpret_cast<char*>(output->GetChars(no_gc)), alphabet);
+     } else {
++#endif
+       simd_result_size = simdutf::binary_to_base64(
+           std::bit_cast<const char*>(uint8array->DataPtr()), length,
+           reinterpret_cast<char*>(output->GetChars(no_gc)), alphabet);
++#ifdef __cpp_lib_atomic_ref
+     }
++#endif
+     DCHECK_EQ(simd_result_size, output_length);
+     USE(simd_result_size);
+   }
+diff --git a/src/objects/simd.cc b/src/objects/simd.cc
+index 0ef570ceb7d..01f5cb0d5c9 100644
+--- a/src/objects/simd.cc
++++ b/src/objects/simd.cc
+@@ -32,6 +32,10 @@
+ #include <arm_neon.h>
+ #endif
+ 
++#ifdef __cpp_lib_atomic_ref
++#define HAS_ATOMIC_REF
++#endif
++
+ namespace v8 {
+ namespace internal {
+ 
+@@ -477,6 +481,7 @@ void Uint8ArrayToHexSlow(const char* bytes, size_t length,
+   }
+ }
+ 
++#ifdef HAS_ATOMIC_REF
+ void AtomicUint8ArrayToHexSlow(const char* bytes, size_t length,
+                                DirectHandle<SeqOneByteString> string_output) {
+   int index = 0;
+@@ -492,6 +497,7 @@ void AtomicUint8ArrayToHexSlow(const char* bytes, size_t length,
+     index += 2;
+   }
+ }
++#endif
+ 
+ inline uint16_t ByteToHex(uint8_t byte) {
+   const uint16_t correction = (('a' - '0' - 10) << 8) + ('a' - '0' - 10);
+@@ -645,11 +651,15 @@ Tagged<Object> Uint8ArrayToHex(const char* bytes, size_t length, bool is_shared,
+   }
+ #endif
+ 
++#ifdef HAS_ATOMIC_REF
+   if (is_shared) {
+     AtomicUint8ArrayToHexSlow(bytes, length, string_output);
+   } else {
++#endif
+     Uint8ArrayToHexSlow(bytes, length, string_output);
++#ifdef HAS_ATOMIC_REF
+   }
++#endif
+   return *string_output;
+ }
+ 
+@@ -1082,12 +1092,16 @@ bool ArrayBufferFromHex(const base::Vector<T>& input_vector, bool is_shared,
+   for (uint32_t i = 0; i < output_length * 2; i += 2) {
+     result = HandleRemainingHexValues(input_vector, i);
+     if (result.has_value()) {
++#ifdef HAS_ATOMIC_REF
+       if (is_shared) {
+         std::atomic_ref<uint8_t>(buffer[index++])
+             .store(result.value(), std::memory_order_relaxed);
+       } else {
++#endif
+         buffer[index++] = result.value();
++#ifdef HAS_ATOMIC_REF
+       }
++#endif
+     } else {
+       return false;
+     }
+-- 
+2.50.0.727.gbf7dc18ff4-goog
+