[wasm] Pass the context to ToJS.

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 1127 matching lines @@
                                 TENURED);
       exportedSig->copy_in(0,
                            reinterpret_cast<const byte*>(funcSig->raw_data()),
                            exportedSig->length());
       export_metadata->set(kExportedSignature, *exportedSig);
       WasmName str = GetName(exp.name_offset, exp.name_length);
       Handle<String> name = factory->InternalizeUtf8String(str);
       Handle<Code> code =
           temp_instance_for_compilation.function_code[exp.func_index];
       Handle<Code> export_code = compiler::CompileJSToWasmWrapper(
-          isolate, &module_env, code, exp.func_index);
+          isolate, temp_instance_for_compilation.context, &module_env, code,
+          exp.func_index);
       if (thrower->error()) return nothing;
       export_metadata->set(kExportCode, *export_code);
       export_metadata->set(kExportName, *name);
       export_metadata->set(
           kExportArity, Smi::FromInt(static_cast<int>(
                             functions[exp.func_index].sig->parameter_count())));
       export_metadata->set(kExportedFunctionIndex,
                            Smi::FromInt(static_cast<int>(exp.func_index)));
       exports->set(i, *export_metadata);
       if (exp.func_index == start_function_index) {
         startup_fct = export_code;
       }
     }
     ret->set(kExports, *exports);
   }
 
   // Compile startup function, if we haven't already.
   if (start_function_index >= 0) {
     uint32_t index = static_cast<uint32_t>(start_function_index);
     HandleScope scope(isolate);
     if (startup_fct.is_null()) {
       Handle<Code> code = temp_instance_for_compilation.function_code[index];
       DCHECK_EQ(0, functions[index].sig->parameter_count());
-      startup_fct =
-          compiler::CompileJSToWasmWrapper(isolate, &module_env, code, index);
+      startup_fct = compiler::CompileJSToWasmWrapper(
+          isolate, temp_instance_for_compilation.context, &module_env, code,
+          index);
     }
     Handle<FixedArray> metadata =
         factory->NewFixedArray(kWasmExportMetadataTableSize, TENURED);
     metadata->set(kExportCode, *startup_fct);
     metadata->set(kExportArity, Smi::FromInt(0));
     metadata->set(kExportedFunctionIndex, Smi::FromInt(start_function_index));
     ret->set(kStartupFunction, *metadata);
   }
 
   // TODO(wasm): saving the module bytes for debugging is wasteful. We should
@@ skipping 483 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