[refactor] Separate generated builtins and C++ builtins into separate files

src/builtins/builtins-typedarray-gen.cc

-// Copyright 2016 the V8 project authors. All rights reserved.
+// Copyright 2017 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-utils-gen.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"
 
 namespace v8 {
 namespace internal {
 
+// -----------------------------------------------------------------------------
+// ES6 section 22.2 TypedArray Objects
+
 class TypedArrayBuiltinsAssembler : public CodeStubAssembler {
  public:
   explicit TypedArrayBuiltinsAssembler(compiler::CodeAssemblerState* state)
       : CodeStubAssembler(state) {}
 
  protected:
   void GenerateTypedArrayPrototypeGetter(const char* method_name,
                                          int object_offset);
   template <IterationKind kIterationKind>
   void GenerateTypedArrayPrototypeIterationMethod(const char* method_name);
@@ skipping 260 matching lines @@
   Node* const maybe_buffer = Parameter(3);
   Node* const byte_offset = Parameter(4);
   Node* byte_length = Parameter(5);
   Node* const initialize = Parameter(6);
   Node* const context = Parameter(9);
 
   DoInitialize(holder, length, maybe_buffer, byte_offset, byte_length,
                initialize, context);
 }
 
-// -----------------------------------------------------------------------------
-// ES6 section 22.2 TypedArray Objects
-
 // ES6 section 22.2.4.2 TypedArray ( length )
 TF_BUILTIN(TypedArrayConstructByLength, TypedArrayBuiltinsAssembler) {
   // We know that holder cannot be an object if this builtin was called.
   Node* holder = Parameter(1);
   Node* length = Parameter(2);
   Node* element_size = Parameter(3);
   Node* context = Parameter(6);
 
   Variable maybe_buffer(this, MachineRepresentation::kTagged);
   maybe_buffer.Bind(NullConstant());
@@ skipping 154 matching lines @@
   }
 
   Bind(&invalid_length);
   {
     CallRuntime(Runtime::kThrowRangeError, context,
                 SmiConstant(MessageTemplate::kInvalidTypedArrayLength));
     Unreachable();
   }
 }
 
-// ES6 section 22.2.3.1 get %TypedArray%.prototype.buffer
-BUILTIN(TypedArrayPrototypeBuffer) {
-  HandleScope scope(isolate);
-  CHECK_RECEIVER(JSTypedArray, typed_array, "get TypedArray.prototype.buffer");
-  return *typed_array->GetBuffer();
-}
-
 void TypedArrayBuiltinsAssembler::GenerateTypedArrayPrototypeGetter(
     const char* method_name, int object_offset) {
   Node* receiver = Parameter(0);
   Node* context = Parameter(3);
 
   // Check if the {receiver} is actually a JSTypedArray.
   Label receiver_is_incompatible(this, Label::kDeferred);
   GotoIf(TaggedIsSmi(receiver), &receiver_is_incompatible);
   GotoIfNot(HasInstanceType(receiver, JS_TYPED_ARRAY_TYPE),
             &receiver_is_incompatible);
@@ skipping 93 matching lines @@
 TF_BUILTIN(TypedArrayPrototypeEntries, TypedArrayBuiltinsAssembler) {
   GenerateTypedArrayPrototypeIterationMethod<IterationKind::kEntries>(
       "%TypedArray%.prototype.entries()");
 }
 
 TF_BUILTIN(TypedArrayPrototypeKeys, TypedArrayBuiltinsAssembler) {
   GenerateTypedArrayPrototypeIterationMethod<IterationKind::kKeys>(
       "%TypedArray%.prototype.keys()");
 }
 
-namespace {
-
-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, 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);
-
-    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;
-
-  // TypedArray buffer may have been transferred/detached during parameter
-  // processing above. Return early in this case, to prevent potential UAF error
-  // TODO(caitp): throw here, as though the full algorithm were performed (the
-  // throw would have come from ecma262/#sec-integerindexedelementget)
-  // (see )
-  if (V8_UNLIKELY(array->WasNeutered())) return *array;
-
-  // Ensure processed indexes are within array bounds
-  DCHECK_GE(from, 0);
-  DCHECK_LT(from, len);
-  DCHECK_GE(to, 0);
-  DCHECK_LT(to, len);
-  DCHECK_GE(len - count, 0);
-
-  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;
-}
-
-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();
-
-  int64_t len = array->length_value();
-  if (len == 0) return isolate->heap()->false_value();
-
-  int64_t index = 0;
-  if (args.length() > 2) {
-    Handle<Object> num;
-    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-        isolate, num, Object::ToInteger(isolate, args.at<Object>(2)));
-    index = CapRelativeIndex(num, 0, len);
-  }
-
-  // TODO(cwhan.tunz): throw. See the above comment in CopyWithin.
-  if (V8_UNLIKELY(array->WasNeutered())) return isolate->heap()->false_value();
-
-  Handle<Object> search_element = args.atOrUndefined(isolate, 1);
-  ElementsAccessor* elements = array->GetElementsAccessor();
-  Maybe<bool> result = elements->IncludesValue(isolate, array, search_element,
-                                               static_cast<uint32_t>(index),
-                                               static_cast<uint32_t>(len));
-  MAYBE_RETURN(result, isolate->heap()->exception());
-  return *isolate->factory()->ToBoolean(result.FromJust());
-}
-
-BUILTIN(TypedArrayPrototypeIndexOf) {
-  HandleScope scope(isolate);
-
-  Handle<JSTypedArray> array;
-  const char* method = "%TypedArray%.prototype.indexOf";
-  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, array, JSTypedArray::Validate(isolate, args.receiver(), method));
-
-  int64_t len = array->length_value();
-  if (len == 0) return Smi::FromInt(-1);
-
-  int64_t index = 0;
-  if (args.length() > 2) {
-    Handle<Object> num;
-    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-        isolate, num, Object::ToInteger(isolate, args.at<Object>(2)));
-    index = CapRelativeIndex(num, 0, len);
-  }
-
-  // TODO(cwhan.tunz): throw. See the above comment in CopyWithin.
-  if (V8_UNLIKELY(array->WasNeutered())) return Smi::FromInt(-1);
-
-  Handle<Object> search_element = args.atOrUndefined(isolate, 1);
-  ElementsAccessor* elements = array->GetElementsAccessor();
-  Maybe<int64_t> result = elements->IndexOfValue(isolate, array, search_element,
-                                                 static_cast<uint32_t>(index),
-                                                 static_cast<uint32_t>(len));
-  MAYBE_RETURN(result, isolate->heap()->exception());
-  return *isolate->factory()->NewNumberFromInt64(result.FromJust());
-}
-
 }  // namespace internal
 }  // namespace v8