[wasm] Generated the framework in wasm-module for parallel compilation.

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 "src/isolate-inl.h"
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
@@ skipping 2838 matching lines @@
       buffer.Dispose();
     }
 
     RecordFunctionCompilation(Logger::FUNCTION_TAG, &info, "wasm-to-js", 0,
                               module_name);
   }
   return code;
 }
 
 std::pair<JSGraph*, SourcePositionTable*> BuildGraphForWasmFunction(
-    Zone* zone, wasm::ErrorThrower& thrower, Isolate* isolate,
-    wasm::ModuleEnv*& module_env, const wasm::WasmFunction& function,
+    Zone* zone, wasm::ErrorThrower* thrower, Isolate* isolate,
+    wasm::ModuleEnv*& module_env, const wasm::WasmFunction* function,
     double* decode_ms) {
   base::ElapsedTimer decode_timer;
   if (FLAG_trace_wasm_decode_time) {
     decode_timer.Start();
   }
   // Create a TF graph during decoding.
   Graph* graph = new (zone) Graph(zone);
   CommonOperatorBuilder* common = new (zone) CommonOperatorBuilder(zone);
   MachineOperatorBuilder* machine = new (zone) MachineOperatorBuilder(
       zone, MachineType::PointerRepresentation(),
       InstructionSelector::SupportedMachineOperatorFlags());
   JSGraph* jsgraph =
       new (zone) JSGraph(isolate, graph, common, nullptr, nullptr, machine);
   SourcePositionTable* source_position_table =
       new (zone) SourcePositionTable(graph);
-  WasmGraphBuilder builder(zone, jsgraph, function.sig, source_position_table);
+  WasmGraphBuilder builder(zone, jsgraph, function->sig, source_position_table);
   wasm::FunctionBody body = {
-      module_env, function.sig, module_env->module->module_start,
-      module_env->module->module_start + function.code_start_offset,
-      module_env->module->module_start + function.code_end_offset};
+      module_env, function->sig, module_env->module->module_start,
+      module_env->module->module_start + function->code_start_offset,
+      module_env->module->module_start + function->code_end_offset};
   wasm::TreeResult result =
       wasm::BuildTFGraph(isolate->allocator(), &builder, body);
 
   if (machine->Is32()) {
-    Int64Lowering r(graph, machine, common, zone, function.sig);
+    Int64Lowering r(graph, machine, common, zone, function->sig);
     r.LowerGraph();
   }
 
   if (result.failed()) {
     if (FLAG_trace_wasm_compiler) {
       OFStream os(stdout);
       os << "Compilation failed: " << result << std::endl;
     }
     // Add the function as another context for the exception
     ScopedVector<char> buffer(128);
-    wasm::WasmName name =
-        module_env->module->GetName(function.name_offset, function.name_length);
+    wasm::WasmName name = module_env->module->GetName(function->name_offset,
+                                                      function->name_length);
     SNPrintF(buffer, "Compiling WASM function #%d:%.*s failed:",
-             function.func_index, name.length(), name.start());
-    thrower.Failed(buffer.start(), result);
+             function->func_index, name.length(), name.start());
+    thrower->Failed(buffer.start(), result);
     return std::make_pair(nullptr, nullptr);
   }
-  int index = static_cast<int>(function.func_index);
+  int index = static_cast<int>(function->func_index);
   if (index >= FLAG_trace_wasm_ast_start && index < FLAG_trace_wasm_ast_end) {
     PrintAst(isolate->allocator(), body);
   }
   if (FLAG_trace_wasm_decode_time) {
     *decode_ms = decode_timer.Elapsed().InMillisecondsF();
   }
   return std::make_pair(jsgraph, source_position_table);
 }
 
 // Helper function to compile a single function.
-Handle<Code> CompileWasmFunction(wasm::ErrorThrower& thrower, Isolate* isolate,
+Handle<Code> CompileWasmFunction(wasm::ErrorThrower* thrower, Isolate* isolate,
                                  wasm::ModuleEnv* module_env,
-                                 const wasm::WasmFunction& function) {
+                                 const wasm::WasmFunction* function) {
   HistogramTimerScope wasm_compile_function_time_scope(
       isolate->counters()->wasm_compile_function_time());
   if (FLAG_trace_wasm_compiler) {
     OFStream os(stdout);
     os << "Compiling WASM function "
-       << wasm::WasmFunctionName(&function, module_env) << std::endl;
+       << wasm::WasmFunctionName(function, module_env) << std::endl;
     os << std::endl;
   }
 
   compiler::ZonePool zone_pool(isolate->allocator());
   compiler::ZonePool::Scope graph_zone_scope(&zone_pool);
   double decode_ms = 0;
   std::pair<JSGraph*, SourcePositionTable*> graph_result =
       BuildGraphForWasmFunction(graph_zone_scope.zone(), thrower, isolate,
                                 module_env, function, &decode_ms);
   JSGraph* jsgraph = graph_result.first;
   SourcePositionTable* source_positions = graph_result.second;
 
   if (jsgraph == nullptr) {
     return Handle<Code>::null();
   }
 
   base::ElapsedTimer compile_timer;
   if (FLAG_trace_wasm_decode_time) {
     compile_timer.Start();
   }
   // Run the compiler pipeline to generate machine code.
   CallDescriptor* descriptor = wasm::ModuleEnv::GetWasmCallDescriptor(
-      jsgraph->graph()->zone(), function.sig);
+      jsgraph->graph()->zone(), function->sig);
   if (jsgraph->machine()->Is32()) {
     descriptor = module_env->GetI32WasmCallDescriptor(jsgraph->graph()->zone(),
                                                       descriptor);
   }
   Code::Flags flags = Code::ComputeFlags(Code::WASM_FUNCTION);
   // add flags here if a meaningful name is helpful for debugging.
   bool debugging =
 #if DEBUG
       true;
 #else
       FLAG_print_opt_code || FLAG_trace_turbo || FLAG_trace_turbo_graph;
 #endif
   Vector<const char> func_name = module_env->module->GetNameOrNull(
-      function.name_offset, function.name_length);
+      function->name_offset, function->name_length);
   Vector<char> buffer;
   if (func_name.is_empty()) {
     if (debugging) {
       buffer = Vector<char>::New(128);
-      int chars = SNPrintF(buffer, "WASM_function_#%d", function.func_index);
+      int chars = SNPrintF(buffer, "WASM_function_#%d", function->func_index);
       func_name = Vector<const char>::cast(buffer.SubVector(0, chars));
     } else {
       func_name = ArrayVector("wasm");
     }
   }
   CompilationInfo info(func_name, isolate, jsgraph->graph()->zone(), flags);
   base::SmartPointer<CompilationJob> job(Pipeline::NewWasmCompilationJob(
       &info, jsgraph->graph(), descriptor, source_positions));
   Handle<Code> code = Handle<Code>::null();
   if (job->OptimizeGraph() == CompilationJob::SUCCEEDED &&
       job->GenerateCode() == CompilationJob::SUCCEEDED) {
     code = info.code();
   }
 
   buffer.Dispose();
   if (!code.is_null()) {
-    RecordFunctionCompilation(Logger::FUNCTION_TAG, &info, "WASM_function",
-                              function.func_index,
-                              module_env->module->GetName(
-                                  function.name_offset, function.name_length));
+    RecordFunctionCompilation(
+        Logger::FUNCTION_TAG, &info, "WASM_function", function->func_index,
+        module_env->module->GetName(function->name_offset,
+                                    function->name_length));
   }
 
   if (FLAG_trace_wasm_decode_time) {
     double compile_ms = compile_timer.Elapsed().InMillisecondsF();
     PrintF(
         "wasm-compile ok: %d bytes, %0.3f ms decode, %d nodes, %0.3f ms "
         "compile\n",
-        static_cast<int>(function.code_end_offset - function.code_start_offset),
+        static_cast<int>(function->code_end_offset -
+                         function->code_start_offset),
         decode_ms, static_cast<int>(jsgraph->graph()->NodeCount()), compile_ms);
   }
   // TODO(bradnelson): Improve histogram handling of size_t.
   isolate->counters()->wasm_compile_function_peak_memory_bytes()->AddSample(
       static_cast<int>(jsgraph->graph()->zone()->allocation_size()));
   graph_zone_scope.Destroy();
   return code;
 }
 
+class WasmCompilationUnit {
+ public:
+  WasmCompilationUnit(wasm::ErrorThrower* thrower, Isolate* isolate,
+                      wasm::ModuleEnv* module_env,
+                      const wasm::WasmFunction* function)
+      : thrower_(thrower),
+        isolate_(isolate),
+        module_env_(module_env),
+        function_(function) {}
+
+  void ExecuteCompilation() {
+    if (function_->external) {
+      return;
+    }
+    // TODO(ahaas): The parallelizable parts of the compilation should move from
+    // FinishCompilation to here.
+  }
+
+  Handle<Code> FinishCompilation() {
+    return CompileWasmFunction(thrower_, isolate_, module_env_, function_);
+  }
+
+  wasm::ErrorThrower* thrower_;
+  Isolate* isolate_;
+  wasm::ModuleEnv* module_env_;
+  const wasm::WasmFunction* function_;
+};
+
+WasmCompilationUnit* CreateWasmCompilationUnit(
+    wasm::ErrorThrower* thrower, Isolate* isolate, wasm::ModuleEnv* module_env,
+    const wasm::WasmFunction* function) {
+  return new WasmCompilationUnit(thrower, isolate, module_env, function);
+}
+
+void ExecuteCompilation(WasmCompilationUnit* unit) {
+  unit->ExecuteCompilation();
+}
+
+Handle<Code> FinishCompilation(WasmCompilationUnit* unit) {
+  Handle<Code> result = unit->FinishCompilation();
+  delete unit;
+  return result;
+}
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8