[wasm] No need for ModuleEnv when building import wrappers.

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 "src/base/atomic-utils.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/v8.h"
 
@@ skipping 468 matching lines @@
     code_size += code->body_size();
     reloc_size += code->relocation_info()->length();
   }
 
   inline void Report() {
     PrintF("Total generated wasm code: %zu bytes\n", code_size);
     PrintF("Total generated wasm reloc: %zu bytes\n", reloc_size);
   }
 };
 
-bool CompileWrappersToImportedFunctions(Isolate* isolate,
-                                        const WasmModule* module,
-                                        const Handle<JSReceiver> ffi,
-                                        WasmModuleInstance* instance,
-                                        ErrorThrower* thrower, Factory* factory,
-                                        ModuleEnv* module_env) {
+bool CompileWrappersToImportedFunctions(
+    Isolate* isolate, const WasmModule* module, const Handle<JSReceiver> ffi,
+    WasmModuleInstance* instance, ErrorThrower* thrower, Factory* factory) {
   if (module->import_table.size() > 0) {
     instance->import_code.reserve(module->import_table.size());
     for (uint32_t index = 0; index < module->import_table.size(); ++index) {
       const WasmImport& import = module->import_table[index];
       WasmName module_name = module->GetNameOrNull(import.module_name_offset,
                                                    import.module_name_length);
       WasmName function_name = module->GetNameOrNull(
           import.function_name_offset, import.function_name_length);
       MaybeHandle<JSFunction> function = LookupFunction(
           *thrower, factory, ffi, index, module_name, function_name);
       if (function.is_null()) return false;
 
       Handle<Code> code = compiler::CompileWasmToJSWrapper(
-          isolate, module_env, function.ToHandleChecked(), import.sig,
-          module_name, function_name);
+          isolate, function.ToHandleChecked(), import.sig, module_name,
+          function_name);
       instance->import_code[index] = code;
     }
   }
   return true;
 }
 
 void InitializeParallelCompilation(
     Isolate* isolate, const std::vector<WasmFunction>& functions,
     std::vector<compiler::WasmCompilationUnit*>& compilation_units,
     ModuleEnv& module_env, ErrorThrower& thrower) {
@@ skipping 310 matching lines @@
 
   ModuleEnv module_env;
   module_env.module = this;
   module_env.instance = &instance;
   module_env.origin = origin;
 
   //-------------------------------------------------------------------------
   // Compile wrappers to imported functions.
   //-------------------------------------------------------------------------
   if (!CompileWrappersToImportedFunctions(isolate, this, ffi, &instance,
-                                          &thrower, factory, &module_env)) {
+                                          &thrower, factory)) {
     return MaybeHandle<JSObject>();
   }
 
   // If FLAG_print_wasm_code_size is set, this aggregates the sum of all code
   // objects created for this module.
   // TODO(titzer): switch this to TRACE_EVENT
   CodeStats code_stats;
   if (FLAG_print_wasm_code_size) {
     for (Handle<Code> c : instance.function_code) code_stats.Record(*c);
     for (Handle<Code> c : instance.import_code) code_stats.Record(*c);
@@ skipping 267 matching lines @@
   Object* info = wasm->GetInternalField(kWasmDebugInfo);
   if (!info->IsUndefined(wasm->GetIsolate())) return WasmDebugInfo::cast(info);
   Handle<WasmDebugInfo> new_info = WasmDebugInfo::New(handle(wasm));
   wasm->SetInternalField(kWasmDebugInfo, *new_info);
   return *new_info;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8