[api] Introduce fast instantiations cache

src/wasm/wasm-module.cc

 // Copyright 2015 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 <memory>
 
 #include "src/base/atomic-utils.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
@@ skipping 186 matching lines @@
   kTable,  // FixedArray of indirect function table
   kWasmIndirectFunctionTableMetadataSize  // Sentinel value.
 };
 
 uint32_t GetMinModuleMemSize(const WasmModule* module) {
   return WasmModule::kPageSize * module->min_mem_pages;
 }
 
 void LoadDataSegments(Handle<FixedArray> compiled_module, Address mem_addr,
                       size_t mem_size) {
+  Isolate* isolate = compiled_module->GetIsolate();
   MaybeHandle<ByteArray> maybe_data =
-      compiled_module->GetValue<ByteArray>(kDataSegments);
+      compiled_module->GetValue<ByteArray>(isolate, kDataSegments);
   MaybeHandle<FixedArray> maybe_segments =
-      compiled_module->GetValue<FixedArray>(kDataSegmentsInfo);
+      compiled_module->GetValue<FixedArray>(isolate, kDataSegmentsInfo);
 
   // We either have both or neither.
   CHECK(maybe_data.is_null() == maybe_segments.is_null());
   // If we have neither, we're done.
   if (maybe_data.is_null()) return;
 
   Handle<ByteArray> data = maybe_data.ToHandleChecked();
   Handle<FixedArray> segments = maybe_segments.ToHandleChecked();
 
   uint32_t last_extraction_pos = 0;
@@ skipping 189 matching lines @@
 void LinkImports(Isolate* isolate, std::vector<Handle<Code>>& functions,
                  const std::vector<Handle<Code>>& imports) {
   for (uint32_t i = 0; i < functions.size(); ++i) {
     Handle<Code> code = functions[i];
     LinkFunction(code, imports, Code::WASM_TO_JS_FUNCTION);
   }
 }
 
 void FlushAssemblyCache(Isolate* isolate, Handle<FixedArray> functions) {
   for (int i = 0; i < functions->length(); ++i) {
-    Handle<Code> code = functions->GetValueChecked<Code>(i);
+    Handle<Code> code = functions->GetValueChecked<Code>(isolate, i);
     Assembler::FlushICache(isolate, code->instruction_start(),
                            code->instruction_size());
   }
 }
 
 }  // namespace
 
 WasmModule::WasmModule(byte* module_start)
     : module_start(module_start),
       module_end(nullptr),
@@ skipping 189 matching lines @@
 
 bool CompileWrappersToImportedFunctions(Isolate* isolate,
                                         const Handle<JSReceiver> ffi,
                                         std::vector<Handle<Code>>& imports,
                                         Handle<FixedArray> import_data,
                                         ErrorThrower* thrower) {
   uint32_t import_count = static_cast<uint32_t>(import_data->length());
   if (import_count > 0) {
     imports.reserve(import_count);
     for (uint32_t index = 0; index < import_count; ++index) {
-      Handle<FixedArray> data = import_data->GetValueChecked<FixedArray>(index);
-      Handle<String> module_name = data->GetValueChecked<String>(kModuleName);
-      MaybeHandle<String> function_name = data->GetValue<String>(kFunctionName);
+      Handle<FixedArray> data =
+          import_data->GetValueChecked<FixedArray>(isolate, index);
+      Handle<String> module_name =
+          data->GetValueChecked<String>(isolate, kModuleName);
+      MaybeHandle<String> function_name =
+          data->GetValue<String>(isolate, kFunctionName);
 
       // TODO(mtrofin): this is an uint32_t, actually. We should rationalize
       // it when we rationalize signed/unsigned stuff.
       int ret_count = Smi::cast(data->get(kOutputCount))->value();
       CHECK(ret_count >= 0);
-      Handle<ByteArray> sig_data = data->GetValueChecked<ByteArray>(kSignature);
+      Handle<ByteArray> sig_data =
+          data->GetValueChecked<ByteArray>(isolate, kSignature);
       int sig_data_size = sig_data->length();
       int param_count = sig_data_size - ret_count;
       CHECK(param_count >= 0);
 
       MaybeHandle<JSFunction> function = LookupFunction(
           *thrower, isolate->factory(), ffi, index, module_name, function_name);
       if (function.is_null()) return false;
 
       {
         // Copy the signature to avoid a raw pointer into a heap object when
@@ skipping 164 matching lines @@
                      str.start());
       break;
     }
       // Install the code into the linker table.
     functions[i] = code;
   }
 }
 
 void SetDebugSupport(Factory* factory, Handle<FixedArray> compiled_module,
                      Handle<JSObject> js_object) {
+  Isolate* isolate = compiled_module->GetIsolate();
   MaybeHandle<String> module_bytes_string =
-      compiled_module->GetValue<String>(kModuleBytes);
+      compiled_module->GetValue<String>(isolate, kModuleBytes);
   if (!module_bytes_string.is_null()) {
     js_object->SetInternalField(kWasmModuleBytesString,
                                 *module_bytes_string.ToHandleChecked());
   }
   Handle<FixedArray> functions = Handle<FixedArray>(
       FixedArray::cast(js_object->GetInternalField(kWasmModuleCodeTable)));
 
   for (int i = FLAG_skip_compiling_wasm_funcs; i < functions->length(); ++i) {
-    Handle<Code> code = functions->GetValueChecked<Code>(i);
+    Handle<Code> code = functions->GetValueChecked<Code>(isolate, i);
     DCHECK(code->deoptimization_data() == nullptr ||
            code->deoptimization_data()->length() == 0);
     Handle<FixedArray> deopt_data = factory->NewFixedArray(2, TENURED);
     if (!js_object.is_null()) {
       deopt_data->set(0, *js_object);
     }
     deopt_data->set(1, Smi::FromInt(static_cast<int>(i)));
     deopt_data->set_length(2);
     code->set_deoptimization_data(*deopt_data);
   }
 
   MaybeHandle<ByteArray> function_name_table =
-      compiled_module->GetValue<ByteArray>(kFunctionNameTable);
+      compiled_module->GetValue<ByteArray>(isolate, kFunctionNameTable);
   if (!function_name_table.is_null()) {
     js_object->SetInternalField(kWasmFunctionNamesArray,
                                 *function_name_table.ToHandleChecked());
   }
 }
 
 bool SetupGlobals(Isolate* isolate, Handle<FixedArray> compiled_module,
                   Handle<JSObject> instance, ErrorThrower* thrower) {
   uint32_t globals_size = static_cast<uint32_t>(
       Smi::cast(compiled_module->get(kGlobalsSize))->value());
@@ skipping 38 matching lines @@
 }
 
 bool SetupImports(Isolate* isolate, Handle<FixedArray> compiled_module,
                   Handle<JSObject> instance, ErrorThrower* thrower,
                   Handle<JSReceiver> ffi) {
   //-------------------------------------------------------------------------
   // Compile wrappers to imported functions.
   //-------------------------------------------------------------------------
   std::vector<Handle<Code>> import_code;
   MaybeHandle<FixedArray> maybe_import_data =
-      compiled_module->GetValue<FixedArray>(kImportData);
+      compiled_module->GetValue<FixedArray>(isolate, kImportData);
   Handle<FixedArray> import_data;
   if (maybe_import_data.ToHandle(&import_data)) {
     if (!CompileWrappersToImportedFunctions(isolate, ffi, import_code,
                                             import_data, thrower)) {
       return false;
     }
   }
 
   RecordStats(isolate, import_code);
 
@@ skipping 13 matching lines @@
 
 bool SetupExportsObject(Handle<FixedArray> compiled_module, Isolate* isolate,
                         Handle<JSObject> instance, ErrorThrower* thrower) {
   Factory* factory = isolate->factory();
   bool mem_export =
       static_cast<bool>(Smi::cast(compiled_module->get(kExportMem))->value());
   ModuleOrigin origin = static_cast<ModuleOrigin>(
       Smi::cast(compiled_module->get(kOrigin))->value());
 
   MaybeHandle<FixedArray> maybe_exports =
-      compiled_module->GetValue<FixedArray>(kExports);
+      compiled_module->GetValue<FixedArray>(isolate, kExports);
   if (!maybe_exports.is_null() || mem_export) {
     PropertyDescriptor desc;
     desc.set_writable(false);
 
     Handle<JSObject> exports_object = instance;
     if (origin == kWasmOrigin) {
       // Create the "exports" object.
       Handle<JSFunction> object_function = Handle<JSFunction>(
           isolate->native_context()->object_function(), isolate);
       exports_object = factory->NewJSObject(object_function, TENURED);
       Handle<String> exports_name = factory->InternalizeUtf8String("exports");
       JSObject::AddProperty(instance, exports_name, exports_object, READ_ONLY);
     }
     Handle<FixedArray> exports;
     if (maybe_exports.ToHandle(&exports)) {
       int exports_size = exports->length();
       for (int i = 0; i < exports_size; ++i) {
         if (thrower->error()) return false;
         Handle<FixedArray> export_metadata =
-            exports->GetValueChecked<FixedArray>(i);
+            exports->GetValueChecked<FixedArray>(isolate, i);
         Handle<Code> export_code =
-            export_metadata->GetValueChecked<Code>(kExportCode);
+            export_metadata->GetValueChecked<Code>(isolate, kExportCode);
         RecordStats(isolate, *export_code);
         Handle<String> name =
-            export_metadata->GetValueChecked<String>(kExportName);
+            export_metadata->GetValueChecked<String>(isolate, kExportName);
         int arity = Smi::cast(export_metadata->get(kExportArity))->value();
         Handle<JSFunction> function = WrapExportCodeAsJSFunction(
             isolate, export_code, name, arity, instance);
         desc.set_value(function);
         Maybe<bool> status = JSReceiver::DefineOwnProperty(
             isolate, exports_object, name, &desc, Object::THROW_ON_ERROR);
         if (!status.IsJust()) {
           thrower->Error("export of %.*s failed.", name->length(),
                          name->ToCString().get());
           return false;
@@ skipping 183 matching lines @@
 }
 
 Handle<FixedArray> CloneModuleForInstance(Isolate* isolate,
                                           Handle<FixedArray> original) {
   Factory* factory = isolate->factory();
   Handle<FixedArray> clone = factory->CopyFixedArray(original);
 
   // Copy the outer table, each WasmIndirectFunctionTableMetadata table, and the
   // inner kTable.
   MaybeHandle<FixedArray> maybe_indirect_tables =
-      original->GetValue<FixedArray>(kTableOfIndirectFunctionTables);
+      original->GetValue<FixedArray>(isolate, kTableOfIndirectFunctionTables);
   Handle<FixedArray> indirect_tables, clone_indirect_tables;
   if (maybe_indirect_tables.ToHandle(&indirect_tables)) {
     clone_indirect_tables = factory->CopyFixedArray(indirect_tables);
     clone->set(kTableOfIndirectFunctionTables, *clone_indirect_tables);
     for (int i = 0; i < clone_indirect_tables->length(); ++i) {
       Handle<FixedArray> orig_metadata =
-          clone_indirect_tables->GetValueChecked<FixedArray>(i);
+          clone_indirect_tables->GetValueChecked<FixedArray>(isolate, i);
       Handle<FixedArray> clone_metadata =
           factory->CopyFixedArray(orig_metadata);
       clone_indirect_tables->set(i, *clone_metadata);
 
       Handle<FixedArray> orig_table =
-          clone_metadata->GetValueChecked<FixedArray>(kTable);
+          clone_metadata->GetValueChecked<FixedArray>(isolate, kTable);
       Handle<FixedArray> clone_table = factory->CopyFixedArray(orig_table);
       clone_metadata->set(kTable, *clone_table);
     }
   }
 
   // Clone each code, then if indirect tables are used, patch the cloned code to
   // refer to the cloned kTable.
   Handle<FixedArray> orig_wasm_functions =
-      original->GetValueChecked<FixedArray>(kFunctions);
+      original->GetValueChecked<FixedArray>(isolate, kFunctions);
   Handle<FixedArray> clone_wasm_functions =
       factory->CopyFixedArray(orig_wasm_functions);
   clone->set(kFunctions, *clone_wasm_functions);
   for (int i = 0; i < clone_wasm_functions->length(); ++i) {
-    Handle<Code> orig_code = clone_wasm_functions->GetValueChecked<Code>(i);
+    Handle<Code> orig_code =
+        clone_wasm_functions->GetValueChecked<Code>(isolate, i);
     Handle<Code> cloned_code = factory->CopyCode(orig_code);
     clone_wasm_functions->set(i, *cloned_code);
 
     if (!clone_indirect_tables.is_null()) {
       for (int j = 0; j < clone_indirect_tables->length(); ++j) {
         Handle<FixedArray> orig_metadata =
-            indirect_tables->GetValueChecked<FixedArray>(j);
+            indirect_tables->GetValueChecked<FixedArray>(isolate, j);
         Handle<FixedArray> orig_table =
-            orig_metadata->GetValueChecked<FixedArray>(kTable);
+            orig_metadata->GetValueChecked<FixedArray>(isolate, kTable);
 
         Handle<FixedArray> clone_metadata =
-            clone_indirect_tables->GetValueChecked<FixedArray>(j);
+            clone_indirect_tables->GetValueChecked<FixedArray>(isolate, j);
         Handle<FixedArray> clone_table =
-            clone_metadata->GetValueChecked<FixedArray>(kTable);
+            clone_metadata->GetValueChecked<FixedArray>(isolate, kTable);
 
         PatchFunctionTable(cloned_code, orig_table, clone_table);
       }
     }
   }
 
   MaybeHandle<FixedArray> maybe_orig_exports =
-      original->GetValue<FixedArray>(kExports);
+      original->GetValue<FixedArray>(isolate, kExports);
   Handle<FixedArray> orig_exports;
   if (maybe_orig_exports.ToHandle(&orig_exports)) {
     Handle<FixedArray> cloned_exports = factory->CopyFixedArray(orig_exports);
     clone->set(kExports, *cloned_exports);
     for (int i = 0; i < orig_exports->length(); ++i) {
       Handle<FixedArray> export_metadata =
-          orig_exports->GetValueChecked<FixedArray>(i);
+          orig_exports->GetValueChecked<FixedArray>(isolate, i);
       Handle<FixedArray> clone_metadata =
           factory->CopyFixedArray(export_metadata);
       cloned_exports->set(i, *clone_metadata);
       Handle<Code> orig_code =
-          export_metadata->GetValueChecked<Code>(kExportCode);
+          export_metadata->GetValueChecked<Code>(isolate, kExportCode);
       Handle<Code> cloned_code = factory->CopyCode(orig_code);
       clone_metadata->set(kExportCode, *cloned_code);
       // TODO(wasm): This is actually a uint32_t, but since FixedArray indexes
       // in int, we are taking the risk of invalid values.
       int exported_fct_index =
           Smi::cast(export_metadata->get(kExportedFunctionIndex))->value();
       CHECK_GE(exported_fct_index, 0);
       CHECK_LT(exported_fct_index, clone_wasm_functions->length());
-      Handle<Code> new_target =
-          clone_wasm_functions->GetValueChecked<Code>(exported_fct_index);
+      Handle<Code> new_target = clone_wasm_functions->GetValueChecked<Code>(
+          isolate, exported_fct_index);
       PatchJSWrapper(isolate, cloned_code, new_target);
     }
   }
 
   MaybeHandle<FixedArray> maybe_startup =
-      original->GetValue<FixedArray>(kStartupFunction);
+      original->GetValue<FixedArray>(isolate, kStartupFunction);
   if (!maybe_startup.is_null()) {
     Handle<FixedArray> startup_metadata =
         factory->CopyFixedArray(maybe_startup.ToHandleChecked());
-    Handle<Code> startup_fct_clone =
-        factory->CopyCode(startup_metadata->GetValueChecked<Code>(kExportCode));
+    Handle<Code> startup_fct_clone = factory->CopyCode(
+        startup_metadata->GetValueChecked<Code>(isolate, kExportCode));
     startup_metadata->set(kExportCode, *startup_fct_clone);
     clone->set(kStartupFunction, *startup_metadata);
     // TODO(wasm): see todo above about int vs size_t indexing in FixedArray.
     int startup_fct_index =
         Smi::cast(startup_metadata->get(kExportedFunctionIndex))->value();
     CHECK_GE(startup_fct_index, 0);
     CHECK_LT(startup_fct_index, clone_wasm_functions->length());
     Handle<Code> new_target =
-        clone_wasm_functions->GetValueChecked<Code>(startup_fct_index);
+        clone_wasm_functions->GetValueChecked<Code>(isolate, startup_fct_index);
     PatchJSWrapper(isolate, startup_fct_clone, new_target);
   }
   return clone;
 }
 
 // Instantiates a wasm module as a JSObject.
 //  * allocates a backing store of {mem_size} bytes.
 //  * installs a named property "memory" for that buffer if exported
 //  * installs named properties on the object for exported functions
 //  * compiles wasm code to machine code
 MaybeHandle<JSObject> WasmModule::Instantiate(
     Isolate* isolate, Handle<FixedArray> compiled_module,
     Handle<JSReceiver> ffi, Handle<JSArrayBuffer> memory) {
   HistogramTimerScope wasm_instantiate_module_time_scope(
       isolate->counters()->wasm_instantiate_module_time());
   ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
   Factory* factory = isolate->factory();
 
   compiled_module = CloneModuleForInstance(isolate, compiled_module);
 
   // These fields are compulsory.
   Handle<FixedArray> code_table =
-      compiled_module->GetValueChecked<FixedArray>(kFunctions);
+      compiled_module->GetValueChecked<FixedArray>(isolate, kFunctions);
 
   std::vector<Handle<Code>> functions(
       static_cast<size_t>(code_table->length()));
   for (int i = 0; i < code_table->length(); ++i) {
-    functions[static_cast<size_t>(i)] = code_table->GetValueChecked<Code>(i);
+    functions[static_cast<size_t>(i)] =
+        code_table->GetValueChecked<Code>(isolate, i);
   }
   LinkModuleFunctions(isolate, functions);
 
   RecordStats(isolate, code_table);
 
   MaybeHandle<JSObject> nothing;
 
   Handle<Map> map = factory->NewMap(
       JS_OBJECT_TYPE,
       JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
   Handle<JSObject> js_object = factory->NewJSObjectFromMap(map, TENURED);
   js_object->SetInternalField(kWasmModuleCodeTable, *code_table);
 
   if (!(SetupInstanceHeap(isolate, compiled_module, js_object, memory,
                           &thrower) &&
         SetupGlobals(isolate, compiled_module, js_object, &thrower) &&
         SetupImports(isolate, compiled_module, js_object, &thrower, ffi) &&
         SetupExportsObject(compiled_module, isolate, js_object, &thrower))) {
     return nothing;
   }
 
   SetDebugSupport(factory, compiled_module, js_object);
 
   FlushAssemblyCache(isolate, code_table);
 
   MaybeHandle<FixedArray> maybe_indirect_tables =
-      compiled_module->GetValue<FixedArray>(kTableOfIndirectFunctionTables);
+      compiled_module->GetValue<FixedArray>(isolate,
+                                            kTableOfIndirectFunctionTables);
   Handle<FixedArray> indirect_tables;
   if (maybe_indirect_tables.ToHandle(&indirect_tables)) {
     for (int i = 0; i < indirect_tables->length(); ++i) {
       Handle<FixedArray> metadata =
-          indirect_tables->GetValueChecked<FixedArray>(i);
+          indirect_tables->GetValueChecked<FixedArray>(isolate, i);
       uint32_t size = Smi::cast(metadata->get(kSize))->value();
-      Handle<FixedArray> table = metadata->GetValueChecked<FixedArray>(kTable);
+      Handle<FixedArray> table =
+          metadata->GetValueChecked<FixedArray>(isolate, kTable);
       wasm::PopulateFunctionTable(table, size, &functions);
     }
     js_object->SetInternalField(kWasmModuleFunctionTable, *indirect_tables);
   }
 
   // Run the start function if one was specified.
   MaybeHandle<FixedArray> maybe_startup_fct =
-      compiled_module->GetValue<FixedArray>(kStartupFunction);
+      compiled_module->GetValue<FixedArray>(isolate, kStartupFunction);
   Handle<FixedArray> metadata;
   if (maybe_startup_fct.ToHandle(&metadata)) {
     HandleScope scope(isolate);
-    Handle<Code> startup_code = metadata->GetValueChecked<Code>(kExportCode);
+    Handle<Code> startup_code =
+        metadata->GetValueChecked<Code>(isolate, kExportCode);
     int arity = Smi::cast(metadata->get(kExportArity))->value();
     Handle<JSFunction> startup_fct = WrapExportCodeAsJSFunction(
         isolate, startup_code, factory->InternalizeUtf8String("start"), arity,
         js_object);
     RecordStats(isolate, *startup_code);
     // Call the JS function.
     Handle<Object> undefined = isolate->factory()->undefined_value();
     MaybeHandle<Object> retval =
         Execution::Call(isolate, startup_fct, undefined, 0, nullptr);
 
@@ skipping 241 matching lines @@
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8