[SAB] Implement SharedArrayBuffer.prototype.slice

src/builtins/builtins-sharedarraybuffer.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 
 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 {
  public:
   explicit SharedArrayBufferBuiltinsAssembler(
       compiler::CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 
  protected:
   void ValidateSharedTypedArray(Node* tagged, Node* context,
                                 Node** out_instance_type,
                                 Node** out_backing_store);
   Node* ConvertTaggedAtomicIndexToWord32(Node* tagged, Node* context,
                                          Node** number_index);
   void ValidateAtomicIndex(Node* index_word, Node* array_length_word,
                            Node* context);
 };
 
 // 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()) {
-    THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
-                              isolate->factory()->NewStringFromAsciiChecked(
-                                  "get SharedArrayBuffer.prototype.byteLength"),
-                              args.receiver()));
-  }
+  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(kMethodName),
+                     new_));
+  }
+
+  // 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(
     Node* tagged, Node* context, Node** out_instance_type,
     Node** out_backing_store) {
   Label not_float_or_clamped(this), invalid(this);
 
   // Fail if it is not a heap object.
   GotoIf(TaggedIsSmi(tagged), &invalid);
 
   // Fail if the array's instance type is not JSTypedArray.
   GotoIf(Word32NotEqual(LoadInstanceType(tagged),
@@ skipping 276 matching lines @@
 
   // This shouldn't happen, we've already validated the type.
   Bind(&other);
   Unreachable();
 #endif  // V8_TARGET_ARCH_MIPS || V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC64
         // || V8_TARGET_ARCH_PPC || V8_TARGET_ARCH_S390 || V8_TARGET_ARCH_S390X
 }
 
 }  // namespace internal
 }  // namespace v8