[wasm] Transferrable 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"
@@ skipping 108 matching lines @@
   // ObjectReference to one) serialized just before it. This is a quirk arising
   // from the previous stack-based implementation.
   kArrayBufferView = 'V',
   // Shared array buffer. transferID:uint32_t
   kSharedArrayBuffer = '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',
+  // A wasm module object transfer. next value is its index.
+  kWasmModuleTransfer = 'w',
   // The delegate is responsible for processing all following data.
   // This "escapes" to whatever wire format the delegate chooses.
   kHostObject = '\\',
 };
 
 namespace {
 
 enum class ArrayBufferViewTag : uint8_t {
   kInt8Array = 'b',
   kUint8Array = 'B',
@@ skipping 657 matching lines @@
     DCHECK(view->IsJSDataView());
     tag = ArrayBufferViewTag::kDataView;
   }
   WriteVarint(static_cast<uint8_t>(tag));
   WriteVarint(NumberToUint32(view->byte_offset()));
   WriteVarint(NumberToUint32(view->byte_length()));
   return ThrowIfOutOfMemory();
 }
 
 Maybe<bool> ValueSerializer::WriteWasmModule(Handle<JSObject> object) {
+  if (delegate_ != nullptr) {
+    Maybe<uint32_t> transfer_id = delegate_->GetWasmModuleTransferId(
+        reinterpret_cast<v8::Isolate*>(isolate_),
+        v8::Local<v8::WasmCompiledModule>::Cast(Utils::ToLocal(object)));
+    RETURN_VALUE_IF_SCHEDULED_EXCEPTION(isolate_, Nothing<bool>());
+    uint32_t id = 0;
+    if (transfer_id.To(&id)) {
+      WriteTag(SerializationTag::kWasmModuleTransfer);
+      WriteVarint<uint32_t>(id);
+      return Just(true);
+    }
+  }
+
   Handle<WasmCompiledModule> compiled_part(
       WasmCompiledModule::cast(object->GetEmbedderField(0)), isolate_);
   WasmEncodingTag encoding_tag = WasmEncodingTag::kRawBytes;
   WriteTag(SerializationTag::kWasmModule);
   WriteRawBytes(&encoding_tag, sizeof(encoding_tag));
 
   Handle<String> wire_bytes(compiled_part->module_bytes(), isolate_);
   int wire_bytes_length = wire_bytes->length();
   WriteVarint<uint32_t>(wire_bytes_length);
   uint8_t* destination;
@@ skipping 327 matching lines @@
     case SerializationTag::kArrayBufferTransfer: {
       const bool is_shared = false;
       return ReadTransferredJSArrayBuffer(is_shared);
     }
     case SerializationTag::kSharedArrayBuffer: {
       const bool is_shared = true;
       return ReadTransferredJSArrayBuffer(is_shared);
     }
     case SerializationTag::kWasmModule:
       return ReadWasmModule();
+    case SerializationTag::kWasmModuleTransfer:
+      return ReadWasmModuleTransfer();
     case SerializationTag::kHostObject:
       return ReadHostObject();
     default:
       // Before there was an explicit tag for host objects, all unknown tags
       // were delegated to the host.
       if (version_ < 13) {
         position_--;
         return ReadHostObject();
       }
       return MaybeHandle<Object>();
@@ skipping 425 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::ReadWasmModuleTransfer() {
+  if (FLAG_wasm_disable_structured_cloning || expect_inline_wasm()) {
+    return MaybeHandle<JSObject>();
+  }
+
+  uint32_t transfer_id = 0;
+  Local<Value> module_value;
+  if (ReadVarint<uint32_t>().To(&transfer_id) && delegate_ != nullptr &&
+      delegate_
+          ->GetWasmModuleFromId(reinterpret_cast<v8::Isolate*>(isolate_),
+                                transfer_id)
+          .ToLocal(&module_value)) {
+    RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate_, JSObject);

[jbroman, 2017/03/17 19:08:48]

This should be in the false path. If an exception is thrown, GetWasmModuleFromId
should return an empty MaybeLocal (and so we won't reach here.)

[Mircea Trofin, 2017/03/17 22:16:48]

Acknowledged.

+    uint32_t id = next_id_++;
+    Handle<JSObject> module =
+        Handle<JSObject>::cast(Utils::OpenHandle(*module_value));
+    AddObjectWithID(id, module);
+    return module;
+  } else {
+    return MaybeHandle<JSObject>();

[jbroman, 2017/03/17 19:08:48]

nit: this might be slightly clearer with early return:

if (!ReadVarint<uint32_t>().To(&transfer_id) || !delegate_ ||
      !delegate_
          ->GetWasmModuleFromId(reinterpret_cast<v8::Isolate*>(isolate_),
                                transfer_id)
          .ToLocal(&module_value)) {
  RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate_, JSObject);
  return MaybeHandle<JSObject>();
}

uint32_t id = next_id_++;
// ...

[Mircea Trofin, 2017/03/17 22:16:48]

Done.

+  }
+}
+
 MaybeHandle<JSObject> ValueDeserializer::ReadWasmModule() {
-  if (FLAG_wasm_disable_structured_cloning) return MaybeHandle<JSObject>();
+  if (FLAG_wasm_disable_structured_cloning || !expect_inline_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;
+  MaybeHandle<JSObject> result;
   if (WasmCompiledModuleSerializer::DeserializeWasmModule(
           isolate_, &script_data, wire_bytes)
           .ToHandle(&compiled_part)) {
-    return WasmModuleObject::New(
+    result = WasmModuleObject::New(
         isolate_, Handle<WasmCompiledModule>::cast(compiled_part));
-  }
-
-  // If that fails, recompile.
-  MaybeHandle<JSObject> result;
-  {
+  } else {
     wasm::ErrorThrower thrower(isolate_, "ValueDeserializer::ReadWasmModule");
     result = wasm::SyncCompile(isolate_, &thrower,
                                wasm::ModuleWireBytes(wire_bytes));
   }
   RETURN_EXCEPTION_IF_SCHEDULED_EXCEPTION(isolate_, JSObject);
+  uint32_t id = next_id_++;
+  if (!result.is_null()) {
+    AddObjectWithID(id, result.ToHandleChecked());
+  }
   return result;
 }
 
 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)) {
@@ skipping 316 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