[wasm] Avoid double-serializing the wire bytes

src/snapshot/code-serializer.cc

 // Copyright 2016 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/snapshot/code-serializer.h"
 
 #include <memory>
 
 #include "src/code-stubs.h"
 #include "src/log.h"
@@ skipping 205 matching lines @@
   }
   return scope.CloseAndEscape(result);
 }
 
 std::unique_ptr<ScriptData> WasmCompiledModuleSerializer::SerializeWasmModule(
     Isolate* isolate, Handle<FixedArray> input) {
   Handle<wasm::WasmCompiledModule> compiled_module =
       Handle<wasm::WasmCompiledModule>::cast(input);
   WasmCompiledModuleSerializer wasm_cs(isolate, 0);
   wasm_cs.reference_map()->AddAttachedReference(*isolate->native_context());
+  Handle<SeqOneByteString> wire_bytes = compiled_module->module_bytes();

[Yang, 2016/10/20 06:46:17]

Another way to do this is to use attached references. You would register this
string as attached reference so that the serializer recognizes this object. The
deserializer then restores it. This is what we do for the source string in
CodeSerializer.

This way, if there are other references to wire bytes in the object graph, the
serializer would find them. Which may not be the case now, but maybe sometime in
the future?

[Mircea Trofin, 2016/10/20 07:22:30]

Oh... yes. Yes, makes sense :) Thanks!

+  compiled_module->reset_module_bytes();
   ScriptData* data = wasm_cs.Serialize(compiled_module);
+  compiled_module->set_module_bytes(wire_bytes);
   return std::unique_ptr<ScriptData>(data);
 }
 
 MaybeHandle<FixedArray> WasmCompiledModuleSerializer::DeserializeWasmModule(
-    Isolate* isolate, ScriptData* data) {
+    Isolate* isolate, ScriptData* data, Vector<const byte> wire_bytes) {
   SerializedCodeData::SanityCheckResult sanity_check_result =
       SerializedCodeData::CHECK_SUCCESS;
   MaybeHandle<FixedArray> nothing;
   const SerializedCodeData scd = SerializedCodeData::FromCachedData(
       isolate, data, 0, &sanity_check_result);
 
   if (sanity_check_result != SerializedCodeData::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;
-  Handle<FixedArray> compiled_module =
-      Handle<FixedArray>::cast(obj.ToHandleChecked());
+  Handle<wasm::WasmCompiledModule> compiled_module =
+      Handle<wasm::WasmCompiledModule>::cast(obj.ToHandleChecked());
+  MaybeHandle<String> maybe_wire_bytes_as_string =
+      isolate->factory()->NewStringFromOneByte(wire_bytes, TENURED);
+  Handle<String> wire_bytes_as_string;
+  if (!maybe_wire_bytes_as_string.ToHandle(&wire_bytes_as_string))
+    return nothing;
+
+  compiled_module->set_module_bytes(
+      handle(SeqOneByteString::cast(*wire_bytes_as_string)));
   wasm::WasmCompiledModule::RecreateModuleWrapper(isolate, compiled_module);
   return compiled_module;
 }
 
 class Checksum {
  public:
   explicit Checksum(Vector<const byte> payload) {
 #ifdef MEMORY_SANITIZER
     // Computing the checksum includes padding bytes for objects like strings.
     // Mark every object as initialized in the code serializer.
@@ skipping 151 matching lines @@
   *rejection_result = scd.SanityCheck(isolate, expected_source_hash);
   if (*rejection_result != CHECK_SUCCESS) {
     cached_data->Reject();
     return SerializedCodeData(nullptr, 0);
   }
   return scd;
 }
 
 }  // namespace internal
 }  // namespace v8