[SAB] Implement SharedArrayBuffer.prototype.slice

src/builtins/builtins-sharedarraybuffer.cc

Index: src/builtins/builtins-sharedarraybuffer.cc
diff --git a/src/builtins/builtins-sharedarraybuffer.cc b/src/builtins/builtins-sharedarraybuffer.cc
index d2b9f1efa96b4bbfc2315986f9f793205b0b3869..c583ec954bc6974127232103973a62381a7e2250 100644
--- a/src/builtins/builtins-sharedarraybuffer.cc
+++ b/src/builtins/builtins-sharedarraybuffer.cc
@@ -10,6 +10,15 @@
 namespace v8 {
 namespace internal {
 
+#define CHECK_IS_SHARED_ARRAY_BUFFER(name, method)                          \
+  if (!name->is_shared()) {                                                 \
+    THROW_NEW_ERROR_RETURN_FAILURE(                                         \
+        isolate,                                                            \
+        NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,          \
+                     isolate->factory()->NewStringFromAsciiChecked(method), \
+                     name));                                                \
+  }
+
 using compiler::Node;
 
 class SharedArrayBufferBuiltinsAssembler : public CodeStubAssembler {
@@ -30,17 +39,138 @@ class SharedArrayBufferBuiltinsAssembler : public CodeStubAssembler {
 
 // ES7 sharedmem 6.3.4.1 get SharedArrayBuffer.prototype.byteLength
 BUILTIN(SharedArrayBufferPrototypeGetByteLength) {
+  const char* const kMethodName = "get SharedArrayBuffer.prototype.byteLength";
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSArrayBuffer, array_buffer,
                  "get SharedArrayBuffer.prototype.byteLength");
-  if (!array_buffer->is_shared()) {
+  CHECK_IS_SHARED_ARRAY_BUFFER(array_buffer, kMethodName);
+  return array_buffer->byte_length();
+}
+
+// ES #sec-sharedarraybuffer.prototype.slice
+// SharedArrayBuffer.prototype.slice ( start, end )
+BUILTIN(SharedArrayBufferPrototypeSlice) {

[Dan Ehrenberg, 2017/03/16 07:45:06]

Would it be possible to reuse most of the implementation of
ArrayBufferPrototypeSlice, just with a different type check at the top?

[binji, 2017/03/16 16:17:00]

I thought so at first, but there are enough differences that it would make
things much harder to read IMO. For example, all the error messages  change, the
species constructor changes, the isShared checks change, and there is no check
for detached buffers either.

[Dan Ehrenberg, 2017/03/17 10:30:44]

Well, I'd still would prefer for it to be de-duplicated. You could pass a flag
for which one it is to do the alternation. But we have a duplicated spec, so I
guess it's not unexpected to turn out like this.

+  const char* const kMethodName = "SharedArrayBuffer.prototype.slice";
+  HandleScope scope(isolate);
+  Handle<Object> start = args.at(1);
+  Handle<Object> end = args.atOrUndefined(isolate, 2);
+
+  // 2. If Type(O) is not Object, throw a TypeError exception.
+  // 3. If O does not have an [[ArrayBufferData]] internal slot, throw a
+  //    TypeError exception.
+  CHECK_RECEIVER(JSArrayBuffer, array_buffer, kMethodName);
+  // 4. If IsSharedArrayBuffer(O) is false, throw a TypeError exception.
+  CHECK_IS_SHARED_ARRAY_BUFFER(array_buffer, kMethodName);
+
+  // 5. Let len be O.[[ArrayBufferByteLength]].
+  double const len = array_buffer->byte_length()->Number();
+
+  // 6. Let relativeStart be ? ToInteger(start).
+  Handle<Object> relative_start;
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, relative_start,
+                                     Object::ToInteger(isolate, start));
+
+  // 7. If relativeStart < 0, let first be max((len + relativeStart), 0); else
+  //    let first be min(relativeStart, len).
+  double const first = (relative_start->Number() < 0)
+                           ? Max(len + relative_start->Number(), 0.0)
+                           : Min(relative_start->Number(), len);
+  Handle<Object> first_obj = isolate->factory()->NewNumber(first);
+
+  // 8. If end is undefined, let relativeEnd be len; else let relativeEnd be ?
+  //    ToInteger(end).
+  double relative_end;
+  if (end->IsUndefined(isolate)) {
+    relative_end = len;
+  } else {
+    Handle<Object> relative_end_obj;
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, relative_end_obj,
+                                       Object::ToInteger(isolate, end));
+    relative_end = relative_end_obj->Number();
+  }
+
+  // 9. If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let
+  //    final be min(relativeEnd, len).
+  double const final_ = (relative_end < 0) ? Max(len + relative_end, 0.0)
+                                           : Min(relative_end, len);
+
+  // 10. Let newLen be max(final-first, 0).
+  double const new_len = Max(final_ - first, 0.0);
+  Handle<Object> new_len_obj = isolate->factory()->NewNumber(new_len);
+
+  // 11. Let ctor be ? SpeciesConstructor(O, %SharedArrayBuffer%).
+  Handle<JSFunction> sharedarraybuffer_fun = isolate->shared_array_buffer_fun();
+  Handle<Object> ctor;
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+      isolate, ctor,
+      Object::SpeciesConstructor(isolate,
+                                 Handle<JSReceiver>::cast(args.receiver()),
+                                 sharedarraybuffer_fun));
+
+  // 12. Let new be ? Construct(ctor, newLen).
+  Handle<JSReceiver> new_;
+  {
+    const int argc = 1;
+
+    ScopedVector<Handle<Object>> argv(argc);
+    argv[0] = new_len_obj;
+
+    Handle<Object> new_obj;
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+        isolate, new_obj,
+        Execution::New(Handle<JSFunction>::cast(ctor), argc, argv.start()));
+
+    new_ = Handle<JSReceiver>::cast(new_obj);
+  }
+
+  // 13. If new does not have an [[ArrayBufferData]] internal slot, throw a
+  //     TypeError exception.
+  if (!new_->IsJSArrayBuffer()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
-                              isolate->factory()->NewStringFromAsciiChecked(
-                                  "get SharedArrayBuffer.prototype.byteLength"),
-                              args.receiver()));
+        isolate,
+        NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
+                     isolate->factory()->NewStringFromAsciiChecked(kMethodName),
+                     new_));
   }
-  return array_buffer->byte_length();
+
+  // 14. If IsSharedArrayBuffer(new) is false, throw a TypeError exception.
+  Handle<JSArrayBuffer> new_array_buffer = Handle<JSArrayBuffer>::cast(new_);
+  CHECK_IS_SHARED_ARRAY_BUFFER(new_array_buffer, kMethodName);
+
+  // 15. If new.[[ArrayBufferData]] and O.[[ArrayBufferData]] are the same
+  //     Shared Data Block values, throw a TypeError exception.
+  if (new_array_buffer->backing_store() == array_buffer->backing_store()) {
+    THROW_NEW_ERROR_RETURN_FAILURE(
+        isolate, NewTypeError(MessageTemplate::kSharedArrayBufferSpeciesThis));
+  }
+
+  // 16. If new.[[ArrayBufferByteLength]] < newLen, throw a TypeError exception.
+  if (new_array_buffer->byte_length()->Number() < new_len) {
+    THROW_NEW_ERROR_RETURN_FAILURE(
+        isolate, NewTypeError(MessageTemplate::kSharedArrayBufferTooShort));
+  }
+
+  // 17. Let fromBuf be O.[[ArrayBufferData]].
+  // 18. Let toBuf be new.[[ArrayBufferData]].
+  // 19. Perform CopyDataBlockBytes(toBuf, 0, fromBuf, first, newLen).
+  size_t first_size = 0, new_len_size = 0;
+  CHECK(TryNumberToSize(*first_obj, &first_size));
+  CHECK(TryNumberToSize(*new_len_obj, &new_len_size));
+  DCHECK(NumberToSize(new_array_buffer->byte_length()) >= new_len_size);
+
+  if (new_len_size != 0) {
+    size_t from_byte_length = NumberToSize(array_buffer->byte_length());
+    USE(from_byte_length);
+    DCHECK(first_size <= from_byte_length);
+    DCHECK(from_byte_length - first_size >= new_len_size);
+    uint8_t* from_data =
+        reinterpret_cast<uint8_t*>(array_buffer->backing_store());
+    uint8_t* to_data =
+        reinterpret_cast<uint8_t*>(new_array_buffer->backing_store());
+    CopyBytes(to_data, from_data + first_size, new_len_size);
+  }
+
+  return *new_;
 }
 
 void SharedArrayBufferBuiltinsAssembler::ValidateSharedTypedArray(