Move all Symbol.species setup for builtin constructors to bootstrapper

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 495 matching lines @@
   return fun;
 }
 
 void InstallConstant(Isolate* isolate, Handle<JSObject> holder,
                      const char* name, Handle<Object> value) {
   JSObject::AddProperty(
       holder, isolate->factory()->NewStringFromAsciiChecked(name), value,
       static_cast<PropertyAttributes>(DONT_DELETE | DONT_ENUM | READ_ONLY));
 }
 
+void InstallSpeciesGetter(Handle<JSFunction> constructor) {
+  Factory* factory = constructor->GetIsolate()->factory();

[gsathya, 2017/01/04 22:11:30]

Why not just pass the isolate to this function? The rest of the Install*
functions seem to do that.

[adamk, 2017/01/04 22:14:28]

SimpleInstallGetter doesn't take an Isolate, so we're already "paying" for a
GetIsolate() call there. Given that this code doesn't ever run in production
(since it's part of the snapshot) I don't think that micro-opt should metter
here.

+  SimpleInstallGetter(constructor, factory->symbol_species_string(),

[adamk, 2017/01/04 22:14:28]

But speaking of micro-opts, it seems like I could make this even faster by
sharing a single SharedFunctionInfo for all these functions...

+                      factory->species_symbol(), Builtins::kReturnReceiver,
+                      true);
+}
+
 }  // namespace
 
 Handle<JSFunction> Genesis::CreateEmptyFunction(Isolate* isolate) {
   // Allocate the map for function instances. Maps are allocated first and their
   // prototypes patched later, once empty function is created.
 
   // Functions with this map will not have a 'prototype' property, and
   // can not be used as constructors.
   Handle<Map> function_without_prototype_map =
       factory()->CreateSloppyFunctionMap(FUNCTION_WITHOUT_PROTOTYPE);
@@ skipping 777 matching lines @@
         Accessors::ArrayLengthInfo(isolate, attribs);
     {  // Add length.
       Descriptor d = Descriptor::AccessorConstant(
           Handle<Name>(Name::cast(array_length->name())), array_length,
           attribs);
       initial_map->AppendDescriptor(&d);
     }
 
     InstallWithIntrinsicDefaultProto(isolate, array_function,
                                      Context::ARRAY_FUNCTION_INDEX);
+    InstallSpeciesGetter(array_function);
 
     // Cache the array maps, needed by ArrayConstructorStub
     CacheInitialJSArrayMaps(native_context(), initial_map);
     ArrayConstructorStub array_constructor_stub(isolate);
     Handle<Code> code = array_constructor_stub.GetCode();
     array_function->shared()->SetConstructStub(*code);
 
     Handle<JSFunction> is_arraylike = SimpleInstallFunction(
         array_function, isolate->factory()->InternalizeUtf8String("isArray"),
         Builtins::kArrayIsArray, 1, true);
@@ skipping 554 matching lines @@
         SimpleInstallFunction(prototype, isolate->factory()->then_string(),
                               Builtins::kPromiseThen, 2, true);
     InstallWithIntrinsicDefaultProto(isolate, promise_then,
                                      Context::PROMISE_THEN_INDEX);
 
     Handle<JSFunction> promise_catch = SimpleInstallFunction(
         prototype, "catch", Builtins::kPromiseCatch, 1, true, DONT_ENUM);
     InstallWithIntrinsicDefaultProto(isolate, promise_catch,
                                      Context::PROMISE_CATCH_INDEX);
 
-    SimpleInstallGetter(promise_fun, factory->symbol_species_string(),
-                        factory->species_symbol(), Builtins::kReturnReceiver,
-                        true);
+    InstallSpeciesGetter(promise_fun);
 
     Handle<Map> prototype_map(prototype->map());
     Map::SetShouldBeFastPrototypeMap(prototype_map, true, isolate);
 
     // Store the initial Promise.prototype map. This is used in fast-path
     // checks. Do not alter the prototype after this point.
     native_context()->set_promise_prototype_map(*prototype_map);
 
     {  // Internal: PromiseInternalConstructor
       Handle<JSFunction> function =
@@ skipping 162 matching lines @@
       Map::SetShouldBeFastPrototypeMap(prototype_map, true, isolate);
 
       // Store the initial RegExp.prototype map. This is used in fast-path
       // checks. Do not alter the prototype after this point.
       native_context()->set_regexp_prototype_map(*prototype_map);
     }
 
     {
       // RegExp getters and setters.
 
-      SimpleInstallGetter(regexp_fun, factory->symbol_species_string(),
-                          factory->species_symbol(), Builtins::kReturnReceiver,
-                          true);
+      InstallSpeciesGetter(regexp_fun);
 
       // Static properties set by a successful match.
 
       const PropertyAttributes no_enum = DONT_ENUM;
       SimpleInstallGetterSetter(regexp_fun, factory->input_string(),
                                 Builtins::kRegExpInputGetter,
                                 Builtins::kRegExpInputSetter, no_enum);
       SimpleInstallGetterSetter(
           regexp_fun, factory->InternalizeUtf8String("$_"),
           Builtins::kRegExpInputGetter, Builtins::kRegExpInputSetter, no_enum);
@@ skipping 304 matching lines @@
                           v8_break_iterator_constructor, DONT_ENUM);
   }
 #endif  // V8_I18N_SUPPORT
 
   {  // -- A r r a y B u f f e r
     Handle<JSFunction> array_buffer_fun = InstallArrayBuffer(
         global, "ArrayBuffer", Builtins::kArrayBufferPrototypeGetByteLength,
         BuiltinFunctionId::kArrayBufferByteLength);
     InstallWithIntrinsicDefaultProto(isolate, array_buffer_fun,
                                      Context::ARRAY_BUFFER_FUN_INDEX);
+    InstallSpeciesGetter(array_buffer_fun);
   }
 
   {  // -- T y p e d A r r a y
     Handle<JSObject> prototype =
         factory->NewJSObject(isolate->object_function(), TENURED);
     native_context()->set_typed_array_prototype(*prototype);
 
     Handle<JSFunction> typed_array_fun =
         CreateFunction(isolate, factory->InternalizeUtf8String("TypedArray"),
                        JS_TYPED_ARRAY_TYPE, JSTypedArray::kSize, prototype,
                        Builtins::kIllegal);
+    InstallSpeciesGetter(typed_array_fun);
 
     // Install the "constructor" property on the {prototype}.
     JSObject::AddProperty(prototype, factory->constructor_string(),
                           typed_array_fun, DONT_ENUM);
     native_context()->set_typed_array_function(*typed_array_fun);
 
     // Install the "buffer", "byteOffset", "byteLength" and "length"
     // getters on the {prototype}.
     SimpleInstallGetter(prototype, factory->buffer_string(),
                         Builtins::kTypedArrayPrototypeBuffer, false);
@@ skipping 107 matching lines @@
     SimpleInstallFunction(prototype, "setFloat64",
                           Builtins::kDataViewPrototypeSetFloat64, 2, false);
   }
 
   {  // -- M a p
     Handle<JSFunction> js_map_fun = InstallFunction(
         global, "Map", JS_MAP_TYPE, JSMap::kSize,
         isolate->initial_object_prototype(), Builtins::kIllegal);
     InstallWithIntrinsicDefaultProto(isolate, js_map_fun,
                                      Context::JS_MAP_FUN_INDEX);
+    InstallSpeciesGetter(js_map_fun);
   }
 
   {  // -- S e t
     Handle<JSFunction> js_set_fun = InstallFunction(
         global, "Set", JS_SET_TYPE, JSSet::kSize,
         isolate->initial_object_prototype(), Builtins::kIllegal);
     InstallWithIntrinsicDefaultProto(isolate, js_set_fun,
                                      Context::JS_SET_FUN_INDEX);
+    InstallSpeciesGetter(js_set_fun);
   }
 
   {  // -- J S M o d u l e N a m e s p a c e
     Handle<Map> map =
         factory->NewMap(JS_MODULE_NAMESPACE_TYPE, JSModuleNamespace::kSize);
     Map::SetPrototype(map, isolate->factory()->null_value());
     Map::EnsureDescriptorSlack(map, 1);
     native_context()->set_js_module_namespace_map(*map);
 
     {  // Install @@toStringTag.
@@ skipping 2172 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8