Revert of [typedarrays] move %TypedArray%.prototype.copyWithin 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"
 
 namespace v8 {
 namespace internal {
@@ skipping 149 matching lines @@
   Generate_TypedArrayPrototypeIterationMethod<IterationKind::kEntries>(
       state, "%TypedArray%.prototype.entries()");
 }
 
 void Builtins::Generate_TypedArrayPrototypeKeys(
     compiler::CodeAssemblerState* state) {
   Generate_TypedArrayPrototypeIterationMethod<IterationKind::kKeys>(
       state, "%TypedArray%.prototype.keys()");
 }
 
-namespace {
-
-MaybeHandle<JSTypedArray> ValiadateTypedArray(Isolate* isolate,
-                                              Handle<Object> receiver,
-                                              const char* method_name) {
-  if (V8_UNLIKELY(!receiver->IsJSTypedArray())) {
-    const MessageTemplate::Template message = MessageTemplate::kNotTypedArray;
-    THROW_NEW_ERROR(isolate, NewTypeError(message), JSTypedArray);
-  }
-
-  Handle<JSTypedArray> array = Handle<JSTypedArray>::cast(receiver);
-  if (V8_UNLIKELY(array->WasNeutered())) {
-    const MessageTemplate::Template message = MessageTemplate::kNotTypedArray;
-    Handle<String> operation =
-        isolate->factory()->NewStringFromAsciiChecked(method_name);
-    THROW_NEW_ERROR(isolate, NewTypeError(message, operation), JSTypedArray);
-  }
-
-  return array;
-}
-
-int64_t CapRelativeIndex(Handle<Object> num, int64_t minimum, int64_t maximum) {
-  int64_t relative;
-  if (V8_LIKELY(num->IsSmi())) {
-    relative = Smi::cast(*num)->value();
-  } else {
-    DCHECK(num->IsHeapNumber());
-    double fp = HeapNumber::cast(*num)->value();
-    if (V8_UNLIKELY(!std::isfinite(fp))) {
-      // +Infinity / -Infinity
-      DCHECK(!std::isnan(fp));
-      return fp < 0 ? minimum : maximum;
-    }
-    relative = static_cast<int64_t>(fp);
-  }
-  return relative < 0 ? std::max<int64_t>(relative + maximum, minimum)
-                      : std::min<int64_t>(relative, maximum);
-}
-
-}  // namespace
-
-BUILTIN(TypedArrayPrototypeCopyWithin) {
-  HandleScope scope(isolate);
-
-  Handle<JSTypedArray> array;
-  const char* method = "%TypedArray%.prototype.copyWithin";
-  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, array, ValiadateTypedArray(isolate, args.receiver(), method));
-
-  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);
-
-    if (args.length() > 2) {
-      ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-          isolate, num, Object::ToInteger(isolate, args.at<Object>(2)));
-      from = CapRelativeIndex(num, 0, len);
-
-      Handle<Object> end = args.atOrUndefined(isolate, 3);
-      if (!end->IsUndefined(isolate)) {
-        ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, num,
-                                           Object::ToInteger(isolate, end));
-        final = CapRelativeIndex(num, 0, len);
-      }
-    }
-  }
-
-  int64_t count = std::min<int64_t>(final - from, len - to);
-  if (count <= 0) return *array;
-
-  Handle<FixedTypedArrayBase> elements(
-      FixedTypedArrayBase::cast(array->elements()));
-  size_t element_size = array->element_size();
-  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;
-}
-
 }  // namespace internal
 }  // namespace v8