Use shared container to manage imports/exports.

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/utils/random-number-generator.h"
 #include "src/code-stubs.h"
@@ skipping 289 matching lines @@
   Handle<Map> CreateStrictFunctionMap(FunctionMode function_mode,
                                       Handle<JSFunction> empty_function);
   Handle<Map> CreateStrongFunctionMap(Handle<JSFunction> empty_function,
                                       bool is_constructor);
 
 
   void SetStrictFunctionInstanceDescriptor(Handle<Map> map,
                                            FunctionMode function_mode);
   void SetStrongFunctionInstanceDescriptor(Handle<Map> map);
 
-  static bool CompileBuiltin(Isolate* isolate, int index,
-                             Handle<JSObject> shared);
+  static bool CompileBuiltin(Isolate* isolate, int index);
   static bool CompileExperimentalBuiltin(Isolate* isolate, int index);
   static bool CompileExtraBuiltin(Isolate* isolate, int index);
   static bool CompileNative(Isolate* isolate, Vector<const char> name,
                             Handle<String> source, int argc,
                             Handle<Object> argv[]);
 
+  static bool CallUtilsFunction(Isolate* isolate, const char* name);
+
   static bool CompileExtension(Isolate* isolate, v8::Extension* extension);
 
   Isolate* isolate_;
   Handle<Context> result_;
   Handle<Context> native_context_;
 
   // Function maps. Function maps are created initially with a read only
   // prototype for the processing of JS builtins. Later the function maps are
   // replaced in order to make prototype writable. These are the final, writable
   // prototype, maps.
@@ skipping 1107 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
 }
 
 
-bool Genesis::CompileBuiltin(Isolate* isolate, int index,
-                             Handle<JSObject> shared) {
+bool Genesis::CompileBuiltin(Isolate* isolate, int index) {
   Vector<const char> name = Natives::GetScriptName(index);
   Handle<String> source_code =
       isolate->bootstrapper()->SourceLookup<Natives>(index);
   Handle<Object> global = isolate->global_object();
-  Handle<Object> exports = isolate->builtin_exports_object();
-  Handle<Object> args[] = {global, shared, exports};
+  Handle<Object> utils = isolate->natives_utils_object();
+  Handle<Object> args[] = {global, utils};
   return CompileNative(isolate, name, source_code, arraysize(args), args);
 }
 
 
 bool Genesis::CompileExperimentalBuiltin(Isolate* isolate, int index) {
   HandleScope scope(isolate);
   Vector<const char> name = ExperimentalNatives::GetScriptName(index);
   Handle<String> source_code =
       isolate->bootstrapper()->SourceLookup<ExperimentalNatives>(index);
   Handle<Object> global = isolate->global_object();
-  Handle<Object> exports = isolate->builtin_exports_object();
-  Handle<Object> args[] = {global, exports};
+  Handle<Object> utils = isolate->natives_utils_object();
+  Handle<Object> args[] = {global, utils};
   return CompileNative(isolate, name, source_code, arraysize(args), args);
 }
 
 
 bool Genesis::CompileExtraBuiltin(Isolate* isolate, int index) {
   HandleScope scope(isolate);
   Vector<const char> name = ExtraNatives::GetScriptName(index);
   Handle<String> source_code =
       isolate->bootstrapper()->SourceLookup<ExtraNatives>(index);
   Handle<Object> global = isolate->global_object();
@@ skipping 35 matching lines @@
   Handle<Object> wrapper;
   if (!Execution::Call(isolate, fun, receiver, 0, NULL).ToHandle(&wrapper)) {
     return false;
   }
   // Then run the function wrapper.
   return !Execution::Call(isolate, Handle<JSFunction>::cast(wrapper), receiver,
                           argc, argv).is_null();
 }
 
 
+bool Genesis::CallUtilsFunction(Isolate* isolate, const char* name) {
+  Handle<JSObject> utils =
+      Handle<JSObject>::cast(isolate->natives_utils_object());
+  Handle<String> name_string =
+      isolate->factory()->NewStringFromAsciiChecked(name);
+  Handle<Object> fun = JSObject::GetDataProperty(utils, name_string);
+  Handle<Object> receiver = isolate->factory()->undefined_value();
+  return !Execution::Call(isolate, fun, receiver, 0, NULL).is_null();
+}
+
+
 bool Genesis::CompileExtension(Isolate* isolate, v8::Extension* extension) {
   Factory* factory = isolate->factory();
   HandleScope scope(isolate);
   Handle<SharedFunctionInfo> function_info;
 
   Handle<String> source =
       isolate->factory()
           ->NewExternalStringFromOneByte(extension->source())
           .ToHandleChecked();
   DCHECK(source->IsOneByteRepresentation());
@@ skipping 381 matching lines @@
   Handle<JSFunction> bridge = factory()->NewFunction(factory()->empty_string());
   DCHECK(bridge->context() == *isolate()->native_context());
 
   // Allocate the builtins context.
   Handle<Context> context =
     factory()->NewFunctionContext(Context::MIN_CONTEXT_SLOTS, bridge);
   context->set_global_object(*builtins);  // override builtins global object
 
   native_context()->set_runtime_context(*context);
 
-  // Set up shared object to set up cross references between native scripts.
-  // "shared" is used for cross references between native scripts that are part
-  // of the snapshot. "builtin_exports" is used for experimental natives.
-  Handle<JSObject> shared =
-      factory()->NewJSObject(isolate()->object_function());
-  JSObject::NormalizeProperties(shared, CLEAR_INOBJECT_PROPERTIES, 16,
-                                "container to share between native scripts");
-
-  Handle<JSObject> builtin_exports =
-      factory()->NewJSObject(isolate()->object_function());
-  JSObject::NormalizeProperties(builtin_exports, CLEAR_INOBJECT_PROPERTIES, 16,
-                                "container to export to experimental natives");
-  native_context()->set_builtin_exports_object(*builtin_exports);
+  // Set up the utils object as shared container between native scripts.
+  Handle<JSObject> utils = factory()->NewJSObject(isolate()->object_function());
+  JSObject::NormalizeProperties(utils, CLEAR_INOBJECT_PROPERTIES, 16,
+                                "utils container for native scripts");
+  native_context()->set_natives_utils_object(*utils);
 
   Handle<JSObject> extras_exports =
       factory()->NewJSObject(isolate()->object_function());
   JSObject::NormalizeProperties(extras_exports, CLEAR_INOBJECT_PROPERTIES, 2,
                                 "container to export to extra natives");
   native_context()->set_extras_exports_object(*extras_exports);
 
   if (FLAG_expose_natives_as != NULL) {
-    Handle<String> shared_key = factory()->NewStringFromAsciiChecked("shared");
-    JSObject::AddProperty(builtins, shared_key, shared, NONE);
+    Handle<String> utils_key = factory()->NewStringFromAsciiChecked("utils");
+    JSObject::AddProperty(builtins, utils_key, utils, NONE);
   }
 
   {  // -- S c r i p t
     // Builtin functions for Script.
     Handle<JSFunction> script_fun = InstallFunction(
         builtins, "Script", JS_VALUE_TYPE, JSValue::kSize,
         isolate()->initial_object_prototype(), Builtins::kIllegal);
     Handle<JSObject> prototype =
         factory()->NewJSObject(isolate()->object_function(), TENURED);
     Accessors::FunctionSetPrototype(script_fun, prototype).Assert();
@@ skipping 155 matching lines @@
     native_context()->set_opaque_reference_function(*opaque_reference_fun);
   }
 
   // InternalArrays should not use Smi-Only array optimizations. There are too
   // many places in the C++ runtime code (e.g. RegEx) that assume that
   // elements in InternalArrays can be set to non-Smi values without going
   // through a common bottleneck that would make the SMI_ONLY -> FAST_ELEMENT
   // transition easy to trap. Moreover, they rarely are smi-only.
   {
     HandleScope scope(isolate());
-    Handle<JSObject> builtin_exports =
-        Handle<JSObject>::cast(isolate()->builtin_exports_object());
-    Handle<JSFunction> array_function = InstallInternalArray(
-        builtin_exports, "InternalArray", FAST_HOLEY_ELEMENTS);
+    Handle<JSObject> utils =
+        Handle<JSObject>::cast(isolate()->natives_utils_object());
+    Handle<JSFunction> array_function =
+        InstallInternalArray(utils, "InternalArray", FAST_HOLEY_ELEMENTS);
     native_context()->set_internal_array_function(*array_function);
-    InstallInternalArray(builtin_exports, "InternalPackedArray", FAST_ELEMENTS);
+    InstallInternalArray(utils, "InternalPackedArray", FAST_ELEMENTS);
   }
 
   {  // -- S e t I t e r a t o r
     Handle<JSFunction> set_iterator_function = InstallFunction(
         builtins, "SetIterator", JS_SET_ITERATOR_TYPE, JSSetIterator::kSize,
         isolate()->initial_object_prototype(), Builtins::kIllegal);
     native_context()->set_set_iterator_map(
         set_iterator_function->initial_map());
   }
 
@@ skipping 79 matching lines @@
   {
     static const PropertyAttributes attributes =
         static_cast<PropertyAttributes>(READ_ONLY | DONT_DELETE);
 #define INSTALL_PUBLIC_SYMBOL(name, varname, description)                 \
   Handle<String> varname = factory()->NewStringFromStaticChars(#varname); \
   JSObject::AddProperty(builtins, varname, factory()->name(), attributes);
     PUBLIC_SYMBOL_LIST(INSTALL_PUBLIC_SYMBOL)
 #undef INSTALL_PUBLIC_SYMBOL
   }
 
-  // Install natives. Everything exported to experimental natives is also
-  // shared to regular natives.
-  TransferNamedProperties(builtin_exports, shared);
   int i = Natives::GetDebuggerCount();
-  if (!CompileBuiltin(isolate(), i, shared)) return false;
+  if (!CompileBuiltin(isolate(), i)) return false;
   if (!InstallJSBuiltins(builtins)) return false;
 
   for (++i; i < Natives::GetBuiltinsCount(); ++i) {
-    if (!CompileBuiltin(isolate(), i, shared)) return false;
+    if (!CompileBuiltin(isolate(), i)) return false;
   }
 
+  if (!CallUtilsFunction(isolate(), "PostNatives")) return false;
+
   InstallNativeFunctions();
 
   auto function_cache =
       ObjectHashTable::New(isolate(), ApiNatives::kInitialFunctionCacheSize);
   native_context()->set_function_cache(*function_cache);
 
   // Store the map for the string prototype after the natives has been compiled
   // and the String function has been set up.
   Handle<JSFunction> string_function(native_context()->string_function());
   DCHECK(JSObject::cast(
@@ skipping 292 matching lines @@
   Handle<JSGlobalObject> global(JSGlobalObject::cast(
       native_context->global_object()));
 
   Handle<JSObject> Error = Handle<JSObject>::cast(
       Object::GetProperty(isolate, global, "Error").ToHandleChecked());
   Handle<String> name =
       factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("stackTraceLimit"));
   Handle<Smi> stack_trace_limit(Smi::FromInt(FLAG_stack_trace_limit), isolate);
   JSObject::AddProperty(Error, name, stack_trace_limit, NONE);
 
-  Handle<Object> builtin_exports(native_context->builtin_exports_object(),
-                                 isolate);
-  native_context->set_builtin_exports_object(Smi::FromInt(0));
+  // By now the utils object is useless and can be removed.
+  native_context->set_natives_utils_object(*factory->undefined_value());
 
   // Expose the natives in global if a name for it is specified.
   if (FLAG_expose_natives_as != NULL && strlen(FLAG_expose_natives_as) != 0) {
     Handle<String> natives_key =
         factory->InternalizeUtf8String(FLAG_expose_natives_as);
     uint32_t dummy_index;
     if (natives_key->AsArrayIndex(&dummy_index)) return true;
     Handle<JSBuiltinsObject> natives(global->builtins());
     JSObject::AddProperty(global, natives_key, natives, DONT_ENUM);
-    Handle<String> builtin_exports_key =
-        factory->NewStringFromAsciiChecked("builtin_exports");
-    JSObject::AddProperty(natives, builtin_exports_key, builtin_exports, NONE);
   }
 
   // Expose the stack trace symbol to native JS.
   RETURN_ON_EXCEPTION_VALUE(isolate,
                             JSObject::SetOwnPropertyIgnoreAttributes(
                                 handle(native_context->builtins(), isolate),
                                 factory->InternalizeOneByteString(
                                     STATIC_CHAR_VECTOR("$stackTraceSymbol")),
                                 factory->stack_trace_symbol(), NONE),
                             false);
@@ skipping 472 matching lines @@
   return from + sizeof(NestingCounterType);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 } }  // namespace v8::internal