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

src/elements.cc

 // Copyright 2012 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/elements.h"
 
 #include "src/arguments.h"
 #include "src/conversions.h"
 #include "src/factory.h"
 #include "src/isolate-inl.h"
@@ skipping 452 matching lines @@
   } cmp;
   Object** start =
       reinterpret_cast<Object**>(indices->GetFirstElementAddress());
   std::sort(start, start + sort_size, cmp);
   if (write_barrier_mode != SKIP_WRITE_BARRIER) {
     FIXED_ARRAY_ELEMENTS_WRITE_BARRIER(indices->GetIsolate()->heap(), *indices,
                                        0, sort_size);
   }
 }
 
+static Object* FillNumberSlowPath(Isolate* isolate, Handle<JSTypedArray> array,
+                               Handle<Object> obj_value,
+                               uint32_t start, uint32_t end) {
+  const char* kMethodName = "%TypedArray%.prototype.fill";
+  Handle<Object> cast_value;
+  ElementsAccessor* elements = array->GetElementsAccessor();
+
+  for (uint32_t k = start; k < end; ++k) {
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+        isolate, cast_value, Object::ToNumber(obj_value));
+    // TODO(caitp,cbruni): throw on neutered array
+    if (V8_UNLIKELY(array->WasNeutered())) return *array;
+    elements->Set(array, k, *cast_value);
+  }
+  return *array;
+}
+
 static Maybe<bool> IncludesValueSlowPath(Isolate* isolate,
                                          Handle<JSObject> receiver,
                                          Handle<Object> value,
                                          uint32_t start_from, uint32_t length) {
   bool search_for_hole = value->IsUndefined(isolate);
   for (uint32_t k = start_from; k < length; ++k) {
     LookupIterator it(isolate, receiver, k);
     if (!it.IsFound()) {
       if (search_for_hole) return Just(true);
       continue;
@@ skipping 701 matching lines @@
 
   static uint32_t GetCapacityImpl(JSObject* holder,
                                   FixedArrayBase* backing_store) {
     return backing_store->length();
   }
 
   uint32_t GetCapacity(JSObject* holder, FixedArrayBase* backing_store) final {
     return Subclass::GetCapacityImpl(holder, backing_store);
   }
 
+  static Object* FillImpl(Isolate* isolate, Handle<JSObject> receiver,
+                       Handle<Object> obj_value, uint32_t start, uint32_t end) {
+    UNREACHABLE();
+    return *receiver;
+  }
+
+  Object* Fill(Isolate* isolate, Handle<JSObject> receiver,
+            Handle<Object> obj_value, uint32_t start, uint32_t end) {
+    return Subclass::FillImpl(isolate, receiver, obj_value, start, end);
+  }
+
   static Maybe<bool> IncludesValueImpl(Isolate* isolate,
                                        Handle<JSObject> receiver,
                                        Handle<Object> value,
                                        uint32_t start_from, uint32_t length) {
     return IncludesValueSlowPath(isolate, receiver, value, start_from, length);
   }
 
   Maybe<bool> IncludesValue(Isolate* isolate, Handle<JSObject> receiver,
                             Handle<Object> value, uint32_t start_from,
                             uint32_t length) final {
@@ skipping 1604 matching lines @@
         if (get_entries) {
           value = MakeEntryPair(isolate, index, value);
         }
         values_or_entries->set(count++, *value);
       }
     }
     *nof_items = count;
     return Just(true);
   }
 
+  template <typename T>
+  static inline uint8_t MaybeClamp(
+      Handle<Object> obj_value, JSTypedArray* array,
+      typename std::enable_if<std::is_same<T, uint8_t>::value, uint8_t>::type =
+          0) {
+    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);
+    }
+    return static_cast<uint8_t>(value);
+  }
+
+  template <typename T>
+  static inline T MaybeClamp(
+      Handle<Object> obj_value, JSTypedArray* array,
+      typename std::enable_if<!std::is_same<T, uint8_t>::value, uint8_t>::type =
+          0) {
+    T value = 0;
+    if (obj_value->IsSmi()) {
+      value = static_cast<T>(Smi::cast(*obj_value)->value());
+    } else {
+      DCHECK(obj_value->IsHeapNumber());
+      value = static_cast<T>(HeapNumber::cast(*obj_value)->value());
+    }
+    return value;
+  }
+
+  static Object* FillImpl(Isolate* isolate, Handle<JSObject> receiver,
+                       Handle<Object> obj_value, uint32_t start, uint32_t end) {
+    Handle<JSTypedArray> array = Handle<JSTypedArray>::cast(receiver);

[Camillo Bruni, 2017/03/13 15:58:14]

Another nit, please add: 
DHECK(!array->WasNeutered());

[rongjie, 2017/03/14 00:18:07]

Done.

+
+    if (!obj_value->IsNumber()) {
+      return FillNumberSlowPath(isolate, array, obj_value, start, end);
+    }
+
+    ctype value = MaybeClamp<ctype>(obj_value, *array);

[Camillo Bruni, 2017/03/13 15:58:14]

Sorry, didn't spot that before eather.
The compiler will take care of this, that the "beauty" of the CRTP:

    if (Kind == UINT8_CLAMPED_ELEMENTS) {
      value = std::min<double>(std::max<double>(0, value), 255);
    }

Kind is already a statically known template param here, so no need to create the
helpers.

[rongjie, 2017/03/14 00:18:07]

Use "Kind == UINT8_CLAMPED_ELEMENTS" done. This make the std::enable_if even
better, only Uint8ClampedArray will match the first template case.

value must only be casted back to uint8_t after clamping, otherwise
overflow/underflow will occur before clamping.

+
+    // Ensure indexes are within array bounds
+    DCHECK_LE(0, start);
+    DCHECK_LE(start, end);
+    DCHECK_LE(end, array->length_value());
+
+    DisallowHeapAllocation no_gc;
+    BackingStore* elements = BackingStore::cast(receiver->elements());
+    ctype* data = static_cast<ctype*>(elements->DataPtr());
+    std::fill(data + start, data + end, value);
+    return *array;
+  }
+
   static Maybe<bool> IncludesValueImpl(Isolate* isolate,
                                        Handle<JSObject> receiver,
                                        Handle<Object> value,
                                        uint32_t start_from, uint32_t length) {
     DCHECK(JSObject::PrototypeHasNoElements(isolate, *receiver));
     DisallowHeapAllocation no_gc;
 
     // TODO(caitp): return Just(false) here when implementing strict throwing on
     // neutered views.
     if (WasNeutered(*receiver)) {
@@ skipping 1037 matching lines @@
     insertion_index += len;
   }
 
   DCHECK_EQ(insertion_index, result_len);
   return result_array;
 }
 
 ElementsAccessor** ElementsAccessor::elements_accessors_ = NULL;
 }  // namespace internal
 }  // namespace v8