deps: V8: revert 6d6c1e680c7b

It depends on `std::atomic_ref`, which is not available in Xcode 16.1.

Refs: v8/v8@6d6c1e6
PR-URL: nodejs#58064
Reviewed-By: Antoine du Hamel <[email protected]>
Reviewed-By: Richard Lau <[email protected]>
Reviewed-By: Darshan Sen <[email protected]>
Reviewed-By: Marco Ippolito <[email protected]>
Reviewed-By: Paolo Insogna <[email protected]>
Reviewed-By: Yagiz Nizipli <[email protected]>

Author: targos

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.7',
+    'v8_embedder_string': '-node.8',
 
     ##### V8 defaults for Node.js #####
 

deps/v8/src/builtins/builtins-typed-array.cc

@@ -898,14 +898,14 @@ BUILTIN(Uint8ArrayFromHex) {
         base::Vector<const uint8_t> input_vector =
             input_content.ToOneByteVector();
         result = ArrayBufferFromHex(
-            input_vector, /*is_shared*/ false,
-            static_cast<uint8_t*>(buffer->backing_store()), output_length);
+            input_vector, static_cast<uint8_t*>(buffer->backing_store()),
+            output_length);
       } else {
         base::Vector<const base::uc16> input_vector =
             input_content.ToUC16Vector();
         result = ArrayBufferFromHex(
-            input_vector, /*is_shared*/ false,
-            static_cast<uint8_t*>(buffer->backing_store()), output_length);
+            input_vector, static_cast<uint8_t*>(buffer->backing_store()),
+            output_length);
       }
   }
 
@@ -982,6 +982,11 @@ BUILTIN(Uint8ArrayPrototypeSetFromHex) {
   size_t output_length = (input_length / 2);
   output_length = std::min(output_length, array_length);
 
+  // TODO(rezvan): Add path for typed arrays backed by SharedArrayBuffer
+  if (uint8array->buffer()->is_shared()) {
+    UNIMPLEMENTED();
+  }
+
   // 7. Let result be FromHex(string, byteLength).
   // 8. Let bytes be result.[[Bytes]].
   // 9. Let written be the length of bytes.
@@ -997,15 +1002,15 @@ BUILTIN(Uint8ArrayPrototypeSetFromHex) {
     if (input_content.IsOneByte()) {
       base::Vector<const uint8_t> input_vector =
           input_content.ToOneByteVector();
-      result = ArrayBufferFromHex(
-          input_vector, uint8array->buffer()->is_shared(),
-          static_cast<uint8_t*>(uint8array->DataPtr()), output_length);
+      result = ArrayBufferFromHex(input_vector,
+                                  static_cast<uint8_t*>(uint8array->DataPtr()),
+                                  output_length);
     } else {
       base::Vector<const base::uc16> input_vector =
           input_content.ToUC16Vector();
-      result = ArrayBufferFromHex(
-          input_vector, uint8array->buffer()->is_shared(),
-          static_cast<uint8_t*>(uint8array->DataPtr()), output_length);
+      result = ArrayBufferFromHex(input_vector,
+                                  static_cast<uint8_t*>(uint8array->DataPtr()),
+                                  output_length);
     }
   }
 
@@ -1076,8 +1081,7 @@ BUILTIN(Uint8ArrayPrototypeToHex) {
   //    b. Set hex to StringPad(hex, 2, "0", start).
   //    c. Set out to the string-concatenation of out and hex.
   //  6. Return out.
-  return Uint8ArrayToHex(bytes, length, uint8array->buffer()->is_shared(),
-                         output);
+  return Uint8ArrayToHex(bytes, length, output);
 }
 
 }  // namespace internal

deps/v8/src/objects/simd.cc

@@ -458,38 +458,16 @@ char NibbleToHex(uint8_t nibble) {
   return c + (mask & correction);
 }
 
-void PerformNibbleToHexAndWriteIntoStringOutPut(
-    uint8_t byte, int index, DirectHandle<SeqOneByteString> string_output) {
-  uint8_t high = byte >> 4;
-  uint8_t low = byte & 0x0F;
-
-  string_output->SeqOneByteStringSet(index++, NibbleToHex(high));
-  string_output->SeqOneByteStringSet(index, NibbleToHex(low));
-}
-
 void Uint8ArrayToHexSlow(const char* bytes, size_t length,
                          DirectHandle<SeqOneByteString> string_output) {
   int index = 0;
   for (size_t i = 0; i < length; i++) {
     uint8_t byte = bytes[i];
-    PerformNibbleToHexAndWriteIntoStringOutPut(byte, index, string_output);
-    index += 2;
-  }
-}
+    uint8_t high = byte >> 4;
+    uint8_t low = byte & 0x0F;
 
-void AtomicUint8ArrayToHexSlow(const char* bytes, size_t length,
-                               DirectHandle<SeqOneByteString> string_output) {
-  int index = 0;
-  // std::atomic_ref<T> must not have a const T, see
-  // https://cplusplus.github.io/LWG/issue3508
-  // we instead provide a mutable input, which is ok since we are only reading
-  // from it.
-  char* mutable_bytes = const_cast<char*>(bytes);
-  for (size_t i = 0; i < length; i++) {
-    uint8_t byte =
-        std::atomic_ref<char>(mutable_bytes[i]).load(std::memory_order_relaxed);
-    PerformNibbleToHexAndWriteIntoStringOutPut(byte, index, string_output);
-    index += 2;
+    string_output->SeqOneByteStringSet(index++, NibbleToHex(high));
+    string_output->SeqOneByteStringSet(index++, NibbleToHex(low));
   }
 }
 
@@ -618,14 +596,11 @@ void Uint8ArrayToHexFastWithNeon(const char* bytes, uint8_t* output,
 #endif
 }  // namespace
 
-Tagged<Object> Uint8ArrayToHex(const char* bytes, size_t length, bool is_shared,
+Tagged<Object> Uint8ArrayToHex(const char* bytes, size_t length,
                                DirectHandle<SeqOneByteString> string_output) {
-  // TODO(rezvan): Add relaxed version for simd methods to handle shared array
-  // buffers.
-
 #ifdef __SSE3__
-  if (!is_shared && (get_vectorization_kind() == SimdKinds::kAVX2 ||
-                     get_vectorization_kind() == SimdKinds::kSSE)) {
+  if (get_vectorization_kind() == SimdKinds::kAVX2 ||
+      get_vectorization_kind() == SimdKinds::kSSE) {
     {
       DisallowGarbageCollection no_gc;
       Uint8ArrayToHexFastWithSSE(bytes, string_output->GetChars(no_gc), length);
@@ -635,7 +610,7 @@ Tagged<Object> Uint8ArrayToHex(const char* bytes, size_t length, bool is_shared,
 #endif
 
 #ifdef NEON64
-  if (!is_shared && get_vectorization_kind() == SimdKinds::kNeon) {
+  if (get_vectorization_kind() == SimdKinds::kNeon) {
     {
       DisallowGarbageCollection no_gc;
       Uint8ArrayToHexFastWithNeon(bytes, string_output->GetChars(no_gc),
@@ -645,11 +620,7 @@ Tagged<Object> Uint8ArrayToHex(const char* bytes, size_t length, bool is_shared,
   }
 #endif
 
-  if (is_shared) {
-    AtomicUint8ArrayToHexSlow(bytes, length, string_output);
-  } else {
-    Uint8ArrayToHexSlow(bytes, length, string_output);
-  }
+  Uint8ArrayToHexSlow(bytes, length, string_output);
   return *string_output;
 }
 
@@ -1055,24 +1026,21 @@ bool Uint8ArrayFromHexWithNeon(const base::Vector<T>& input_vector,
 }  // namespace
 
 template <typename T>
-bool ArrayBufferFromHex(const base::Vector<T>& input_vector, bool is_shared,
-                        uint8_t* buffer, size_t output_length) {
+bool ArrayBufferFromHex(const base::Vector<T>& input_vector, uint8_t* buffer,
+                        size_t output_length) {
   size_t input_length = input_vector.size();
   USE(input_length);
   DCHECK_LE(output_length, input_length / 2);
 
-  // TODO(rezvan): Add relaxed version for simd methods to handle shared array
-  // buffers.
-
 #ifdef __SSE3__
-  if (!is_shared && (get_vectorization_kind() == SimdKinds::kAVX2 ||
-                     get_vectorization_kind() == SimdKinds::kSSE)) {
+  if (get_vectorization_kind() == SimdKinds::kAVX2 ||
+      get_vectorization_kind() == SimdKinds::kSSE) {
     return Uint8ArrayFromHexWithSSE(input_vector, buffer, output_length);
   }
 #endif
 
 #ifdef NEON64
-  if (!is_shared && get_vectorization_kind() == SimdKinds::kNeon) {
+  if (get_vectorization_kind() == SimdKinds::kNeon) {
     return Uint8ArrayFromHexWithNeon(input_vector, buffer, output_length);
   }
 #endif
@@ -1082,12 +1050,7 @@ 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()) {
-      if (is_shared) {
-        std::atomic_ref<uint8_t>(buffer[index++])
-            .store(result.value(), std::memory_order_relaxed);
-      } else {
-        buffer[index++] = result.value();
-      }
+      buffer[index++] = result.value();
     } else {
       return false;
     }
@@ -1096,11 +1059,11 @@ bool ArrayBufferFromHex(const base::Vector<T>& input_vector, bool is_shared,
 }
 
 template bool ArrayBufferFromHex(
-    const base::Vector<const uint8_t>& input_vector, bool is_shared,
-    uint8_t* buffer, size_t output_length);
+    const base::Vector<const uint8_t>& input_vector, uint8_t* buffer,
+    size_t output_length);
 template bool ArrayBufferFromHex(
-    const base::Vector<const base::uc16>& input_vector, bool is_shared,
-    uint8_t* buffer, size_t output_length);
+    const base::Vector<const base::uc16>& input_vector, uint8_t* buffer,
+    size_t output_length);
 
 #ifdef NEON64
 #undef NEON64

deps/v8/src/objects/simd.h

@@ -20,11 +20,11 @@ uintptr_t ArrayIndexOfIncludesSmiOrObject(Address array_start,
 uintptr_t ArrayIndexOfIncludesDouble(Address array_start, uintptr_t array_len,
                                      uintptr_t from_index,
                                      Address search_element);
-Tagged<Object> Uint8ArrayToHex(const char* bytes, size_t length, bool is_shared,
+Tagged<Object> Uint8ArrayToHex(const char* bytes, size_t length,
                                DirectHandle<SeqOneByteString> string_output);
 template <typename T>
-bool ArrayBufferFromHex(const base::Vector<T>& input_vector, bool is_shared,
-                        uint8_t* buffer, size_t output_length);
+bool ArrayBufferFromHex(const base::Vector<T>& input_vector, uint8_t* buffer,
+                        size_t output_length);
 
 }  // namespace internal
 }  // namespace v8