Support structured clone of compiled WebAssembly modules.

src/value-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/value-serializer.h"
 
 #include <type_traits>
 
 #include "src/base/logging.h"
 #include "src/conversions.h"
 #include "src/factory.h"
+#include "src/flags.h"
 #include "src/handles-inl.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
 #include "src/objects.h"
+#include "src/snapshot/code-serializer.h"
 #include "src/transitions.h"
+#include "src/wasm/wasm-module.h"
+#include "src/wasm/wasm-result.h"
 
 namespace v8 {
 namespace internal {
 
 static const uint32_t kLatestVersion = 9;
 static const int kPretenureThreshold = 100 * KB;
 
 template <typename T>
 static size_t BytesNeededForVarint(T value) {
   static_assert(std::is_integral<T>::value && std::is_unsigned<T>::value,
@@ skipping 73 matching lines @@
   // View into an array buffer.
   // subtag:ArrayBufferViewTag, byteOffset:uint32_t, byteLength:uint32_t
   // For typed arrays, byteOffset and byteLength must be divisible by the size
   // of the element.
   // Note: kArrayBufferView is special, and should have an ArrayBuffer (or an
   // ObjectReference to one) serialized just before it. This is a quirk arising
   // from the previous stack-based implementation.
   kArrayBufferView = 'V',
   // Shared array buffer (transferred). transferID:uint32_t
   kSharedArrayBufferTransfer = 'u',
+  // Compiled WebAssembly module. encodingType:(one-byte tag).
+  // If encodingType == 'y' (raw bytes):
+  //  wasmWireByteLength:uint32_t, then raw data
+  //  compiledDataLength:uint32_t, then raw data
+  kWasmModule = 'W',
 };
 
 namespace {
 
 enum class ArrayBufferViewTag : uint8_t {
   kInt8Array = 'b',
   kUint8Array = 'B',
   kUint8ClampedArray = 'C',
   kInt16Array = 'w',
   kUint16Array = 'W',
   kInt32Array = 'd',
   kUint32Array = 'D',
   kFloat32Array = 'f',
   kFloat64Array = 'F',
   kDataView = '?',
 };
 
+enum class WasmEncodingTag : uint8_t {
+  kRawBytes = 'y',
+};
+
 }  // namespace
 
 ValueSerializer::ValueSerializer(Isolate* isolate,
                                  v8::ValueSerializer::Delegate* delegate)
     : isolate_(isolate),
       delegate_(delegate),
       zone_(isolate->allocator(), ZONE_NAME),
       id_map_(isolate->heap(), &zone_),
       array_buffer_transfer_map_(isolate->heap(), &zone_) {}
 
@@ skipping 221 matching lines @@
   // If we are at the end of the stack, abort. This function may recurse.
   STACK_CHECK(isolate_, Nothing<bool>());
 
   HandleScope scope(isolate_);
   switch (instance_type) {
     case JS_ARRAY_TYPE:
       return WriteJSArray(Handle<JSArray>::cast(receiver));
     case JS_OBJECT_TYPE:
     case JS_API_OBJECT_TYPE: {
       Handle<JSObject> js_object = Handle<JSObject>::cast(receiver);
-      return js_object->GetInternalFieldCount() ? WriteHostObject(js_object)
-                                                : WriteJSObject(js_object);
+      Map* map = js_object->map();
+      if (FLAG_expose_wasm &&
+          map->GetConstructor() ==
+              isolate_->native_context()->wasm_module_constructor()) {
+        return WriteWasmModule(js_object);
+      } else if (JSObject::GetInternalFieldCount(map)) {
+        return WriteHostObject(js_object);
+      } else {
+        return WriteJSObject(js_object);
+      }
     }
     case JS_SPECIAL_API_OBJECT_TYPE:
       return WriteHostObject(Handle<JSObject>::cast(receiver));
     case JS_DATE_TYPE:
       WriteJSDate(JSDate::cast(*receiver));
       return Just(true);
     case JS_VALUE_TYPE:
       return WriteJSValue(Handle<JSValue>::cast(receiver));
     case JS_REGEXP_TYPE:
       WriteJSRegExp(JSRegExp::cast(*receiver));
@@ skipping 330 matching lines @@
   } else {
     DCHECK(view->IsJSDataView());
     tag = ArrayBufferViewTag::kDataView;
   }
   WriteVarint(static_cast<uint8_t>(tag));
   WriteVarint(NumberToUint32(view->byte_offset()));
   WriteVarint(NumberToUint32(view->byte_length()));
   return Just(true);
 }
 
+Maybe<bool> ValueSerializer::WriteWasmModule(Handle<JSObject> object) {
+  Handle<wasm::WasmCompiledModule> compiled_part(
+      wasm::WasmCompiledModule::cast(object->GetInternalField(0)), isolate_);
+  WasmEncodingTag encoding_tag = WasmEncodingTag::kRawBytes;
+  WriteTag(SerializationTag::kWasmModule);
+  WriteRawBytes(&encoding_tag, sizeof(encoding_tag));
+
+  Handle<String> wire_bytes = compiled_part->module_bytes();
+  int wire_bytes_length = wire_bytes->length();
+  WriteVarint<uint32_t>(wire_bytes_length);
+  uint8_t* destination = ReserveRawBytes(wire_bytes_length);
+  String::WriteToFlat(*wire_bytes, destination, 0, wire_bytes_length);
+
+  std::unique_ptr<ScriptData> script_data =
+      WasmCompiledModuleSerializer::SerializeWasmModule(isolate_,
+                                                        compiled_part);
+  int script_data_length = script_data->length();
+  WriteVarint<uint32_t>(script_data_length);
+  WriteRawBytes(script_data->data(), script_data_length);
+
+  return Just(true);
+}
+
 Maybe<bool> ValueSerializer::WriteHostObject(Handle<JSObject> object) {
   if (!delegate_) {
     isolate_->Throw(*isolate_->factory()->NewError(
         isolate_->error_function(), MessageTemplate::kDataCloneError, object));
     return Nothing<bool>();
   }
   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate_);
   Maybe<bool> result =
       delegate_->WriteHostObject(v8_isolate, Utils::ToLocal(object));
   RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate_, Nothing<bool>());
@@ skipping 290 matching lines @@
     case SerializationTag::kArrayBuffer:
       return ReadJSArrayBuffer();
     case SerializationTag::kArrayBufferTransfer: {
       const bool is_shared = false;
       return ReadTransferredJSArrayBuffer(is_shared);
     }
     case SerializationTag::kSharedArrayBufferTransfer: {
       const bool is_shared = true;
       return ReadTransferredJSArrayBuffer(is_shared);
     }
+    case SerializationTag::kWasmModule:
+      return ReadWasmModule();
     default:
       // TODO(jbroman): Introduce an explicit tag for host objects to avoid
       // having to treat every unknown tag as a potential host object.
       position_--;
       return ReadHostObject();
   }
 }
 
 MaybeHandle<String> ValueDeserializer::ReadUtf8String() {
   uint32_t utf8_length;
@@ skipping 382 matching lines @@
       byte_length % element_size != 0) {
     return MaybeHandle<JSArrayBufferView>();
   }
   Handle<JSTypedArray> typed_array = isolate_->factory()->NewJSTypedArray(
       external_array_type, buffer, byte_offset, byte_length / element_size,
       pretenure_);
   AddObjectWithID(id, typed_array);
   return typed_array;
 }
 
+MaybeHandle<JSObject> ValueDeserializer::ReadWasmModule() {
+  if (!FLAG_expose_wasm) return MaybeHandle<JSObject>();
+
+  Vector<const uint8_t> encoding_tag;
+  if (!ReadRawBytes(sizeof(WasmEncodingTag)).To(&encoding_tag) ||
+      encoding_tag[0] != static_cast<uint8_t>(WasmEncodingTag::kRawBytes)) {
+    return MaybeHandle<JSObject>();
+  }
+
+  // Extract the data from the buffer: wasm wire bytes, followed by V8 compiled
+  // script data.
+  static_assert(sizeof(int) <= sizeof(uint32_t),
+                "max int must fit in uint32_t");
+  const uint32_t max_valid_size = std::numeric_limits<int>::max();
+  uint32_t wire_bytes_length = 0;
+  Vector<const uint8_t> wire_bytes;
+  uint32_t compiled_bytes_length = 0;
+  Vector<const uint8_t> compiled_bytes;
+  if (!ReadVarint<uint32_t>().To(&wire_bytes_length) ||
+      wire_bytes_length > max_valid_size ||
+      !ReadRawBytes(wire_bytes_length).To(&wire_bytes) ||
+      !ReadVarint<uint32_t>().To(&compiled_bytes_length) ||
+      compiled_bytes_length > max_valid_size ||
+      !ReadRawBytes(compiled_bytes_length).To(&compiled_bytes)) {
+    return MaybeHandle<JSObject>();
+  }
+
+  // Try to deserialize the compiled module first.
+  ScriptData script_data(compiled_bytes.start(), compiled_bytes.length());
+  Handle<FixedArray> compiled_part;
+  if (WasmCompiledModuleSerializer::DeserializeWasmModule(
+          isolate_, &script_data, wire_bytes)
+          .ToHandle(&compiled_part)) {
+    return wasm::CreateWasmModuleObject(
+        isolate_, Handle<wasm::WasmCompiledModule>::cast(compiled_part),
+        wasm::ModuleOrigin::kWasmOrigin);
+  }
+
+  // If that fails, recompile.
+  wasm::ErrorThrower thrower(isolate_, "ValueDeserializer::ReadWasmModule");
+  return wasm::CreateModuleObjectFromBytes(
+      isolate_, wire_bytes.begin(), wire_bytes.end(), &thrower,
+      wasm::ModuleOrigin::kWasmOrigin, Handle<Script>::null(), nullptr,
+      nullptr);
+}
+
 MaybeHandle<JSObject> ValueDeserializer::ReadHostObject() {
   if (!delegate_) return MaybeHandle<JSObject>();
   STACK_CHECK(isolate_, MaybeHandle<JSObject>());
   uint32_t id = next_id_++;
   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate_);
   v8::Local<v8::Object> object;
   if (!delegate_->ReadHostObject(v8_isolate).ToLocal(&object)) {
     RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate_, JSObject);
     return MaybeHandle<JSObject>();
   }
@@ skipping 291 matching lines @@
   if (stack.size() != 1) {
     isolate_->Throw(*isolate_->factory()->NewError(
         MessageTemplate::kDataCloneDeserializationError));
     return MaybeHandle<Object>();
   }
   return scope.CloseAndEscape(stack[0]);
 }
 
 }  // namespace internal
 }  // namespace v8