[wasm] Split the compilation and instantiation API into sync and async methods.

test/cctest/wasm/test-run-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 <stdlib.h>
 #include <string.h>
 
 #include "src/objects-inl.h"
 #include "src/snapshot/code-serializer.h"
 #include "src/version.h"
@@ skipping 253 matching lines @@
     {
       DisallowHeapAllocation assume_no_gc;
       Handle<WasmCompiledModule> compiled_part(
           WasmCompiledModule::cast(module_object->GetInternalField(0)),
           current_isolate());
       CHECK_EQ(memcmp(compiled_part->module_bytes()->GetCharsAddress(),
                       wire_bytes().first, wire_bytes().second),
                0);
     }
     Handle<JSObject> instance =
-        WasmModule::Instantiate(current_isolate(), &thrower, module_object,
-                                Handle<JSReceiver>::null(),
-                                Handle<JSArrayBuffer>::null())
+        SyncInstantiate(current_isolate(), &thrower, module_object,
+                        Handle<JSReceiver>::null(),
+                        MaybeHandle<JSArrayBuffer>())
             .ToHandleChecked();
     Handle<Object> params[1] = {
         Handle<Object>(Smi::FromInt(41), current_isolate())};
     int32_t result = testing::CallWasmFunctionForTesting(
         current_isolate(), instance, &thrower, kFunctionName, 1, params,
         ModuleOrigin::kWasmOrigin);
     CHECK(result == 42);
   }
 
   Isolate* current_isolate() {
@@ skipping 24 matching lines @@
     WasmSerializationTest::BuildWireBytes(zone(), &buffer);
 
     Isolate* serialization_isolate = CcTest::InitIsolateOnce();
     ErrorThrower thrower(serialization_isolate, "");
     uint8_t* bytes = nullptr;
     size_t bytes_size = 0;
     {
       HandleScope scope(serialization_isolate);
       testing::SetupIsolateForWasmModule(serialization_isolate);
 
-      ModuleResult decoding_result =
-          DecodeWasmModule(serialization_isolate, buffer.begin(), buffer.end(),
-                           false, kWasmOrigin);
-      CHECK(!decoding_result.failed());
+      MaybeHandle<WasmModuleObject> module_object =
+          SyncCompile(serialization_isolate, &thrower,
+                      ModuleWireBytes(buffer.begin(), buffer.end()));
 
-      Handle<WasmModuleWrapper> module_wrapper = WasmModuleWrapper::New(
-          serialization_isolate, const_cast<WasmModule*>(decoding_result.val));
-
-      MaybeHandle<WasmCompiledModule> compiled_module =
-          decoding_result.val->CompileFunctions(
-              serialization_isolate, module_wrapper, &thrower,
-              ModuleWireBytes(buffer.begin(), buffer.end()),
-              Handle<Script>::null(), Vector<const byte>::empty());
+      MaybeHandle<WasmCompiledModule> compiled_module(
+          module_object.ToHandleChecked()->compiled_module(),
+          serialization_isolate);
       CHECK(!compiled_module.is_null());
       Handle<JSObject> module_obj = WasmModuleObject::New(
           serialization_isolate, compiled_module.ToHandleChecked());
       v8::Local<v8::Object> v8_module_obj = v8::Utils::ToLocal(module_obj);
       CHECK(v8_module_obj->IsWebAssemblyCompiledModule());
 
       v8::Local<v8::WasmCompiledModule> v8_compiled_module =
           v8_module_obj.As<v8::WasmCompiledModule>();
       v8::Local<v8::String> uncompiled_bytes =
           v8_compiled_module->GetWasmWireBytes();
@@ skipping 86 matching lines @@
   v8::internal::AccountingAllocator allocator;
   Zone zone(&allocator, ZONE_NAME);
   ZoneBuffer buffer(&zone);
   WasmSerializationTest::BuildWireBytes(&zone, &buffer);
   Isolate* isolate = CcTest::InitIsolateOnce();
   HandleScope scope(isolate);
   testing::SetupIsolateForWasmModule(isolate);
   CcTest::isolate()->SetAllowCodeGenerationFromStringsCallback(False);
 
   ErrorThrower thrower(isolate, "block codegen");
-  MaybeHandle<WasmModuleObject> ret = wasm::CreateModuleObjectFromBytes(
-      isolate, buffer.begin(), buffer.end(), &thrower,
-      wasm::ModuleOrigin::kWasmOrigin, Handle<v8::internal::Script>::null(),
-      Vector<const byte>::empty());
+  MaybeHandle<WasmModuleObject> ret = wasm::SyncCompile(
+      isolate, &thrower, ModuleWireBytes(buffer.begin(), buffer.end()));
   CcTest::isolate()->SetAllowCodeGenerationFromStringsCallback(nullptr);
   CHECK(ret.is_null());
   CHECK(thrower.error());
 }
 
 TEST(BlockWasmCodeGenAtDeserialization) {
   WasmSerializationTest test;
   {
     HandleScope scope(test.current_isolate());
     test.current_isolate_v8()->SetAllowCodeGenerationFromStringsCallback(False);
@@ skipping 502 matching lines @@
     };
 
     testing::CompileInstantiateWasmModuleForTesting(isolate, &thrower, data,
                                                     data + arraysize(data),
                                                     ModuleOrigin::kWasmOrigin);
     // It should not be possible to instantiate this module.
     CHECK(thrower.error());
   }
   Cleanup();
 }