deps: V8: add CopyArrayBufferBytes API

Add v8::ArrayBuffer::CopyArrayBufferBytes and
v8::SharedArrayBuffer::CopyArrayBufferBytes, which copy a byte range
from one backing store to another. V8 clamps the byte range and handles
detached and immutable buffers: nothing is copied when the source is
detached or the target is detached or immutable, and the number of bytes
actually copied is returned. The SharedArrayBuffer overload uses a
relaxed-atomic memmove that honors the SharedArrayBuffer memory model.
Carried as a floating patch cherry-picked from:
https://chromium-review.googlesource.com/c/v8/v8/+/7735151
That CL is authored by a Node.js collaborator (Ben Noordhuis) and is
expected to land upstream, so the floating patch should be easy to
maintain: it touches nothing but the public ArrayBuffer API and can be
dropped wholesale on the next V8 upgrade that includes it.
v8_embedder_string is bumped to -node.21 accordingly.
Refs: https://chromium-review.googlesource.com/c/v8/v8/+/7735151
Signed-off-by: Robert Nagy <ronagy@icloud.com>
PR-URL: #63828
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: René <contact.9a5d6388@renegade334.me.uk>

Author: ronag

common.gypi

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

deps/v8/include/v8-array-buffer.h

@@ -338,6 +338,17 @@ class V8_EXPORT ArrayBuffer : public Object {
 */
 boolIsImmutable() const;
 
+/**
+ * Copy up to |bytes_to_copy| bytes from this ArrayBuffer starting at
+ * position |source_start| to the target ArrayBuffer starting at position
+ * |target_start|. Nothing is copied if the source ArrayBuffer is detached,
+ * or if the target ArrayBuffer is detached or immutable.
+ * Returns the number of bytes actually copied.
+*/
+size_tCopyArrayBufferBytes(size_t source_start, size_t bytes_to_copy,
+ Local<ArrayBuffer> target,
+size_t target_start) const;
+
 /**
  * Detaches this ArrayBuffer and all its views (typed arrays).
  * Detaching sets the byte length of the buffer and all typed arrays to zero,
@@ -605,6 +616,16 @@ class V8_EXPORT SharedArrayBuffer : public Object {
 */
 void* Data() const;
 
+/**
+ * Copy up to |bytes_to_copy| bytes from this SharedArrayBuffer starting at
+ * position |source_start| to the target SharedArrayBuffer starting at
+ * position |target_start|.
+ * Returns the number of bytes actually copied.
+*/
+size_tCopyArrayBufferBytes(size_t source_start, size_t bytes_to_copy,
+ Local<SharedArrayBuffer> target,
+size_t target_start) const;
+
 V8_INLINEstatic SharedArrayBuffer* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
 CheckCast(value);

deps/v8/src/api/api.cc

@@ -4221,6 +4221,44 @@ void* v8::SharedArrayBuffer::Data() const {
 returnUtils::OpenDirectHandle(this)->backing_store();
 }
 
+template <bool is_shared>
+staticsize_tCopyArrayBufferBytesImpl(constvoid* source_buffer,
+size_t source_start,
+size_t source_length,
+void* target_buffer, size_t target_start,
+size_t target_length,
+size_t bytes_to_copy) {
+ source_start = std::min(source_start, source_length);
+ target_start = std::min(target_start, target_length);
+size_t source_size = source_length - source_start;
+size_t target_size = target_length - target_start;
+ bytes_to_copy = std::min({bytes_to_copy, source_size, target_size});
+if (bytes_to_copy == 0) return0;
+constchar* src = static_cast<constchar*>(source_buffer) + source_start;
+char* dst = static_cast<char*>(target_buffer) + target_start;
+if (is_shared) {
+base::Relaxed_Memmove(reinterpret_cast<base::Atomic8*>(dst),
+reinterpret_cast<const base::Atomic8*>(src),
+ bytes_to_copy);
+ } else {
+std::memmove(dst, src, bytes_to_copy);
+ }
+return bytes_to_copy;
+}
+
+size_tv8::SharedArrayBuffer::CopyArrayBufferBytes(
+size_t source_start, size_t bytes_to_copy, Local<SharedArrayBuffer> target,
+size_t target_start) const {
+ i::DisallowGarbageCollection no_gc;
+auto self = Utils::OpenDirectHandle(this);
+auto that = Utils::OpenDirectHandle(*target);
+DCHECK(!that->is_immutable());
+return CopyArrayBufferBytesImpl<true>(self->backing_store(), source_start,
+ self->GetByteLength(),
+ that->backing_store(), target_start,
+ that->GetByteLength(), bytes_to_copy);
+}
+
 voidv8::ArrayBuffer::CheckCast(Value* that) {
 auto obj = *Utils::OpenDirectHandle(that);
 Utils::ApiCheck(
@@ -8907,6 +8945,21 @@ bool v8::ArrayBuffer::IsImmutable() const {
 returnUtils::OpenDirectHandle(this)->is_immutable();
 }
 
+size_tv8::ArrayBuffer::CopyArrayBufferBytes(size_t source_start,
+size_t bytes_to_copy,
+ Local<ArrayBuffer> target,
+size_t target_start) const {
+ i::DisallowGarbageCollection no_gc;
+auto self = Utils::OpenDirectHandle(this);
+auto that = Utils::OpenDirectHandle(*target);
+if (self->was_detached()) return0;
+if (that->was_detached() || that->is_immutable()) return0;
+return CopyArrayBufferBytesImpl<false>(self->backing_store(), source_start,
+ self->GetByteLength(),
+ that->backing_store(), target_start,
+ that->GetByteLength(), bytes_to_copy);
+}
+
 namespace {
 std::shared_ptr<i::BackingStore> ToInternal(
  std::shared_ptr<i::BackingStoreBase> backing_store) {

deps/v8/test/cctest/test-api-array-buffer.cc

@@ -1301,3 +1301,53 @@ TEST(ArrayBuffer_ImmutableBackingStore) {
 
 CHECK(ab->IsImmutable());
 }
+
+TEST(ArrayBuffer_CopyArrayBufferBytes) {
+ LocalContext env;
+ v8::Isolate* isolate = env.isolate();
+ v8::HandleScope scope(isolate);
+auto ab1 = v8::ArrayBuffer::New(isolate, 6);
+auto ab2 = v8::ArrayBuffer::New(isolate, 4);
+std::memcpy(ab1->Data(), "123456", 6);
+std::memcpy(ab2->Data(), "ABCD", 4);
+CHECK_EQ(0, ab1->CopyArrayBufferBytes(0, 0, ab2, 0));
+CHECK_EQ(0, ab1->CopyArrayBufferBytes(6, 0, ab2, 6));
+CHECK_EQ(0, ab1->CopyArrayBufferBytes(0, 4, ab2, 6));
+CHECK_EQ(0, std::memcmp(ab2->Data(), "ABCD", 4));
+CHECK_EQ(4, ab1->CopyArrayBufferBytes(0, 6, ab2, 0));
+CHECK_EQ(0, std::memcmp(ab2->Data(), "1234", 4));
+CHECK_EQ(2, ab1->CopyArrayBufferBytes(0, 6, ab2, 2));
+CHECK_EQ(0, std::memcmp(ab2->Data(), "1212", 4));
+ ab2->Detach(v8::Local<v8::Value>()).Check();
+CHECK_EQ(0, ab1->CopyArrayBufferBytes(0, 6, ab2, 0));
+ std::unique_ptr<v8::BackingStore> backing_store =
+v8::ArrayBuffer::NewBackingStore(isolate, 6);
+CHECK(backing_store);
+ v8::internal::BackingStore* i_backing_store =
+reinterpret_cast<v8::internal::BackingStore*>(backing_store.get());
+ i_backing_store->set_is_immutable(true);
+CHECK(i_backing_store->is_immutable());
+ std::shared_ptr<v8::BackingStore> shared_backing_store =
+std::move(backing_store);
+auto ab3 = v8::ArrayBuffer::New(isolate, shared_backing_store);
+CHECK(ab3->IsImmutable());
+CHECK_EQ(0, ab1->CopyArrayBufferBytes(0, 6, ab3, 0));
+}
+
+TEST(SharedArrayBuffer_CopyArrayBufferBytes) {
+ LocalContext env;
+ v8::Isolate* isolate = env.isolate();
+ v8::HandleScope scope(isolate);
+auto ab1 = v8::SharedArrayBuffer::New(isolate, 6);
+auto ab2 = v8::SharedArrayBuffer::New(isolate, 4);
+std::memcpy(ab1->Data(), "123456", 6);
+std::memcpy(ab2->Data(), "ABCD", 4);
+CHECK_EQ(0, ab1->CopyArrayBufferBytes(0, 0, ab2, 0));
+CHECK_EQ(0, ab1->CopyArrayBufferBytes(6, 0, ab2, 6));
+CHECK_EQ(0, ab1->CopyArrayBufferBytes(0, 4, ab2, 6));
+CHECK_EQ(0, std::memcmp(ab2->Data(), "ABCD", 4));
+CHECK_EQ(4, ab1->CopyArrayBufferBytes(0, 6, ab2, 0));
+CHECK_EQ(0, std::memcmp(ab2->Data(), "1234", 4));
+CHECK_EQ(2, ab1->CopyArrayBufferBytes(0, 6, ab2, 2));
+CHECK_EQ(0, std::memcmp(ab2->Data(), "1212", 4));
+}