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

src/compiler/wasm-compiler.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 "src/compiler/wasm-compiler.h"
 
 #include <memory>
 
 #include "src/isolate-inl.h"
 
@@ skipping 2548 matching lines @@
                               graph()->start());
   }
   Node* jsval = ToJS(
       retval, sig->return_count() == 0 ? wasm::kAstStmt : sig->GetReturn());
   Node* ret =
       graph()->NewNode(jsgraph()->common()->Return(), jsval, call, start);
 
   MergeControlToEnd(jsgraph(), ret);
 }
 
-void WasmGraphBuilder::BuildWasmToJSWrapper(Handle<JSReceiver> target,
+void WasmGraphBuilder::BuildWasmToJSWrapper(Handle<Context> context,
+                                            Handle<JSReceiver> target,
                                             wasm::FunctionSig* sig) {
   DCHECK(target->IsCallable());
 
   int wasm_count = static_cast<int>(sig->parameter_count());
   int param_count;
   if (jsgraph()->machine()->Is64()) {
     param_count = wasm_count;
   } else {
     param_count = Int64Lowering::GetParameterCountAfterLowering(sig);
   }
 
   // Build the start and the parameter nodes.
   Isolate* isolate = jsgraph()->isolate();
   CallDescriptor* desc;
   Node* start = Start(param_count + 3);
   *effect_ = start;
   *control_ = start;
   Node** args = Buffer(wasm_count + 7);
 
   // The default context of the target.
-  Handle<Context> target_context = isolate->native_context();
+  Handle<Context> target_context = context;
 
   // Optimization: check if the target is a JSFunction with the right arity so
   // that we can call it directly.
   bool call_direct = false;
   int pos = 0;
   if (target->IsJSFunction()) {
     Handle<JSFunction> function = Handle<JSFunction>::cast(target);
     if (function->shared()->internal_formal_parameter_count() == wasm_count) {
       call_direct = true;
 
@@ skipping 49 matching lines @@
 
   args[pos++] = HeapConstant(target_context);
   args[pos++] = *effect_;
   args[pos++] = *control_;
 
   Node* call = graph()->NewNode(jsgraph()->common()->Call(desc), pos, args);
 
   // Convert the return value back.
   Node* ret;
   Node* val =
-      FromJS(call, HeapConstant(isolate->native_context()),
+      FromJS(call, HeapConstant(context),
              sig->return_count() == 0 ? wasm::kAstStmt : sig->GetReturn());
   if (jsgraph()->machine()->Is32() && sig->return_count() > 0 &&
       sig->GetReturn() == wasm::kAstI64) {
     ret = graph()->NewNode(jsgraph()->common()->Return(), val,
                            graph()->NewNode(jsgraph()->machine()->Word32Sar(),
                                             val, jsgraph()->Int32Constant(31)),
                            call, start);
   } else {
     ret = graph()->NewNode(jsgraph()->common()->Return(), val, call, start);
   }
@@ skipping 335 matching lines @@
 
   if (isolate->logger()->is_logging_code_events() || isolate->is_profiling()) {
     RecordFunctionCompilation(
         CodeEventListener::FUNCTION_TAG, isolate, code, "js-to-wasm", index,
         wasm::WasmName("export"),
         module->module->GetName(func->name_offset, func->name_length));
   }
   return code;
 }
 
-Handle<Code> CompileWasmToJSWrapper(Isolate* isolate, Handle<JSReceiver> target,
+Handle<Code> CompileWasmToJSWrapper(Isolate* isolate, Handle<Context> context,
+                                    Handle<JSReceiver> target,
                                     wasm::FunctionSig* sig, uint32_t index,
                                     Handle<String> import_module,
                                     MaybeHandle<String> import_function) {
   //----------------------------------------------------------------------------
   // Create the Graph
   //----------------------------------------------------------------------------
   Zone zone(isolate->allocator());
   Graph graph(&zone);
   CommonOperatorBuilder common(&zone);
   MachineOperatorBuilder machine(&zone);
   JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
 
   Node* control = nullptr;
   Node* effect = nullptr;
 
   WasmGraphBuilder builder(&zone, &jsgraph, sig);
   builder.set_control_ptr(&control);
   builder.set_effect_ptr(&effect);
-  builder.BuildWasmToJSWrapper(target, sig);
+  builder.BuildWasmToJSWrapper(context, target, sig);
 
   Handle<Code> code = Handle<Code>::null();
   {
     if (FLAG_trace_turbo_graph) {  // Simple textual RPO.
       OFStream os(stdout);
       os << "-- Graph after change lowering -- " << std::endl;
       os << AsRPO(graph);
     }
 
     // Schedule and compile to machine code.
@@ skipping 224 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8