Revert of Use function wrapper argument to expose internal arrays to native scripts.

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 199 matching lines @@
 
 #define DECLARE_FEATURE_INITIALIZATION(id, descr) \
   void InstallNativeFunctions_##id();             \
   void InitializeGlobal_##id();
 
   HARMONY_INPROGRESS(DECLARE_FEATURE_INITIALIZATION)
   HARMONY_STAGED(DECLARE_FEATURE_INITIALIZATION)
   HARMONY_SHIPPING(DECLARE_FEATURE_INITIALIZATION)
 #undef DECLARE_FEATURE_INITIALIZATION
 
-  Handle<JSFunction> InstallInternalArray(Handle<JSObject> target,
+  Handle<JSFunction> InstallInternalArray(Handle<JSBuiltinsObject> builtins,
                                           const char* name,
                                           ElementsKind elements_kind);
   bool InstallNatives();
 
   void InstallTypedArray(
       const char* name,
       ElementsKind elements_kind,
       Handle<JSFunction>* fun,
       Handle<Map>* external_map);
   bool InstallExperimentalNatives();
   bool InstallExtraNatives();
   void InstallBuiltinFunctionIds();
   void InstallJSFunctionResultCaches();
   void InitializeNormalizedMapCaches();
 
-  void RemoveExportObjects();
-
   enum ExtensionTraversalState {
     UNVISITED, VISITED, INSTALLED
   };
 
   class ExtensionStates {
    public:
     ExtensionStates();
     ExtensionTraversalState get_state(RegisteredExtension* extension);
     void set_state(RegisteredExtension* extension,
                    ExtensionTraversalState state);
@@ skipping 54 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 CompileExtension(Isolate* isolate, v8::Extension* extension);
+  static bool CompileNative(Isolate* isolate,
+                            Vector<const char> name,
+                            Handle<String> source);
+  static bool CompileScriptCached(Isolate* isolate,
+                                  Vector<const char> name,
+                                  Handle<String> source,
+                                  SourceCodeCache* cache,
+                                  v8::Extension* extension,
+                                  Handle<Context> top_context,
+                                  bool use_runtime_context);
 
   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.
   Handle<Map> sloppy_function_map_writable_prototype_;
@@ skipping 1101 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};
-  return CompileNative(isolate, name, source_code, arraysize(args), args);
+  return CompileNative(isolate, name, source_code);
 }
 
 
 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};
-  return CompileNative(isolate, name, source_code, arraysize(args), args);
+  return CompileNative(isolate, name, source_code);
 }
 
 
 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();
-  Handle<Object> exports = isolate->builtin_exports_object();
-  Handle<Object> args[] = {global, exports};
-  return CompileNative(isolate, name, source_code, arraysize(args), args);
+  return CompileNative(isolate, name, source_code);
 }
 
 
-bool Genesis::CompileNative(Isolate* isolate, Vector<const char> name,
-                            Handle<String> source, int argc,
-                            Handle<Object> argv[]) {
+bool Genesis::CompileNative(Isolate* isolate,
+                            Vector<const char> name,
+                            Handle<String> source) {
+  HandleScope scope(isolate);
   SuppressDebug compiling_natives(isolate->debug());
   // During genesis, the boilerplate for stack overflow won't work until the
   // environment has been at least partially initialized. Add a stack check
   // before entering JS code to catch overflow early.
   StackLimitCheck check(isolate);
   if (check.HasOverflowed()) return false;
 
-  Handle<Context> context(isolate->context());
-
-  Handle<String> script_name =
-      isolate->factory()->NewStringFromUtf8(name).ToHandleChecked();
-  Handle<SharedFunctionInfo> function_info = Compiler::CompileScript(
-      source, script_name, 0, 0, false, false, Handle<Object>(), context, NULL,
-      NULL, ScriptCompiler::kNoCompileOptions, NATIVES_CODE, false);
-
-  DCHECK(context->IsNativeContext());
-
-  Handle<Context> runtime_context(context->runtime_context());
-  Handle<JSBuiltinsObject> receiver(context->builtins());
-  Handle<JSFunction> fun =
-      isolate->factory()->NewFunctionFromSharedFunctionInfo(function_info,
-                                                            runtime_context);
-
-  // For non-extension scripts, run script to get the function wrapper.
-  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 result = CompileScriptCached(isolate,
+                                    name,
+                                    source,
+                                    NULL,
+                                    NULL,
+                                    Handle<Context>(isolate->context()),
+                                    true);
+  DCHECK(isolate->has_pending_exception() != result);
+  if (!result) isolate->clear_pending_exception();
+  return result;
 }
 
 
-bool Genesis::CompileExtension(Isolate* isolate, v8::Extension* extension) {
+bool Genesis::CompileScriptCached(Isolate* isolate,
+                                  Vector<const char> name,
+                                  Handle<String> source,
+                                  SourceCodeCache* cache,
+                                  v8::Extension* extension,
+                                  Handle<Context> top_context,
+                                  bool use_runtime_context) {
   Factory* factory = isolate->factory();
   HandleScope scope(isolate);
   Handle<SharedFunctionInfo> function_info;
 
-  Handle<String> source =
-      isolate->factory()
-          ->NewExternalStringFromOneByte(extension->source())
-          .ToHandleChecked();
-  DCHECK(source->IsOneByteRepresentation());
-
   // If we can't find the function in the cache, we compile a new
   // function and insert it into the cache.
-  Vector<const char> name = CStrVector(extension->name());
-  SourceCodeCache* cache = isolate->bootstrapper()->extensions_cache();
-  Handle<Context> context(isolate->context());
-  DCHECK(context->IsNativeContext());
-
-  if (!cache->Lookup(name, &function_info)) {
+  if (cache == NULL || !cache->Lookup(name, &function_info)) {
+    DCHECK(source->IsOneByteRepresentation());
     Handle<String> script_name =
         factory->NewStringFromUtf8(name).ToHandleChecked();
     function_info = Compiler::CompileScript(
-        source, script_name, 0, 0, false, false, Handle<Object>(), context,
-        extension, NULL, ScriptCompiler::kNoCompileOptions, NOT_NATIVES_CODE,
-        false);
+        source, script_name, 0, 0, false, false, Handle<Object>(), top_context,
+        extension, NULL, ScriptCompiler::kNoCompileOptions,
+        use_runtime_context ? NATIVES_CODE : NOT_NATIVES_CODE, false);
     if (function_info.is_null()) return false;
-    cache->Add(name, function_info);
+    if (cache != NULL) cache->Add(name, function_info);
   }
 
   // Set up the function context. Conceptually, we should clone the
   // function before overwriting the context but since we're in a
   // single-threaded environment it is not strictly necessary.
+  DCHECK(top_context->IsNativeContext());
+  Handle<Context> context =
+      Handle<Context>(use_runtime_context
+                      ? Handle<Context>(top_context->runtime_context())
+                      : top_context);
   Handle<JSFunction> fun =
       factory->NewFunctionFromSharedFunctionInfo(function_info, context);
 
   // Call function using either the runtime object or the global
   // object as the receiver. Provide no parameters.
-  Handle<Object> receiver = isolate->global_object();
-  return !Execution::Call(isolate, fun, receiver, 0, NULL).is_null();
+  Handle<Object> receiver =
+      Handle<Object>(use_runtime_context
+                     ? top_context->builtins()
+                     : top_context->global_object(),
+                     isolate);
+  MaybeHandle<Object> result;
+  if (extension == NULL) {
+    // For non-extension scripts, run script to get the function wrapper.
+    Handle<Object> wrapper;
+    if (!Execution::Call(isolate, fun, receiver, 0, NULL).ToHandle(&wrapper)) {
+      return false;
+    }
+    // Then run the function wrapper.
+    Handle<Object> global_obj(top_context->global_object(), isolate);
+    Handle<Object> args[] = {global_obj};
+    result = Execution::Call(isolate, Handle<JSFunction>::cast(wrapper),
+                             receiver, arraysize(args), args);
+  } else {
+    result = Execution::Call(isolate, fun, receiver, 0, NULL);
+  }
+  return !result.is_null();
 }
 
 
 static Handle<JSObject> ResolveBuiltinIdHolder(Handle<Context> native_context,
                                                const char* holder_expr) {
   Isolate* isolate = native_context->GetIsolate();
   Factory* factory = isolate->factory();
   Handle<GlobalObject> global(native_context->global_object());
   const char* period_pos = strchr(holder_expr, '.');
   if (period_pos == NULL) {
@@ skipping 250 matching lines @@
   Handle<JSObject> builtins(native_context()->builtins());
 
   Handle<HeapObject> flag(FLAG_harmony_tostring ? heap()->true_value()
                                                 : heap()->false_value());
   Runtime::SetObjectProperty(isolate(), builtins,
                              factory()->harmony_tostring_string(), flag,
                              STRICT).Assert();
 }
 
 
-Handle<JSFunction> Genesis::InstallInternalArray(Handle<JSObject> target,
-                                                 const char* name,
-                                                 ElementsKind elements_kind) {
+Handle<JSFunction> Genesis::InstallInternalArray(
+    Handle<JSBuiltinsObject> builtins,
+    const char* name,
+    ElementsKind elements_kind) {
   // --- I n t e r n a l   A r r a y ---
   // An array constructor on the builtins object that works like
   // the public Array constructor, except that its prototype
   // doesn't inherit from Object.prototype.
   // To be used only for internal work by builtins. Instances
   // must not be leaked to user code.
   Handle<JSObject> prototype =
       factory()->NewJSObject(isolate()->object_function(), TENURED);
-  Handle<JSFunction> array_function =
-      InstallFunction(target, name, JS_ARRAY_TYPE, JSArray::kSize, prototype,
-                      Builtins::kInternalArrayCode);
+  Handle<JSFunction> array_function = InstallFunction(
+      builtins, name, JS_ARRAY_TYPE, JSArray::kSize,
+      prototype, Builtins::kInternalArrayCode);
 
   InternalArrayConstructorStub internal_array_constructor_stub(isolate());
   Handle<Code> code = internal_array_constructor_stub.GetCode();
   array_function->shared()->set_construct_stub(*code);
   array_function->shared()->DontAdaptArguments();
 
   Handle<Map> original_map(array_function->initial_map());
   Handle<Map> initial_map = Map::Copy(original_map, "InternalArray");
   initial_map->set_elements_kind(elements_kind);
   JSFunction::SetInitialMap(array_function, initial_map, prototype);
@@ skipping 57 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);
-
-  if (FLAG_expose_natives_as != nullptr) {
-    Handle<String> shared_key = factory()->NewStringFromAsciiChecked("shared");
-    Handle<String> builtin_exports_key =
-        factory()->NewStringFromAsciiChecked("builtin_exports");
-    JSObject::AddProperty(builtins, shared_key, shared, NONE);
-    JSObject::AddProperty(builtins, builtin_exports_key, builtin_exports, 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();
     native_context()->set_script_function(*script_fun);
 
@@ skipping 152 matching lines @@
     Accessors::FunctionSetPrototype(opaque_reference_fun, prototype).Assert();
     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<JSFunction> array_function =
+        InstallInternalArray(builtins, "InternalArray", FAST_HOLEY_ELEMENTS);
     native_context()->set_internal_array_function(*array_function);
-    InstallInternalArray(builtin_exports, "InternalPackedArray", FAST_ELEMENTS);
+  }
+
+  {
+    InstallInternalArray(builtins, "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 72 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);
+  // Install natives.
   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;
   }
 
   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.
@@ skipping 183 matching lines @@
 bool Genesis::InstallExtraNatives() {
   for (int i = ExtraNatives::GetDebuggerCount();
        i < ExtraNatives::GetBuiltinsCount(); i++) {
     if (!CompileExtraBuiltin(isolate(), i)) return false;
   }
 
   return true;
 }
 
 
-void Genesis::RemoveExportObjects() {
-  native_context_->set_builtin_exports_object(Smi::FromInt(0));
-}
-
-
 static void InstallBuiltinFunctionId(Handle<JSObject> holder,
                                      const char* function_name,
                                      BuiltinFunctionId id) {
   Isolate* isolate = holder->GetIsolate();
   Handle<Object> function_object =
       Object::GetProperty(isolate, holder, function_name).ToHandleChecked();
   Handle<JSFunction> function = Handle<JSFunction>::cast(function_object);
   function->shared()->set_function_data(Smi::FromInt(id));
 }
 
@@ skipping 242 matching lines @@
   v8::Extension* extension = current->extension();
   // Install the extension's dependencies
   for (int i = 0; i < extension->dependency_count(); i++) {
     if (!InstallExtension(isolate,
                           extension->dependencies()[i],
                           extension_states)) {
       return false;
     }
   }
   // We do not expect this to throw an exception. Change this if it does.
-  bool result = CompileExtension(isolate, extension);
+  Handle<String> source_code =
+      isolate->factory()
+          ->NewExternalStringFromOneByte(extension->source())
+          .ToHandleChecked();
+  bool result = CompileScriptCached(isolate,
+                                    CStrVector(extension->name()),
+                                    source_code,
+                                    isolate->bootstrapper()->extensions_cache(),
+                                    extension,
+                                    Handle<Context>(isolate->context()),
+                                    false);
   DCHECK(isolate->has_pending_exception() != result);
   if (!result) {
     // We print out the name of the extension that fail to install.
     // When an error is thrown during bootstrapping we automatically print
     // the line number at which this happened to the console in the isolate
     // error throwing functionality.
     base::OS::PrintError("Error installing extension '%s'.\n",
                          current->extension()->name());
     isolate->clear_pending_exception();
   }
@@ skipping 230 matching lines @@
   // The deserializer needs to hook up references to the global proxy.
   // Create an uninitialized global proxy now if we don't have one
   // and initialize it later in CreateNewGlobals.
   Handle<JSGlobalProxy> global_proxy;
   if (!maybe_global_proxy.ToHandle(&global_proxy)) {
     global_proxy = isolate->factory()->NewUninitializedJSGlobalProxy();
   }
 
   // We can only de-serialize a context if the isolate was initialized from
   // a snapshot. Otherwise we have to build the context from scratch.
-  // Also create a context from scratch to expose natives, if required by flag.
   Handle<FixedArray> outdated_contexts;
-  if (FLAG_expose_natives_as != nullptr ||
-      !isolate->initialized_from_snapshot() ||
+  if (!isolate->initialized_from_snapshot() ||
       !Snapshot::NewContextFromSnapshot(isolate, global_proxy,
                                         &outdated_contexts)
            .ToHandle(&native_context_)) {
     native_context_ = Handle<Context>();
   }
 
   if (!native_context().is_null()) {
     AddToWeakNativeContextList(*native_context());
     isolate->set_context(*native_context());
     isolate->counters()->contexts_created_by_snapshot()->Increment();
@@ skipping 35 matching lines @@
     isolate->counters()->contexts_created_from_scratch()->Increment();
   }
 
   // Install experimental and extra 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 (!isolate->serializer_enabled()) {
     InitializeExperimentalGlobal();
     if (!InstallExperimentalNatives()) return;
     if (!InstallExtraNatives()) return;
-
-    // Exports are no longer needed.
-    RemoveExportObjects();
   }
 
   // The serializer cannot serialize typed arrays. Reset those typed arrays
   // for each new context.
   InitializeBuiltinTypedArrays();
 
   result_ = native_context();
 }
 
 
@@ skipping 19 matching lines @@
   return from + sizeof(NestingCounterType);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 } }  // namespace v8::internal