Revert "[builtins] Port TypedArrayInitialize to CodeStubAssembler."

This reverts commit b23b2c10.

Reason for revert: Makes Linux debug bot sad

Original change's description:
> [builtins] Port TypedArrayInitialize to CodeStubAssembler.
> 
> Turbofan is a lot slower than Crankshaft at constructing TypedArrays,
> because we always go to the C++ builtin. Port the builtin to CSA
> to improve performance, and to clean up the implementation, which is
> split across multiple files and pieces at the moment.
> 
> This CL increases the performance with --future to roughly the same
> as with crankshaft.
> 
> BUG=v8:5977
> 
> Change-Id: I5a4c4b544a735a56290b85bf33c2f3718df7e2b8
> Reviewed-on: https://chromium-review.googlesource.com/445717
> Commit-Queue: Peter Marshall <petermarshall@chromium.org>
> Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
> Reviewed-by: Camillo Bruni <cbruni@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#43518}

TBR=cbruni@chromium.org,petermarshall@chromium.org,bmeurer@chromium.org,v8-reviews@googlegroups.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=v8:5977

Change-Id: I5d5bc8b4677a405c716d78e688af80ae9c737b4a
Reviewed-on: https://chromium-review.googlesource.com/448558Reviewed-by: Peter Marshall <petermarshall@chromium.org>
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#43520}

src/assembler.cc

@@ -1546,14 +1546,6 @@ ExternalReference ExternalReference::libc_memchr_function(Isolate* isolate) {
   return ExternalReference(Redirect(isolate, FUNCTION_ADDR(libc_memchr)));
 }
 
-void* libc_memset(void* string, int character, size_t n) {
-  return memset(string, character, n);
-}
-
-ExternalReference ExternalReference::libc_memset_function(Isolate* isolate) {
-  return ExternalReference(Redirect(isolate, FUNCTION_ADDR(libc_memset)));
-}
-
 ExternalReference ExternalReference::page_flags(Page* page) {
   return ExternalReference(reinterpret_cast<Address>(page) +
                            MemoryChunk::kFlagsOffset);

src/assembler.h

@@ -978,7 +978,6 @@ class ExternalReference BASE_EMBEDDED {
   static ExternalReference ieee754_tanh_function(Isolate* isolate);
 
   static ExternalReference libc_memchr_function(Isolate* isolate);
-  static ExternalReference libc_memset_function(Isolate* isolate);
 
   static ExternalReference page_flags(Page* page);
 

src/bootstrapper.cc

@@ -2620,13 +2620,6 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
   }
     TYPED_ARRAYS(INSTALL_TYPED_ARRAY)
 #undef INSTALL_TYPED_ARRAY
-
-    // %typed_array_initialize
-    Handle<JSFunction> typed_array_initialize = SimpleCreateFunction(
-        isolate, factory->NewStringFromAsciiChecked("typedArrayInitialize"),
-        Builtins::kTypedArrayInitialize, 6, false);
-    InstallWithIntrinsicDefaultProto(isolate, typed_array_initialize,
-                                     Context::TYPED_ARRAY_INITIALIZE_INDEX);
   }
 
   {  // -- D a t a V i e w

src/builtins/builtins.h

@@ -805,7 +805,6 @@ class Isolate;
   TFJ(SymbolPrototypeValueOf, 0)                                               \
                                                                                \
   /* TypedArray */                                                             \
-  TFJ(TypedArrayInitialize, 6)                                                 \
   CPP(TypedArrayPrototypeBuffer)                                               \
   /* ES6 section 22.2.3.2 get %TypedArray%.prototype.byteLength */             \
   TFJ(TypedArrayPrototypeByteLength, 0)                                        \

src/contexts.h

@@ -68,7 +68,6 @@ enum ContextLookupFlags {
   V(REFLECT_DELETE_PROPERTY_INDEX, JSFunction, reflect_delete_property) \
   V(SPREAD_ARGUMENTS_INDEX, JSFunction, spread_arguments)               \
   V(SPREAD_ITERABLE_INDEX, JSFunction, spread_iterable)                 \
-  V(TYPED_ARRAY_INITIALIZE_INDEX, JSFunction, typed_array_initialize)   \
   V(MATH_FLOOR_INDEX, JSFunction, math_floor)                           \
   V(MATH_POW_INDEX, JSFunction, math_pow)                               \
   V(NEW_PROMISE_CAPABILITY_INDEX, JSFunction, new_promise_capability)   \

src/external-reference-table.cc

@@ -233,8 +233,6 @@ void ExternalReferenceTable::AddReferences(Isolate* isolate) {
       "wasm::call_trap_callback_for_testing");
   Add(ExternalReference::libc_memchr_function(isolate).address(),
       "libc_memchr");
-  Add(ExternalReference::libc_memset_function(isolate).address(),
-      "libc_memset");
   Add(ExternalReference::log_enter_external_function(isolate).address(),
       "Logger::EnterExternal");
   Add(ExternalReference::log_leave_external_function(isolate).address(),

src/factory.cc

@@ -2017,20 +2017,23 @@ Handle<JSSetIterator> Factory::NewJSSetIterator() {
                      JSSetIterator);
 }
 
-ExternalArrayType Factory::GetArrayTypeFromElementsKind(ElementsKind kind) {
-  switch (kind) {
+
+namespace {
+
+ElementsKind GetExternalArrayElementsKind(ExternalArrayType type) {
+  switch (type) {
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
-  case TYPE##_ELEMENTS:                                 \
-    return kExternal##Type##Array;
+  case kExternal##Type##Array:                          \
+    return TYPE##_ELEMENTS;
     TYPED_ARRAYS(TYPED_ARRAY_CASE)
-    default:
-      UNREACHABLE();
-      return kExternalInt8Array;
   }
+  UNREACHABLE();
+  return FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND;
 #undef TYPED_ARRAY_CASE
 }
 
-size_t Factory::GetExternalArrayElementSize(ExternalArrayType type) {
+
+size_t GetExternalArrayElementSize(ExternalArrayType type) {
   switch (type) {
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   case kExternal##Type##Array:                          \
@@ -2043,29 +2046,30 @@ size_t Factory::GetExternalArrayElementSize(ExternalArrayType type) {
 #undef TYPED_ARRAY_CASE
 }
 
-namespace {
 
-ElementsKind GetExternalArrayElementsKind(ExternalArrayType type) {
-  switch (type) {
+size_t GetFixedTypedArraysElementSize(ElementsKind kind) {
+  switch (kind) {
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
-  case kExternal##Type##Array:                          \
-    return TYPE##_ELEMENTS;
+  case TYPE##_ELEMENTS:                                 \
+    return size;
     TYPED_ARRAYS(TYPED_ARRAY_CASE)
-  }
+    default:
       UNREACHABLE();
-  return FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND;
+      return 0;
+  }
 #undef TYPED_ARRAY_CASE
 }
 
-size_t GetFixedTypedArraysElementSize(ElementsKind kind) {
+
+ExternalArrayType GetArrayTypeFromElementsKind(ElementsKind kind) {
   switch (kind) {
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   case TYPE##_ELEMENTS:                                 \
-    return size;
+    return kExternal##Type##Array;
     TYPED_ARRAYS(TYPED_ARRAY_CASE)
     default:
       UNREACHABLE();
-      return 0;
+      return kExternalInt8Array;
   }
 #undef TYPED_ARRAY_CASE
 }

src/factory.h

@@ -536,9 +536,6 @@ class V8_EXPORT_PRIVATE Factory final {
       SharedFlag shared = SharedFlag::kNotShared,
       PretenureFlag pretenure = NOT_TENURED);
 
-  ExternalArrayType GetArrayTypeFromElementsKind(ElementsKind kind);
-  size_t GetExternalArrayElementSize(ExternalArrayType type);
-
   Handle<JSTypedArray> NewJSTypedArray(ExternalArrayType type,
                                        PretenureFlag pretenure = NOT_TENURED);
 

src/js/typedarray.js

@@ -169,14 +169,13 @@ function NAMEConstructByArrayBuffer(obj, buffer, byteOffset, length) {
       throw %make_range_error(kInvalidTypedArrayLength);
     }
   }
-  var newLength = newByteLength / ELEMENT_SIZE;
-  %typed_array_initialize(obj, newLength, buffer, offset, newByteLength, true);
+  %_TypedArrayInitialize(obj, ARRAY_ID, buffer, offset, newByteLength, true);
 }
 
 function NAMEConstructByLength(obj, length) {
   var l = IS_UNDEFINED(length) ?
     0 : ToIndex(length, kInvalidTypedArrayLength);
-  if (l > %_MaxSmi()) {
+  if (length > %_MaxSmi()) {
     // Note: this is not per spec, but rather a constraint of our current
     // representation (which uses smi's).
     throw %make_range_error(kInvalidTypedArrayLength);
@@ -184,9 +183,9 @@ function NAMEConstructByLength(obj, length) {
   var byteLength = l * ELEMENT_SIZE;
   if (byteLength > %_TypedArrayMaxSizeInHeap()) {
     var buffer = new GlobalArrayBuffer(byteLength);
-    %typed_array_initialize(obj, l, buffer, 0, byteLength, true);
+    %_TypedArrayInitialize(obj, ARRAY_ID, buffer, 0, byteLength, true);
   } else {
-    %typed_array_initialize(obj, l, null, 0, byteLength, true);
+    %_TypedArrayInitialize(obj, ARRAY_ID, null, 0, byteLength, true);
   }
 }
 
@@ -199,7 +198,7 @@ function NAMEConstructByArrayLike(obj, arrayLike, length) {
   var initialized = false;
   var byteLength = l * ELEMENT_SIZE;
   if (byteLength <= %_TypedArrayMaxSizeInHeap()) {
-    %typed_array_initialize(obj, l, null, 0, byteLength, false);
+    %_TypedArrayInitialize(obj, ARRAY_ID, null, 0, byteLength, false);
   } else {
     initialized =
         %TypedArrayInitializeFromArrayLike(obj, ARRAY_ID, arrayLike, l);

test/mjsunit/es6/typedarray.js

@@ -822,12 +822,3 @@ function TestNonConfigurableProperties(constructor) {
 for(i = 0; i < typedArrayConstructors.length; i++) {
   TestNonConfigurableProperties(typedArrayConstructors[i]);
 }
-
-(function TestInitialization() {
-  for (var i = 0; i <= 128; i++) {
-    var arr = new Uint8Array(i);
-    for (var j = 0; j < i; j++) {
-      assertEquals(0, arr[j]);
-    }
-  }
-})();