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

src/builtins/builtins-typedarray.cc

Index: src/builtins/builtins-typedarray.cc
diff --git a/src/builtins/builtins-typedarray.cc b/src/builtins/builtins-typedarray.cc
index 5f061651584c9cf02c896cf8fe4e48bc38f62d83..2c49ed2ffbf6b2fe6ddf6b84dd64afb584263b31 100644
--- a/src/builtins/builtins-typedarray.cc
+++ b/src/builtins/builtins-typedarray.cc
@@ -464,8 +464,6 @@ BUILTIN(TypedArrayPrototypeCopyWithin) {
   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;
@@ -521,6 +519,99 @@ BUILTIN(TypedArrayPrototypeCopyWithin) {
   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);