[wasm] Serialization/Deserialization of compiled module

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"
 #include "src/macro-assembler.h"
 #include "src/snapshot/deserializer.h"
+#include "src/snapshot/snapshot.h"
 #include "src/version.h"
 
 namespace v8 {
 namespace internal {
 
 ScriptData* CodeSerializer::Serialize(Isolate* isolate,
                                       Handle<SharedFunctionInfo> info,
                                       Handle<String> source) {
   base::ElapsedTimer timer;
   if (FLAG_profile_deserialization) timer.Start();
   if (FLAG_trace_serializer) {
     PrintF("[Serializing from");
     Object* script = info->script();
     if (script->IsScript()) Script::cast(script)->name()->ShortPrint();
     PrintF("]\n");
   }
 
   // Serialize code object.
-  CodeSerializer cs(isolate, *source);
+  CodeSerializer cs(isolate, SerializedCodeData::SourceHash(source));
   DisallowHeapAllocation no_gc;
-  Object** location = Handle<Object>::cast(info).location();
-  cs.VisitPointer(location);
-  cs.SerializeDeferredObjects();
-  cs.Pad();
-
-  SerializedCodeData data(cs.sink()->data(), &cs);
-  ScriptData* script_data = data.GetScriptData();
+  cs.reference_map()->AddAttachedReference(*source);
+  ScriptData* ret = cs.Serialize(info);
 
   if (FLAG_profile_deserialization) {
     double ms = timer.Elapsed().InMillisecondsF();
-    int length = script_data->length();
+    int length = ret->length();
     PrintF("[Serializing to %d bytes took %0.3f ms]\n", length, ms);
   }
 
-  return script_data;
+  return ret;
+}
+
+ScriptData* CodeSerializer::Serialize(Handle<HeapObject> obj) {
+  DisallowHeapAllocation no_gc;
+
+  VisitPointer(Handle<Object>::cast(obj).location());
+  SerializeDeferredObjects();
+  Pad();
+
+  SerializedCodeData data(sink()->data(), this);
+
+  return data.GetScriptData();
 }
 
 void CodeSerializer::SerializeObject(HeapObject* obj, HowToCode how_to_code,
                                      WhereToPoint where_to_point, int skip) {
   if (SerializeHotObject(obj, how_to_code, where_to_point, skip)) return;
 
   int root_index = root_index_map_.Lookup(obj);
   if (root_index != RootIndexMap::kInvalidRootIndex) {
     PutRoot(root_index, obj, how_to_code, where_to_point, skip);
     return;
@@ skipping 22 matching lines @@
 #undef IC_KIND_CASE
         SerializeCodeStub(code_object, how_to_code, where_to_point);
         return;
       case Code::FUNCTION:
         DCHECK(code_object->has_reloc_info_for_serialization());
         SerializeGeneric(code_object, how_to_code, where_to_point);
         return;
       case Code::WASM_FUNCTION:
       case Code::WASM_TO_JS_FUNCTION:
       case Code::JS_TO_WASM_FUNCTION:
-        UNREACHABLE();
+        SerializeGeneric(code_object, how_to_code, where_to_point);

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

Would it make sense to check for code_object->has_reloc_info_for_serialization()
here as well?

[Yang, 2016/08/05 12:05:44]

Also, assuming that we will use a subclass of CodeSerializer to serialize wasm,
can we check that we only get here if this is called for the subclass?

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

We don't set that flag. Should we? It seems to be user-set, rather than
calculated - not quite sure what value it brings.

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

We don't emit reloc info for external references in general, unless we
explicitly make the macro assembler do it. If you emit external references in
code, but do not emit reloc info for it, serializing/deserializing between
different V8 processes is going to break.
If we emitted reloc info for external references, we set the flag so that we can
check it here.

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

I see - thanks. 

It turns out that has_reloc_code_for_serialization only applies to code->kind()
== Code::FUNCTION. Not sure if that is stale and needs to be extended, but, on
the wasm side, it would be actually expected not to have
RelocInfo::EXTERNAL_REFERENCEs. 

I added DCHECKs in the ObjectSerializer members that deal with external
references, to formalize the relationship you described.

I don't have sufficient information if we need to expand
has_reloc_code_for_serialization()'s accepting of non-FUNCTION Code objects. If
we are ok with expanding that, I'd be happy to also add a DCHECK for wasm that
ensures the flag isn't set.

+        return;
     }
     UNREACHABLE();
   }
 
   // Past this point we should not see any (context-specific) maps anymore.
   CHECK(!obj->IsMap());
   // There should be no references to the global object embedded.
   CHECK(!obj->IsJSGlobalProxy() && !obj->IsJSGlobalObject());
   // There should be no hash table embedded. They would require rehashing.
   CHECK(!obj->IsHashTable());
@@ skipping 48 matching lines @@
   PutAttachedReference(reference, how_to_code, where_to_point);
 }
 
 MaybeHandle<SharedFunctionInfo> CodeSerializer::Deserialize(
     Isolate* isolate, ScriptData* cached_data, Handle<String> source) {
   base::ElapsedTimer timer;
   if (FLAG_profile_deserialization) timer.Start();
 
   HandleScope scope(isolate);
 
-  std::unique_ptr<SerializedCodeData> scd(
-      SerializedCodeData::FromCachedData(isolate, cached_data, *source));
-  if (!scd) {
+  SanityCheckResult sanity_check_result = CHECK_SUCCESS;
+  const SerializedCodeData scd = SerializedCodeData::FromCachedData(
+      isolate, cached_data, SerializedCodeData::SourceHash(source),
+      &sanity_check_result);
+  if (sanity_check_result != CHECK_SUCCESS) {
     if (FLAG_profile_deserialization) PrintF("[Cached code failed check]\n");
     DCHECK(cached_data->rejected());
+    source->GetIsolate()->counters()->code_cache_reject_reason()->AddSample(
+        sanity_check_result);
     return MaybeHandle<SharedFunctionInfo>();
   }
 
-  Deserializer deserializer(scd.get());
+  Deserializer deserializer(&scd);
   deserializer.AddAttachedObject(source);
-  Vector<const uint32_t> code_stub_keys = scd->CodeStubKeys();
+  Vector<const uint32_t> code_stub_keys = scd.CodeStubKeys();
   for (int i = 0; i < code_stub_keys.length(); i++) {
     deserializer.AddAttachedObject(
         CodeStub::GetCode(isolate, code_stub_keys[i]).ToHandleChecked());
   }
 
   // Deserialize.
-  Handle<SharedFunctionInfo> result;
-  if (!deserializer.DeserializeCode(isolate).ToHandle(&result)) {
+  Handle<HeapObject> as_heap_object;
+  if (!deserializer.DeserializeObject(isolate).ToHandle(&as_heap_object)) {
     // Deserializing may fail if the reservations cannot be fulfilled.
     if (FLAG_profile_deserialization) PrintF("[Deserializing failed]\n");
     return MaybeHandle<SharedFunctionInfo>();
   }
 
+  Handle<SharedFunctionInfo> result =
+      Handle<SharedFunctionInfo>::cast(as_heap_object);
   if (FLAG_profile_deserialization) {
     double ms = timer.Elapsed().InMillisecondsF();
     int length = cached_data->length();
     PrintF("[Deserializing from %d bytes took %0.3f ms]\n", length, ms);
   }
   result->set_deserialized(true);
 
   if (isolate->logger()->is_logging_code_events() || isolate->is_profiling()) {
     String* name = isolate->heap()->empty_string();
     if (result->script()->IsScript()) {
@@ skipping 60 matching lines @@
   int payload_offset = kHeaderSize + reservation_size + stub_keys_size;
   int padded_payload_offset = POINTER_SIZE_ALIGN(payload_offset);
   int size = padded_payload_offset + payload->length();
 
   // Allocate backing store and create result data.
   AllocateData(size);
 
   // Set header values.
   SetMagicNumber(cs->isolate());
   SetHeaderValue(kVersionHashOffset, Version::Hash());
-  SetHeaderValue(kSourceHashOffset, SourceHash(cs->source()));
+  SetHeaderValue(kSourceHashOffset, cs->source_hash());
   SetHeaderValue(kCpuFeaturesOffset,
                  static_cast<uint32_t>(CpuFeatures::SupportedFeatures()));
   SetHeaderValue(kFlagHashOffset, FlagList::Hash());
   SetHeaderValue(kNumReservationsOffset, reservations.length());
   SetHeaderValue(kNumCodeStubKeysOffset, num_stub_keys);
   SetHeaderValue(kPayloadLengthOffset, payload->length());
 
   Checksum checksum(payload->ToConstVector());
   SetHeaderValue(kChecksum1Offset, checksum.a());
   SetHeaderValue(kChecksum2Offset, checksum.b());
 
   // Copy reservation chunk sizes.
   CopyBytes(data_ + kHeaderSize, reinterpret_cast<byte*>(reservations.begin()),
             reservation_size);
 
   // Copy code stub keys.
   CopyBytes(data_ + kHeaderSize + reservation_size,
             reinterpret_cast<byte*>(stub_keys->begin()), stub_keys_size);
 
   memset(data_ + payload_offset, 0, padded_payload_offset - payload_offset);
 
   // Copy serialized data.
   CopyBytes(data_ + padded_payload_offset, payload->begin(),
             static_cast<size_t>(payload->length()));
 }
 
-SerializedCodeData::SanityCheckResult SerializedCodeData::SanityCheck(
-    Isolate* isolate, String* source) const {
+SanityCheckResult SerializedCodeData::SanityCheck(
+    Isolate* isolate, uint32_t expected_source_hash) const {
   uint32_t magic_number = GetMagicNumber();
   if (magic_number != ComputeMagicNumber(isolate)) return MAGIC_NUMBER_MISMATCH;
   uint32_t version_hash = GetHeaderValue(kVersionHashOffset);
   uint32_t source_hash = GetHeaderValue(kSourceHashOffset);
   uint32_t cpu_features = GetHeaderValue(kCpuFeaturesOffset);
   uint32_t flags_hash = GetHeaderValue(kFlagHashOffset);
   uint32_t c1 = GetHeaderValue(kChecksum1Offset);
   uint32_t c2 = GetHeaderValue(kChecksum2Offset);
   if (version_hash != Version::Hash()) return VERSION_MISMATCH;
-  if (source_hash != SourceHash(source)) return SOURCE_MISMATCH;
+  if (source_hash != expected_source_hash) return SOURCE_MISMATCH;
   if (cpu_features != static_cast<uint32_t>(CpuFeatures::SupportedFeatures())) {
     return CPU_FEATURES_MISMATCH;
   }
   if (flags_hash != FlagList::Hash()) return FLAGS_MISMATCH;
   if (!Checksum(Payload()).Check(c1, c2)) return CHECKSUM_MISMATCH;
   return CHECK_SUCCESS;
 }
 
-uint32_t SerializedCodeData::SourceHash(String* source) const {
+uint32_t SerializedCodeData::SourceHash(Handle<String> source) {
   return source->length();
 }
 
 // Return ScriptData object and relinquish ownership over it to the caller.
 ScriptData* SerializedCodeData::GetScriptData() {
   DCHECK(owns_data_);
   ScriptData* result = new ScriptData(data_, size_);
   result->AcquireDataOwnership();
   owns_data_ = false;
   data_ = NULL;
@@ skipping 22 matching lines @@
 Vector<const uint32_t> SerializedCodeData::CodeStubKeys() const {
   int reservations_size = GetHeaderValue(kNumReservationsOffset) * kInt32Size;
   const byte* start = data_ + kHeaderSize + reservations_size;
   return Vector<const uint32_t>(reinterpret_cast<const uint32_t*>(start),
                                 GetHeaderValue(kNumCodeStubKeysOffset));
 }
 
 SerializedCodeData::SerializedCodeData(ScriptData* data)
     : SerializedData(const_cast<byte*>(data->data()), data->length()) {}
 
-SerializedCodeData* SerializedCodeData::FromCachedData(Isolate* isolate,
-                                                       ScriptData* cached_data,
-                                                       String* source) {
+const SerializedCodeData SerializedCodeData::FromCachedData(
+    Isolate* isolate, ScriptData* cached_data, uint32_t expected_source_hash,
+    SanityCheckResult* rejection_result) {
   DisallowHeapAllocation no_gc;
-  SerializedCodeData* scd = new SerializedCodeData(cached_data);
-  SanityCheckResult r = scd->SanityCheck(isolate, source);
-  if (r == CHECK_SUCCESS) return scd;
-  cached_data->Reject();
-  source->GetIsolate()->counters()->code_cache_reject_reason()->AddSample(r);
-  delete scd;
-  return NULL;
+  SerializedCodeData scd(cached_data);
+  *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