[wasm] Use the right context in the wasm-to-js wrapper.

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/code-stubs.h"
 
 #include "src/macro-assembler.h"
@@ skipping 618 matching lines @@
     encoded_import->set(
         kOutputCount,
         Smi::FromInt(static_cast<int>(import.sig->return_count())));
     encoded_import->set(kSignature, *sig);
     ret->set(static_cast<int>(i), *encoded_import);
   }
   return ret;
 }
 
 bool CompileWrappersToImportedFunctions(Isolate* isolate,
+                                        Handle<Context> context,
                                         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>(isolate, index);
@@ skipping 52 matching lines @@
       } else {
         // Copy the signature to avoid a raw pointer into a heap object when
         // GC can happen.
         Zone zone(isolate->allocator());
         MachineRepresentation* reps =
             zone.NewArray<MachineRepresentation>(sig_data_size);
         memcpy(reps, sig_data->data(),
                sizeof(MachineRepresentation) * sig_data_size);
         FunctionSig sig(ret_count, param_count, reps);
 
-        code = compiler::CompileWasmToJSWrapper(isolate, target, &sig, index,
-                                                module_name, function_name);
+        code = compiler::CompileWasmToJSWrapper(
+            isolate, context, target, &sig, index, module_name, function_name);
       }
       imports.push_back(code);
     }
   }
   return true;
 }
 
 void InitializeParallelCompilation(
     Isolate* isolate, const std::vector<WasmFunction>& functions,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
@@ skipping 217 matching lines @@
     instance->SetInternalField(kWasmMemArrayBuffer, *memory);
     Address mem_start = static_cast<Address>(memory->backing_store());
     uint32_t mem_size = static_cast<uint32_t>(memory->byte_length()->Number());
     RelocateInstanceCode(instance, mem_start,
                          WasmModule::kPageSize * min_mem_pages, mem_size);
     LoadDataSegments(compiled_module, mem_start, mem_size);
   }
   return true;
 }
 
-bool SetupImports(Isolate* isolate, Handle<FixedArray> compiled_module,
-                  Handle<JSObject> instance, ErrorThrower* thrower,
-                  Handle<JSReceiver> ffi) {
+bool SetupImports(Isolate* isolate, Handle<Context> context,
+                  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>(isolate, kImportData);
   Handle<FixedArray> import_data;
   if (maybe_import_data.ToHandle(&import_data)) {
-    if (!CompileWrappersToImportedFunctions(isolate, ffi, import_code,
+    if (!CompileWrappersToImportedFunctions(isolate, context, ffi, import_code,
                                             import_data, thrower)) {
       return false;
     }
   }
 
   RecordStats(isolate, import_code);
 
   Handle<FixedArray> code_table = Handle<FixedArray>(
       FixedArray::cast(instance->GetInternalField(kWasmModuleCodeTable)));
   // TODO(mtrofin): get the code off std::vector and on FixedArray, for
@@ skipping 344 matching lines @@
   }
   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) {
+    Isolate* isolate, Handle<Context> context,
+    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>(isolate, kFunctions);
@@ skipping 12 matching lines @@
 
   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) &&
+        SetupImports(isolate, context, 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>(isolate,
@@ skipping 245 matching lines @@
   if (module->export_table.size() == 0) {
     thrower.Error("Not supported: module has no exports.");
   }
 
   if (thrower.error()) return -1;
   MaybeHandle<FixedArray> compiled_module =
       module->CompileFunctions(isolate, &thrower);
 
   if (compiled_module.is_null()) return -1;
   Handle<JSObject> instance =
-      WasmModule::Instantiate(isolate, compiled_module.ToHandleChecked(),
+      WasmModule::Instantiate(isolate, handle(isolate->context(), isolate),
+                              compiled_module.ToHandleChecked(),
                               Handle<JSReceiver>::null(),
                               Handle<JSArrayBuffer>::null())
           .ToHandleChecked();
 
   return CallFunction(isolate, instance, &thrower, "main", 0, nullptr);
 }
 
 int32_t CallFunction(Isolate* isolate, Handle<JSObject> instance,
                      ErrorThrower* thrower, const char* name, int argc,
                      Handle<Object> argv[]) {
@@ skipping 26 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