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 187 matching lines @@
   void HookUpGlobalProxy(Handle<JSGlobalProxy> global_proxy);
   // The native context has a ScriptContextTable that store declarative bindings
   // made in script scopes.  Add a "this" binding to that table pointing to the
   // global proxy.
   void InstallGlobalThisBinding();
   // New context initialization.  Used for creating a context from scratch.
   void InitializeGlobal(Handle<JSGlobalObject> global_object,
                         Handle<JSFunction> empty_function,
                         GlobalContextType context_type);
   void InitializeExperimentalGlobal();
+  void InstallFastArrayBuiltins();
   // Depending on the situation, expose and/or get rid of the utils object.
   void ConfigureUtilsObject(GlobalContextType context_type);
 
 #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 InitializeGlobal_enable_fast_array_builtins();
+  void InstallOneBuiltinFunction(const char* object, const char* method,
+                                 Builtins::Name name);
+  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 2825 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();
 }
 
+void Genesis::InstallFastArrayBuiltins() {
+  InstallOneBuiltinFunction("Array", "forEach", Builtins::kArrayForEach);
+  InstallOneBuiltinFunction("Array", "every", Builtins::kArrayEvery);
+  InstallOneBuiltinFunction("Array", "some", Builtins::kArraySome);
+}
 
 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();
@@ skipping 577 matching lines @@
       JSGlobalObject::cast(native_context->global_object()));
   Handle<String> symbol_string = factory->InternalizeUtf8String("Symbol");
   Handle<JSObject> symbol = Handle<JSObject>::cast(
       JSObject::GetProperty(global, symbol_string).ToHandleChecked());
   Handle<String> name_string = factory->InternalizeUtf8String(name);
   PropertyAttributes attributes =
       static_cast<PropertyAttributes>(DONT_ENUM | DONT_DELETE | READ_ONLY);
   JSObject::AddProperty(symbol, name_string, value, attributes);
 }
 
-void Genesis::InitializeGlobal_enable_fast_array_builtins() {
-  if (!FLAG_enable_fast_array_builtins) return;
-
+void Genesis::InstallOneBuiltinFunction(const char* object_name,
+                                        const char* method_name,
+                                        Builtins::Name builtin_name) {
   Handle<JSGlobalObject> global(native_context()->global_object());
   Isolate* isolate = global->GetIsolate();
   Factory* factory = isolate->factory();
 
-  LookupIterator it1(global, factory->NewStringFromAsciiChecked("Array"),
+  LookupIterator it1(global, factory->NewStringFromAsciiChecked(object_name),
                      LookupIterator::OWN_SKIP_INTERCEPTOR);
-  Handle<Object> array_object = Object::GetProperty(&it1).ToHandleChecked();
-  LookupIterator it2(array_object,
-                     factory->NewStringFromAsciiChecked("prototype"),
+  Handle<Object> object = Object::GetProperty(&it1).ToHandleChecked();
+  LookupIterator it2(object, factory->NewStringFromAsciiChecked("prototype"),
                      LookupIterator::OWN_SKIP_INTERCEPTOR);
-  Handle<Object> array_prototype = Object::GetProperty(&it2).ToHandleChecked();
-  LookupIterator it3(array_prototype,
-                     factory->NewStringFromAsciiChecked("forEach"),
+  Handle<Object> prototype = Object::GetProperty(&it2).ToHandleChecked();
+
+  LookupIterator it3(prototype, factory->NewStringFromAsciiChecked(method_name),
                      LookupIterator::OWN_SKIP_INTERCEPTOR);
-  Handle<Object> for_each_function =
-      Object::GetProperty(&it3).ToHandleChecked();
-  Handle<JSFunction>::cast(for_each_function)
-      ->set_code(isolate->builtins()->builtin(Builtins::kArrayForEach));
-  Handle<JSFunction>::cast(for_each_function)
-      ->shared()
-      ->set_code(isolate->builtins()->builtin(Builtins::kArrayForEach));
+  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));
+}
 
-  LookupIterator it4(array_prototype,
-                     factory->NewStringFromAsciiChecked("every"),
-                     LookupIterator::OWN_SKIP_INTERCEPTOR);
-  Handle<Object> every_function = Object::GetProperty(&it4).ToHandleChecked();
-  Handle<JSFunction>::cast(every_function)
-      ->set_code(isolate->builtins()->builtin(Builtins::kArrayEvery));
-  Handle<JSFunction>::cast(every_function)
-      ->shared()
-      ->set_code(isolate->builtins()->builtin(Builtins::kArrayEvery));
-
-  LookupIterator it5(array_prototype,
-                     factory->NewStringFromAsciiChecked("some"),
-                     LookupIterator::OWN_SKIP_INTERCEPTOR);
-  Handle<Object> some_function = Object::GetProperty(&it5).ToHandleChecked();
-  Handle<JSFunction>::cast(some_function)
-      ->set_code(isolate->builtins()->builtin(Builtins::kArraySome));
-  Handle<JSFunction>::cast(some_function)
-      ->shared()
-      ->set_code(isolate->builtins()->builtin(Builtins::kArraySome));
+void Genesis::InitializeGlobal_experimental_fast_array_builtins() {
+  if (!FLAG_experimental_fast_array_builtins) return;
+  // Insert experimental fast array builtins here.
 }
 
 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 1216 matching lines @@
     if (!InstallNatives(context_type)) return;
 
     MakeFunctionInstancePrototypeWritable();
 
     if (!InstallExtraNatives()) return;
     if (!ConfigureGlobalObjects(global_proxy_template)) return;
 
     isolate->counters()->contexts_created_from_scratch()->Increment();
   }
 
+  InstallFastArrayBuiltins();

[Yang, 2017/03/20 15:00:24]

This seems wrong. We would install these builtins once when creating the
snapshot, and later overwrite with the same content.

This should be put into InstallNatives.

[mvstanton, 2017/03/21 21:15:47]

Done.

+
   // Install experimental natives. Do not include them into the
   // snapshot as we should be able to turn them off at runtime. Re-installing
   // them after they have already been deserialized would also fail.
   if (context_type == FULL_CONTEXT) {
     if (!isolate->serializer_enabled()) {
       InitializeExperimentalGlobal();
 
       if (FLAG_experimental_extras) {
         if (!InstallExperimentalExtraNatives()) return;
       }
@@ skipping 108 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8