Always run our fast array builtins.

src/bootstrapper.cc

 // Copyright 2014 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/bootstrapper.h"
 
 #include "src/accessors.h"
 #include "src/api-natives.h"
 #include "src/base/ieee754.h"
 #include "src/code-stubs.h"
@@ skipping 200 matching lines @@
 #define DECLARE_FEATURE_INITIALIZATION(id, descr) \
   void InitializeGlobal_##id();
 
   HARMONY_INPROGRESS(DECLARE_FEATURE_INITIALIZATION)
   HARMONY_STAGED(DECLARE_FEATURE_INITIALIZATION)
   HARMONY_SHIPPING(DECLARE_FEATURE_INITIALIZATION)
 #undef DECLARE_FEATURE_INITIALIZATION
 
   void InstallOneBuiltinFunction(const char* object, const char* method,
                                  Builtins::Name name);
-  void InitializeGlobal_enable_fast_array_builtins();
+  void InitializeGlobal_experimental_fast_array_builtins();
 
   Handle<JSFunction> InstallArrayBuffer(Handle<JSObject> target,
                                         const char* name, Builtins::Name call,
                                         BuiltinFunctionId id, bool is_shared);
   Handle<JSFunction> InstallInternalArray(Handle<JSObject> target,
                                           const char* name,
                                           ElementsKind elements_kind);
   bool InstallNatives(GlobalContextType context_type);
 
   void InstallTypedArray(const char* name, ElementsKind elements_kind,
@@ skipping 194 matching lines @@
                      MaybeHandle<JSObject>(), call);
   if (adapt) {
     fun->shared()->set_internal_formal_parameter_count(len);
   } else {
     fun->shared()->DontAdaptArguments();
   }
   fun->shared()->set_length(len);
   return fun;
 }
 
+Handle<JSFunction> InstallArrayBuiltinFunction(Handle<JSObject> base,
+                                               const char* name,
+                                               Builtins::Name call,
+                                               int argument_count) {
+  Isolate* isolate = base->GetIsolate();
+  Handle<String> str_name = isolate->factory()->InternalizeUtf8String(name);
+  Handle<JSFunction> fun =
+      CreateFunction(isolate, str_name, JS_OBJECT_TYPE, JSObject::kHeaderSize,
+                     MaybeHandle<JSObject>(), call, true);
+  fun->shared()->set_internal_formal_parameter_count(argument_count);
+
+  // Set the length to 1 to satisfy ECMA-262.
+  fun->shared()->set_length(1);
+  fun->shared()->set_language_mode(STRICT);
+  InstallFunction(base, fun, str_name);
+  return fun;
+}
+
 Handle<JSFunction> SimpleInstallFunction(Handle<JSObject> base,
                                          Handle<String> name,
                                          Builtins::Name call, int len,
                                          bool adapt,
                                          PropertyAttributes attrs = DONT_ENUM) {
   Handle<JSFunction> fun =
       SimpleCreateFunction(base->GetIsolate(), name, call, len, adapt);
   InstallFunction(base, fun, name, attrs);
   return fun;
 }
@@ skipping 2613 matching lines @@
 
 
 void Genesis::InitializeExperimentalGlobal() {
 #define FEATURE_INITIALIZE_GLOBAL(id, descr) InitializeGlobal_##id();
 
   HARMONY_INPROGRESS(FEATURE_INITIALIZE_GLOBAL)
   HARMONY_STAGED(FEATURE_INITIALIZE_GLOBAL)
   HARMONY_SHIPPING(FEATURE_INITIALIZE_GLOBAL)
 #undef FEATURE_INITIALIZE_GLOBAL
 
-  InitializeGlobal_enable_fast_array_builtins();
+  InitializeGlobal_experimental_fast_array_builtins();
 }
 
-
 bool Bootstrapper::CompileBuiltin(Isolate* isolate, int index) {
   Vector<const char> name = Natives::GetScriptName(index);
   Handle<String> source_code =
       isolate->bootstrapper()->SourceLookup<Natives>(index);
 
   // We pass in extras_utils so that builtin code can set it up for later use
   // by actual extras code, compiled with CompileExtraBuiltin.
   Handle<Object> global = isolate->global_object();
   Handle<Object> utils = isolate->natives_utils_object();
   Handle<Object> extras_utils = isolate->extras_utils_object();
@@ skipping 599 matching lines @@
 
   LookupIterator it3(prototype, factory->NewStringFromAsciiChecked(method_name),
                      LookupIterator::OWN_SKIP_INTERCEPTOR);
   Handle<Object> function = Object::GetProperty(&it3).ToHandleChecked();
   Handle<JSFunction>::cast(function)->set_code(
       isolate->builtins()->builtin(builtin_name));
   Handle<JSFunction>::cast(function)->shared()->set_code(
       isolate->builtins()->builtin(builtin_name));
 }
 
-void Genesis::InitializeGlobal_enable_fast_array_builtins() {
-  if (!FLAG_enable_fast_array_builtins) return;
+void Genesis::InitializeGlobal_experimental_fast_array_builtins() {
+  if (!FLAG_experimental_fast_array_builtins) return;
 
-  InstallOneBuiltinFunction("Array", "forEach", Builtins::kArrayForEach);
-  InstallOneBuiltinFunction("Array", "every", Builtins::kArrayEvery);
-  InstallOneBuiltinFunction("Array", "some", Builtins::kArraySome);
-  InstallOneBuiltinFunction("Array", "reduce", Builtins::kArrayReduce);
-
-  if (FLAG_experimental_array_builtins) {
-    InstallOneBuiltinFunction("Array", "filter", Builtins::kArrayFilter);
-  }
+  // Insert experimental fast array builtins here.
+  InstallOneBuiltinFunction("Array", "filter", Builtins::kArrayFilter);
 }
 
 void Genesis::InitializeGlobal_harmony_sharedarraybuffer() {
   if (!FLAG_harmony_sharedarraybuffer) return;
 
   Handle<JSGlobalObject> global(native_context()->global_object());
   Isolate* isolate = global->GetIsolate();
   Factory* factory = isolate->factory();
 
   Handle<JSFunction> shared_array_buffer_fun =
@@ skipping 423 matching lines @@
   }
 
   // Install Global.isFinite
   SimpleInstallFunction(global_object, "isFinite", Builtins::kGlobalIsFinite, 1,
                         true, kGlobalIsFinite);
 
   // Install Global.isNaN
   SimpleInstallFunction(global_object, "isNaN", Builtins::kGlobalIsNaN, 1, true,
                         kGlobalIsNaN);
 
-  // Install Array.prototype.concat
+  // Install Array builtin functions.
   {
     Handle<JSFunction> array_constructor(native_context()->array_function());
-    Handle<JSObject> proto(JSObject::cast(array_constructor->prototype()));
+    Handle<JSArray> proto(JSArray::cast(array_constructor->prototype()));
+
+    // Verification of important array prototype properties.
+    Object* length = proto->length();
+    CHECK(length->IsSmi());
+    CHECK(Smi::cast(length)->value() == 0);
+    CHECK(proto->HasFastSmiOrObjectElements());
+    // This is necessary to enable fast checks for absence of elements
+    // on Array.prototype and below.
+    proto->set_elements(heap()->empty_fixed_array());
+
+    // Install Array.prototype.concat
     Handle<JSFunction> concat =
         InstallFunction(proto, "concat", JS_OBJECT_TYPE, JSObject::kHeaderSize,
                         MaybeHandle<JSObject>(), Builtins::kArrayConcat);
 
     // Make sure that Array.prototype.concat appears to be compiled.
     // The code will never be called, but inline caching for call will
     // only work if it appears to be compiled.
     concat->shared()->DontAdaptArguments();
     DCHECK(concat->is_compiled());
     // Set the lengths for the functions to satisfy ECMA-262.
     concat->shared()->set_length(1);
+
+    // Install Array.prototype.forEach
+    Handle<JSFunction> forEach = InstallArrayBuiltinFunction(
+        proto, "forEach", Builtins::kArrayForEach, 2);
+    // Add forEach to the context.
+    native_context()->set_array_for_each_iterator(*forEach);
+
+    // Install Array.prototype.every
+    InstallArrayBuiltinFunction(proto, "every", Builtins::kArrayEvery, 2);
+
+    // Install Array.prototype.some
+    InstallArrayBuiltinFunction(proto, "some", Builtins::kArraySome, 2);
+
+    // Install Array.prototype.reduce
+    InstallArrayBuiltinFunction(proto, "reduce", Builtins::kArrayReduce, 2);
   }
 
   // Install InternalArray.prototype.concat
   {
     Handle<JSFunction> array_constructor(
         native_context()->internal_array_function());
     Handle<JSObject> proto(JSObject::cast(array_constructor->prototype()));
     Handle<JSFunction> concat =
         InstallFunction(proto, "concat", JS_OBJECT_TYPE, JSObject::kHeaderSize,
                         MaybeHandle<JSObject>(), Builtins::kArrayConcat);
@@ skipping 886 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8