[wasm] Generated the framework in wasm-module for parallel 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 "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/v8.h"
 
 #include "src/simulator.h"
 
@@ skipping 473 matching lines @@
     }
   }
 
   //-------------------------------------------------------------------------
   // Compile all functions in the module.
   //-------------------------------------------------------------------------
   {
     isolate->counters()->wasm_functions_per_module()->AddSample(
         static_cast<int>(functions.size()));
 
+    std::vector<compiler::WasmCompilationUnit*> compilation_units(
+        functions.size());
+    if (FLAG_wasm_parallel_compilation) {
+      // Create a placeholder code object for all functions.
+      // TODO(ahaas): Maybe we could skip this for external functions.
+      for (uint32_t i = 0; i < functions.size(); i++) {
+        linker.GetFunctionCode(i);
+      }
+
+      for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size();
+           i++) {
+        if (!functions[i].external) {
+          compilation_units[i] = compiler::CreateWasmCompilationUnit(
+              &thrower, isolate, &module_env, &functions[i]);
+        }
+      }
+
+      for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size();
+           i++) {
+        if (!functions[i].external) {
+          compiler::ExecuteCompilation(compilation_units[i]);
+        }
+      }
+    }
+
     // First pass: compile each function and initialize the code table.
-    index = FLAG_skip_compiling_wasm_funcs;
-    while (index < functions.size()) {
-      const WasmFunction& func = functions[index];
+    for (uint32_t i = FLAG_skip_compiling_wasm_funcs; i < functions.size();
+         i++) {
+      const WasmFunction& func = functions[i];
       if (thrower.error()) break;
-      DCHECK_EQ(index, func.func_index);
+      DCHECK_EQ(i, func.func_index);
 
       WasmName str = GetName(func.name_offset, func.name_length);
       WasmName str_null = {nullptr, 0};
       Handle<String> name = factory->InternalizeUtf8String(str);
       Handle<Code> code = Handle<Code>::null();
       Handle<JSFunction> function = Handle<JSFunction>::null();
       if (func.external) {
         // Lookup external function in FFI object.
         MaybeHandle<JSFunction> function =
-            LookupFunction(thrower, factory, ffi, index, str, str_null);
+            LookupFunction(thrower, factory, ffi, i, str, str_null);
         if (function.is_null()) return MaybeHandle<JSObject>();
         code = compiler::CompileWasmToJSWrapper(isolate, &module_env,
                                                 function.ToHandleChecked(),
                                                 func.sig, str, str_null);
       } else {
-        // Compile the function.
-        code =
-            compiler::CompileWasmFunction(thrower, isolate, &module_env, func);
+        if (FLAG_wasm_parallel_compilation) {
+          code = compiler::FinishCompilation(compilation_units[i]);
+        } else {
+          // Compile the function.
+          code = compiler::CompileWasmFunction(&thrower, isolate, &module_env,
+                                               &func);
+        }
         if (code.is_null()) {
-          thrower.Error("Compilation of #%d:%.*s failed.", index, str.length(),
+          thrower.Error("Compilation of #%d:%.*s failed.", i, str.length(),
                         str.start());
           return MaybeHandle<JSObject>();
         }
         if (func.exported) {
           function = compiler::CompileJSToWasmWrapper(
-              isolate, &module_env, name, code, instance.js_object, index);
+              isolate, &module_env, name, code, instance.js_object, i);
         }
       }
       if (!code.is_null()) {
         // Install the code into the linker table.
-        linker.Finish(index, code);
-        code_table->set(index, *code);
+        linker.Finish(i, code);
+        code_table->set(i, *code);
       }
       if (func.exported) {
         // Exported functions are installed as read-only properties on the
         // module.
         JSObject::AddProperty(instance.js_object, name, function, READ_ONLY);
       }
-      index++;
     }
 
     // Second pass: patch all direct call sites.
     linker.Link(instance.function_table, this->function_table);
     instance.js_object->SetInternalField(kWasmModuleFunctionTable,
                                          Smi::FromInt(0));
 
     //-------------------------------------------------------------------------
     // Create and populate the exports object.
     //-------------------------------------------------------------------------
     if (export_table.size() > 0 || mem_export) {
-      index = 0;
       // Create the "exports" object.
       Handle<JSFunction> object_function = Handle<JSFunction>(
           isolate->native_context()->object_function(), isolate);
       Handle<JSObject> exports_object =
           factory->NewJSObject(object_function, TENURED);
       Handle<String> exports_name = factory->InternalizeUtf8String("exports");
       JSObject::AddProperty(instance.js_object, exports_name, exports_object,
                             READ_ONLY);
 
       // Compile wrappers and add them to the exports object.
@@ skipping 114 matching lines @@
 
   // Compile all functions.
   Handle<Code> main_code = Handle<Code>::null();  // record last code.
   uint32_t index = 0;
   int main_index = 0;
   for (const WasmFunction& func : module->functions) {
     DCHECK_EQ(index, func.func_index);
     if (!func.external) {
       // Compile the function and install it in the code table.
       Handle<Code> code =
-          compiler::CompileWasmFunction(thrower, isolate, &module_env, func);
+          compiler::CompileWasmFunction(&thrower, isolate, &module_env, &func);
       if (!code.is_null()) {
         if (func.exported) {
           main_code = code;
           main_index = index;
         }
         linker.Finish(index, code);
       }
       if (thrower.error()) return -1;
     }
     index++;
@@ skipping 28 matching lines @@
   }
   if (result->IsHeapNumber()) {
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8