[wasm] Move WasmCompilationUnit to .h file.

Removed wrapper functions.

BUG=

Review-Url: https://codereview.chromium.org/1994963002
Cr-Commit-Position: refs/heads/master@{#36372}

src/compiler/wasm-compiler.h

@@ -7,6 +7,7 @@
 
 // Clients of this interface shouldn't depend on lots of compiler internals.
 // Do not include anything from src/compiler here!
+#include "src/compiler.h"
 #include "src/wasm/wasm-opcodes.h"
 #include "src/zone.h"
 
@@ -20,7 +21,6 @@ class JSGraph;
 class Graph;
 class Operator;
 class SourcePositionTable;
-class WasmCompilationUnit;
 }
 
 namespace wasm {
@@ -35,10 +35,41 @@ typedef compiler::JSGraph TFGraph;
 }
 
 namespace compiler {
-// Compiles a single function, producing a code object.
-Handle<Code> CompileWasmFunction(wasm::ErrorThrower* thrower, Isolate* isolate,
-                                 wasm::ModuleEnv* module_env,
-                                 const wasm::WasmFunction* function);
+class WasmCompilationUnit final {
+ public:
+  WasmCompilationUnit(wasm::ErrorThrower* thrower, Isolate* isolate,
+                      wasm::ModuleEnv* module_env,
+                      const wasm::WasmFunction* function, uint32_t index);
+
+  Zone* graph_zone() { return graph_zone_.get(); }
+  int index() const { return index_; }
+
+  void ExecuteCompilation();
+  Handle<Code> FinishCompilation();
+
+  static Handle<Code> CompileWasmFunction(wasm::ErrorThrower* thrower,
+                                          Isolate* isolate,
+                                          wasm::ModuleEnv* module_env,
+                                          const wasm::WasmFunction* function) {
+    WasmCompilationUnit unit(thrower, isolate, module_env, function, 0);
+    unit.ExecuteCompilation();
+    return unit.FinishCompilation();
+  }
+
+ private:
+  wasm::ErrorThrower* thrower_;
+  Isolate* isolate_;
+  wasm::ModuleEnv* module_env_;
+  const wasm::WasmFunction* function_;
+  // The graph zone is deallocated at the end of ExecuteCompilation.
+  base::SmartPointer<Zone> graph_zone_;
+  JSGraph* jsgraph_;
+  Zone compilation_zone_;
+  CompilationInfo info_;
+  base::SmartPointer<CompilationJob> job_;
+  uint32_t index_;
+  bool ok_;
+};
 
 // Wraps a JS function, producing a code object that can be called from WASM.
 Handle<Code> CompileWasmToJSWrapper(Isolate* isolate, wasm::ModuleEnv* module,
@@ -53,16 +84,6 @@ Handle<JSFunction> CompileJSToWasmWrapper(
     Isolate* isolate, wasm::ModuleEnv* module, Handle<String> name,
     Handle<Code> wasm_code, Handle<JSObject> module_object, uint32_t index);
 
-WasmCompilationUnit* CreateWasmCompilationUnit(
-    wasm::ErrorThrower* thrower, Isolate* isolate, wasm::ModuleEnv* module_env,
-    const wasm::WasmFunction* function, uint32_t index);
-
-void ExecuteCompilation(WasmCompilationUnit* unit);
-
-Handle<Code> FinishCompilation(WasmCompilationUnit* unit);
-
-uint32_t GetIndexOfWasmCompilationUnit(WasmCompilationUnit* unit);
-
 // Abstracts details of building TurboFan graph nodes for WASM to separate
 // the WASM decoder from the internal details of TurboFan.
 class WasmTrapHelper;

src/wasm/wasm-module.cc

@@ -411,7 +411,7 @@ bool FetchAndExecuteCompilationUnit(
 
   compiler::WasmCompilationUnit* unit = compilation_units->at(index);
   if (unit != nullptr) {
-    compiler::ExecuteCompilation(unit);
+    unit->ExecuteCompilation();
     {
       base::LockGuard<base::Mutex> guard(result_mutex);
       executed_units->push(unit);
@@ -498,7 +498,7 @@ void InitializeParallelCompilation(
   }
 
   for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size(); i++) {
-    compilation_units[i] = compiler::CreateWasmCompilationUnit(
+    compilation_units[i] = new compiler::WasmCompilationUnit(
         &thrower, isolate, &module_env, &functions[i], i);
   }
 }
@@ -553,8 +553,9 @@ void FinishCompilationUnits(
       unit = executed_units.front();
       executed_units.pop();
     }
-    int j = compiler::GetIndexOfWasmCompilationUnit(unit);
-    results[j] = compiler::FinishCompilation(unit);
+    int j = unit->index();
+    results[j] = unit->FinishCompilation();
+    delete unit;
   }
 }
 
@@ -580,8 +581,8 @@ bool FinishCompilation(Isolate* isolate, WasmModule* module,
       code = results[i];
     } else {
       // Compile the function.
-      code =
-          compiler::CompileWasmFunction(&thrower, isolate, &module_env, &func);
+      code = compiler::WasmCompilationUnit::CompileWasmFunction(
+          &thrower, isolate, &module_env, &func);
     }
     if (code.is_null()) {
       thrower.Error("Compilation of #%d:%.*s failed.", i, str.length(),
@@ -772,7 +773,7 @@ MaybeHandle<JSObject> WasmModule::Instantiate(Isolate* isolate,
     if (!FinishCompilation(isolate, this, ffi, results, instance, code_table,
                            thrower, factory, module_env, total_code_size,
                            desc)) {
-      return MaybeHandle<JSObject>();
+      instance.js_object = Handle<JSObject>::null();
     }
 
     // Patch all direct call sites.
@@ -930,8 +931,8 @@ int32_t CompileAndRunWasmModule(Isolate* isolate, WasmModule* module) {
   for (const WasmFunction& func : module->functions) {
     DCHECK_EQ(index, func.func_index);
     // Compile the function and install it in the code table.
-    Handle<Code> code =
-        compiler::CompileWasmFunction(&thrower, isolate, &module_env, &func);
+    Handle<Code> code = compiler::WasmCompilationUnit::CompileWasmFunction(
+        &thrower, isolate, &module_env, &func);
     if (!code.is_null()) {
       if (func.exported) {
         main_code = code;