Migrate %TypedArray%.prototype.fill to C++

src/builtins/builtins-typedarray.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-stub-assembler.h"
 #include "src/counters.h"
 #include "src/elements.h"
 #include "src/objects-inl.h"
@@ skipping 446 matching lines @@
 }  // namespace
 
 BUILTIN(TypedArrayPrototypeCopyWithin) {
   HandleScope scope(isolate);
 
   Handle<JSTypedArray> array;
   const char* method = "%TypedArray%.prototype.copyWithin";
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
 
-  if (V8_UNLIKELY(array->WasNeutered())) return *array;
-
   int64_t len = array->length_value();
   int64_t to = 0;
   int64_t from = 0;
   int64_t final = len;
 
   if (V8_LIKELY(args.length() > 1)) {
     Handle<Object> num;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
         isolate, num, Object::ToInteger(isolate, args.at<Object>(1)));
     to = CapRelativeIndex(num, 0, len);
@@ skipping 35 matching lines @@
   to = to * element_size;
   from = from * element_size;
   count = count * element_size;
 
   uint8_t* data = static_cast<uint8_t*>(elements->DataPtr());
   std::memmove(data + to, data + from, count);
 
   return *array;
 }
 
+BUILTIN(TypedArrayPrototypeFill) {
+  HandleScope scope(isolate);
+
+  Handle<JSTypedArray> array;
+  const char* method = "%TypedArray%.prototype.fill";
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+      isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
+
+  int64_t len = array->length_value();
+  int64_t start = 0;
+  int64_t end = len;
+
+  if (args.length() > 2) {
+    Handle<Object> num = args.atOrUndefined(isolate, 2);
+    if (!num->IsUndefined(isolate)) {
+      ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+          isolate, num, Object::ToInteger(isolate, num));
+      start = CapRelativeIndex(num, 0, len);
+
+      num = args.atOrUndefined(isolate, 3);
+      if (!num->IsUndefined(isolate)) {
+        ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+            isolate, num, Object::ToInteger(isolate, num));
+        end = CapRelativeIndex(num, 0, len);
+      }
+    }
+  }
+
+  int64_t count = end - start;
+  if (count <= 0) return *array;
+
+  if (V8_UNLIKELY(array->WasNeutered())) return *array;
+
+  // Ensure processed indexes are within array bounds
+  DCHECK_GE(start, 0);
+  DCHECK_LT(start, len);
+  DCHECK_GE(end, 0);
+  DCHECK_LE(end, len);
+  DCHECK_LE(count, len);
+
+  Handle<Object> obj_value = args.at<Object>(1);
+
+  if (obj_value->IsNumber()) {
+    double value = 0.0;
+
+    if (obj_value->IsSmi()) {
+      value = Smi::cast(*obj_value)->value();
+    } else {
+      DCHECK(obj_value->IsHeapNumber());
+      value = HeapNumber::cast(*obj_value)->value();
+    }
+    if (array->type() == kExternalUint8ClampedArray) {
+      value = std::min<double>(std::max<double>(0, value), 255);
+    }
+
+    Handle<FixedTypedArrayBase> elements(
+        FixedTypedArrayBase::cast(array->elements()));
+    switch (array->type()) {
+#define TYPED_ARRAY_FILL(Type, type, TYPE, ctype, size)       \
+    case kExternal##Type##Array: {                            \
+      ctype* data = static_cast<ctype*>(elements->DataPtr()); \
+      ctype cast_value = static_cast<ctype>(value);           \
+      std::fill(data + start, data + end, cast_value);        \
+      break;                                                  \
+    }
+
+      TYPED_ARRAYS(TYPED_ARRAY_FILL)
+#undef TYPED_ARRAY_FILL
+    }
+  } else {
+    ElementsAccessor* elements = array->GetElementsAccessor();
+

[Camillo Bruni, 2017/03/09 12:11:08]

Could you put the following code inside the ElementsAccessor?

You can follow the path which ends up calling IndexOfValueSlowPath.

The final call should like as follows:
array->GetElementsAccessor()->Fill(obj_value, start, end)

Inernally in ElementsAccessor you will have all implementations for fill for
different ElementsKind. You could even put the default implementation from above
on the ElementsAccessor. In the slow case when !obj_value->IsNumber() you fall
back to FillSlowPath for typed arrays.

+    Handle<Object> cast_value;
+    uint32_t start32 = static_cast<uint32_t>(start);
+    uint32_t end32 = static_cast<uint32_t>(end);
+
+    for (uint32_t k = start32; k < end32; ++k) {
+      ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+          isolate, cast_value, Object::ToNumber(obj_value));
+      // IntegerIndexedElementSet step 5
+      if (V8_UNLIKELY(array->WasNeutered())) {
+        THROW_NEW_ERROR_RETURN_FAILURE(
+            isolate, NewTypeError(MessageTemplate::kDetachedOperation,
+                                  isolate->factory()->NewStringFromAsciiChecked(
+                                  method)));
+      }
+      elements->Set(array, k, *cast_value);
+    }
+  }
+
+  return *array;
+}
+
 BUILTIN(TypedArrayPrototypeIncludes) {
   HandleScope scope(isolate);
 
   Handle<JSTypedArray> array;
   const char* method = "%TypedArray%.prototype.includes";
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
 
   if (args.length() < 2) return isolate->heap()->false_value();
 
@@ skipping 12 matching lines @@
   Handle<Object> search_element = args.at<Object>(1);
   ElementsAccessor* elements = array->GetElementsAccessor();
   Maybe<bool> result = elements->IncludesValue(isolate, array, search_element,
                                                static_cast<uint32_t>(index),
                                                static_cast<uint32_t>(len));
   return *isolate->factory()->ToBoolean(result.FromJust());
 }
 
 }  // namespace internal
 }  // namespace v8