[wasm] Serialization/Deserialization of compiled module

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/base/atomic-utils.h"
+#include "src/code-stubs.h"
+
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
+#include "src/simulator.h"
+#include "src/snapshot/snapshot.h"
 #include "src/v8.h"
 
-#include "src/simulator.h"
-
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-debug.h"
 #include "src/wasm/wasm-function-name-table.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-result.h"
 
 #include "src/compiler/wasm-compiler.h"
 
+// DELETE THESE 2:
+#include "src/snapshot/code-serializer.h"
+#include "src/snapshot/deserializer.h"

[Yang, 2016/08/05 15:39:28]

Should this be removed?

[Mircea Trofin, 2016/08/06 00:31:39]

Done.

+//
+
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 static const int kPlaceholderMarker = 1000000000;
 
 static const char* wasmSections[] = {
 #define F(enumerator, order, string) string,
     FOR_EACH_WASM_SECTION_TYPE(F)
 #undef F
@@ skipping 1476 matching lines @@
     table->set(static_cast<int>(i), *(*code_table)[index]);
   }
 }
 
 int GetNumberOfFunctions(JSObject* wasm) {
   Object* func_names_obj = wasm->GetInternalField(kWasmFunctionNamesArray);
   // TODO(clemensh): this looks inside an array constructed elsewhere. Refactor.
   return ByteArray::cast(func_names_obj)->get_int(0);
 }
 
+ScriptData* SerializeWasmCompiledModule(Isolate* isolate,
+                                        Handle<FixedArray> compiled_module) {
+  CodeSerializer cs(isolate, 0);
+  cs.reference_map()->AddAttachedReference(*isolate->native_context());

[Yang, 2016/08/05 12:04:17]

Can we put all this into src/snapshot in a new subclass of CodeSerializer? Aside
from CreateCompiledModuleObject, none of this contains anything wasm-specific.

[Mircea Trofin, 2016/08/05 15:01:29]

Knowing we need to attach the native context is specific (but probably not
uniquely) to wasm. 

That's actually the only extra thing that happens here. The rest is usage of a
general-purpose API.

[Yang, 2016/08/05 15:39:28]

Same thing can be said for CodeSerializer::Serialize. Yet the code for it is not
in src/compiler.cc. Putting it into a separate file in src/snapshot would mirror
what we do for CodeSerializer. Attaching the source string is specific to the
CodeSerializer, but belongs to the API of serializing/deserializing an
user-defined script.

I also don't like that we are using CodeSerializer to deal with wasm aside from
its original purpose. We make clear distinctions between StartupSerializer,
PartialSerializer, and CodeSerializer, each with its own purpose. Serialization
logic should not be put outside of src/snapshot.

[Mircea Trofin, 2016/08/06 00:31:39]

Done.

I was a bit concerned that the serializer would end up learning about a very
specific (wasm) area. But I buy the consistency argument - as you pointed out,
at the moment, everything serialization-related lives under snapshot.

+  ScriptData* data = cs.Serialize(compiled_module);
+  return data;
+}
+
+MaybeHandle<FixedArray> DeserializeWasmCompiledModule(Isolate* isolate,
+                                                      ScriptData* data) {
+  SanityCheckResult sanity_check_result = CHECK_SUCCESS;
+  MaybeHandle<FixedArray> nothing;
+  const SerializedCodeData scd = SerializedCodeData::FromCachedData(
+      isolate, data, 0, &sanity_check_result);
+
+  if (sanity_check_result != SanityCheckResult::CHECK_SUCCESS) {
+    return nothing;
+  }
+
+  Deserializer deserializer(&scd, true);
+  deserializer.AddAttachedObject(isolate->native_context());
+
+  Vector<const uint32_t> stub_keys = scd.CodeStubKeys();
+  for (int i = 0; i < stub_keys.length(); ++i) {
+    deserializer.AddAttachedObject(
+        CodeStub::GetCode(isolate, stub_keys[i]).ToHandleChecked());
+  }
+
+  MaybeHandle<HeapObject> obj = deserializer.DeserializeObject(isolate);
+  if (obj.is_null() || !obj.ToHandleChecked()->IsFixedArray()) return nothing;
+  return Handle<FixedArray>::cast(obj.ToHandleChecked());
+}
+
+Handle<JSObject> CreateCompiledModuleObject(
+    Isolate* isolate, Handle<FixedArray> compiled_module) {
+  Handle<JSFunction> module_cons(
+      isolate->native_context()->wasm_module_constructor());
+  Handle<JSObject> module_obj = isolate->factory()->NewJSObject(module_cons);
+  module_obj->SetInternalField(0, *compiled_module);
+  Handle<Symbol> module_sym(isolate->native_context()->wasm_module_sym());
+  Object::SetProperty(module_obj, module_sym, module_obj, STRICT).Check();
+  return module_obj;
+}
+
 namespace testing {
 
 int32_t CompileAndRunWasmModule(Isolate* isolate, const byte* module_start,
                                 const byte* module_end, bool asm_js) {
   HandleScope scope(isolate);
   Zone zone(isolate->allocator());
   ErrorThrower thrower(isolate, "CompileAndRunWasmModule");
 
   // Decode the module, but don't verify function bodies, since we'll
   // be compiling them anyway.
@@ skipping 56 matching lines @@
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8