[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());
+  wasm_cs.reference_map()->AddAttachedReference(
+      *compiled_module->module_bytes());
   ScriptData* data = wasm_cs.Serialize(compiled_module);
   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());
 
+  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;
+  }
+  deserializer.AddAttachedObject(
+      handle(SeqOneByteString::cast(*wire_bytes_as_string)));
+
   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());
+
   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