[wasm] Prepare WasmCompilationUnit for lazy compilation

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/assembler-inl.h"
 #include "src/base/adapters.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ skipping 244 matching lines @@
   void InitializeParallelCompilation(const std::vector<WasmFunction>& functions,
                                      ModuleBytesEnv& module_env,
                                      ErrorThrower* thrower) {
     uint32_t start = module_env.module_env.module->num_imported_functions +
                      FLAG_skip_compiling_wasm_funcs;
     uint32_t num_funcs = static_cast<uint32_t>(functions.size());
     uint32_t funcs_to_compile = start > num_funcs ? 0 : num_funcs - start;
     compilation_units_.reserve(funcs_to_compile);
     for (uint32_t i = start; i < num_funcs; ++i) {
       const WasmFunction* func = &functions[i];
-      compilation_units_.push_back(new compiler::WasmCompilationUnit(
-          thrower, isolate_, &module_env, func, i));
+      compilation_units_.push_back(
+          new compiler::WasmCompilationUnit(isolate_, &module_env, func));
     }
   }
 
   uint32_t* StartCompilationTasks() {
     const size_t num_tasks =
         Min(static_cast<size_t>(FLAG_wasm_num_compilation_tasks),
             V8::GetCurrentPlatform()->NumberOfAvailableBackgroundThreads());
     uint32_t* task_ids = new uint32_t[num_tasks];
     for (size_t i = 0; i < num_tasks; ++i) {
       CompilationTask* task = new CompilationTask(this);
@@ skipping 12 matching lines @@
       // If the task has not started yet, then we abort it. Otherwise we wait
       // for
       // it to finish.
       if (isolate_->cancelable_task_manager()->TryAbort(task_ids[i]) !=
           CancelableTaskManager::kTaskAborted) {
         module_->pending_tasks.get()->Wait();
       }
     }
   }
 
-  void FinishCompilationUnits(std::vector<Handle<Code>>& results) {
+  void FinishCompilationUnits(std::vector<Handle<Code>>& results,
+                              ErrorThrower* thrower) {
     while (true) {
       compiler::WasmCompilationUnit* unit = nullptr;
       {
         base::LockGuard<base::Mutex> guard(&result_mutex_);
         if (executed_units_.empty()) {
           break;
         }
         unit = executed_units_.front();
         executed_units_.pop();
       }
-      int j = unit->index();
-      results[j] = unit->FinishCompilation();
+      int j = unit->func_index();
+      results[j] = unit->FinishCompilation(thrower);
       delete unit;
     }
   }
 
   void CompileInParallel(ModuleBytesEnv* module_env,
                          std::vector<Handle<Code>>& results,
                          ErrorThrower* thrower) {
     const WasmModule* module = module_env->module_env.module;
     // Data structures for the parallel compilation.
 
@@ skipping 31 matching lines @@
 
     // 3.a) The background threads and the main thread pick one compilation
     //      unit at a time and execute the parallel phase of the compilation
     //      unit. After finishing the execution of the parallel phase, the
     //      result is enqueued in {executed_units}.
     while (FetchAndExecuteCompilationUnit()) {
       // 3.b) If {executed_units} contains a compilation unit, the main thread
       //      dequeues it and finishes the compilation unit. Compilation units
       //      are finished concurrently to the background threads to save
       //      memory.
-      FinishCompilationUnits(results);
+      FinishCompilationUnits(results, thrower);
     }
     // 4) After the parallel phase of all compilation units has started, the
     //    main thread waits for all {CompilationTask} instances to finish.
     WaitForCompilationTasks(task_ids.get());
     // Finish the compilation of the remaining compilation units.
-    FinishCompilationUnits(results);
+    FinishCompilationUnits(results, thrower);
   }
 
   void CompileSequentially(ModuleBytesEnv* module_env,
                            std::vector<Handle<Code>>& results,
                            ErrorThrower* thrower) {
     DCHECK(!thrower->error());
 
     const WasmModule* module = module_env->module_env.module;
     for (uint32_t i = FLAG_skip_compiling_wasm_funcs;
          i < module->functions.size(); ++i) {
@@ skipping 2336 matching lines @@
   Handle<String> module_property_name =
       isolate->factory()->InternalizeUtf8String("module");
   Handle<String> instance_property_name =
       isolate->factory()->InternalizeUtf8String("instance");
   JSObject::AddProperty(ret, module_property_name, module, NONE);
   JSObject::AddProperty(ret, instance_property_name,
                         instance_object.ToHandleChecked(), NONE);
 
   ResolvePromise(isolate, promise, ret);
 }