[wasm] Support recompilation if deserialization fails.

src/api.cc

 // Copyright 2012 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/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 7166 matching lines @@
   PREPARE_FOR_EXECUTION(context, Proxy, New, Proxy);
   i::Handle<i::JSReceiver> target = Utils::OpenHandle(*local_target);
   i::Handle<i::JSReceiver> handler = Utils::OpenHandle(*local_handler);
   Local<Proxy> result;
   has_pending_exception =
       !ToLocal<Proxy>(i::JSProxy::New(isolate, target, handler), &result);
   RETURN_ON_FAILED_EXECUTION(Proxy);
   RETURN_ESCAPED(result);
 }
 
-WasmCompiledModule::SerializedModule WasmCompiledModule::Serialize() {
+Local<String> WasmCompiledModule::GetUncompiledBytes() {
   i::Handle<i::JSObject> obj =
       i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
-  i::Handle<i::FixedArray> compiled_part =
-      i::handle(i::FixedArray::cast(obj->GetInternalField(0)));
+  i::Handle<i::wasm::WasmCompiledModule> compiled_part =
+      i::handle(i::wasm::WasmCompiledModule::cast(obj->GetInternalField(0)));
+  return Local<String>::Cast(Utils::ToLocal(compiled_part->module_bytes()));
+}
+
+WasmCompiledModule::SerializedModule WasmCompiledModule::Serialize() {
+  class WasmCompiledModuleRawBytesManager {
+   public:
+    WasmCompiledModuleRawBytesManager(
+        i::Handle<i::wasm::WasmCompiledModule> wasm_module)
+        : module_(wasm_module), bytes_(wasm_module->module_bytes()) {
+      module_->reset_module_bytes();
+    }
+
+    ~WasmCompiledModuleRawBytesManager() { module_->set_module_bytes(bytes_); }
+
+   private:
+    i::Handle<i::wasm::WasmCompiledModule> module_;
+    i::Handle<i::String> bytes_;
+  };
+
+  i::Handle<i::JSObject> obj =
+      i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
+  i::Handle<i::wasm::WasmCompiledModule> compiled_part =
+      i::handle(i::wasm::WasmCompiledModule::cast(obj->GetInternalField(0)));
+
+  WasmCompiledModuleRawBytesManager ensure_clean_serialization(compiled_part);

[Yang, 2016/10/06 07:35:34]

what's the advantage of this over of simply take compiled_part->module_bytes()
here and store it back at the end?

Also, do we expect compiled_part->module_bytes() to changed in
SerializeWasmModule?

[vogelheim, 2016/10/06 10:00:50]

Agree w/ Yang.

Also, in case we do want to keep this: Elsewhere in V8 we've called similar
helper objects SomethingSomethingScope, which makes it clearer to people
familiar w/ V8 code what this does. Maybe something like: SaveModuleBytesScope?
Or SaveModuleBytesScope?

[Mircea Trofin, 2016/10/06 16:17:47]

Initially I thought there may be error cases to deal with, coming out of the
serializer, but now I realize that's not
the case, and that in itself wouldn't change the control flow in a way that'd
make the simpler code unfeasible. 
So canning the over-complication. 
Absolutely not. We take it out, however, because:
- we want the bytes to be separately handled by the caller. The scenario is:
serialize to IndexedDB today; Chrome+v8 updates; deserialize. We want the
uncompiled bytes to be serialized separately as raw bytes, and not depend  on
v8's serializer. 
- we don't want to pay for the bytes twice. Wasm payloads are large. Uncompiled
bytes are megs or tens of megs. Especially on mobile, it'd be sloppy to save
them both.
I like the name suggestions, but I think for now I'm taking the simpler code
suggestion.

   std::unique_ptr<i::ScriptData> script_data =
       i::WasmCompiledModuleSerializer::SerializeWasmModule(obj->GetIsolate(),
                                                            compiled_part);
   script_data->ReleaseDataOwnership();
+
   size_t size = static_cast<size_t>(script_data->length());
   return {std::unique_ptr<const uint8_t[]>(script_data->data()), size};
 }
 
-MaybeLocal<WasmCompiledModule> WasmCompiledModule::Deserialize(
+MaybeLocal<WasmCompiledModule> WasmCompiledModule::DeserializeOrCompile(
     Isolate* isolate,
-    const WasmCompiledModule::SerializedModule& serialized_data) {
+    const WasmCompiledModule::SerializedModule& serialized_data,
+    Local<String> uncompiled_bytes) {
   int size = static_cast<int>(serialized_data.second);
   i::ScriptData sc(serialized_data.first.get(), size);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   i::MaybeHandle<i::FixedArray> maybe_compiled_part =
       i::WasmCompiledModuleSerializer::DeserializeWasmModule(i_isolate, &sc);
   i::Handle<i::FixedArray> compiled_part;
   if (!maybe_compiled_part.ToHandle(&compiled_part)) {
-    return MaybeLocal<WasmCompiledModule>();
+    return Compile(isolate, uncompiled_bytes);
   }
+  i::Handle<i::wasm::WasmCompiledModule> compiled_module =
+      handle(i::wasm::WasmCompiledModule::cast(*compiled_part));
+  i::Handle<i::String> module_bytes = Utils::OpenHandle(*uncompiled_bytes);
+  compiled_module->set_module_bytes(module_bytes);
   return Local<WasmCompiledModule>::Cast(
       Utils::ToLocal(i::wasm::CreateCompiledModuleObject(
-          i_isolate, compiled_part, i::wasm::ModuleOrigin::kWasmOrigin)));
+          i_isolate, compiled_module, i::wasm::ModuleOrigin::kWasmOrigin)));
+}
+
+MaybeLocal<WasmCompiledModule> WasmCompiledModule::Compile(
+    Isolate* isolate, Local<String> bytes) {
+  i::Handle<i::String> module_bytes = Utils::OpenHandle(*bytes);
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  // if we cannot deserialize, we recompile

[vogelheim, 2016/10/06 10:00:50]

Doesn't that comment belongs into DeserializeOrCompile? (Once we're here, we
have already made the decision to recompile, right?)

[Mircea Trofin, 2016/10/06 16:17:47]

yes.

+  i::wasm::ErrorThrower thrower(i_isolate, "WasmCompiledModule::Deserialize()");
+  i::SeqOneByteString* data = i::SeqOneByteString::cast(*module_bytes);
+  i::MaybeHandle<i::JSObject> maybe_compiled =
+      i::wasm::CreateModuleObjectFromBytes(
+          i_isolate, data->GetChars(), data->GetChars() + data->length(),
+          &thrower, i::wasm::ModuleOrigin::kWasmOrigin);
+  if (maybe_compiled.is_null()) return MaybeLocal<WasmCompiledModule>();
+  return Local<WasmCompiledModule>::Cast(
+      Utils::ToLocal(maybe_compiled.ToHandleChecked()));
 }
 
 // static
 v8::ArrayBuffer::Allocator* v8::ArrayBuffer::Allocator::NewDefaultAllocator() {
   return new ArrayBufferAllocator();
 }
 
 bool v8::ArrayBuffer::IsExternal() const {
   return Utils::OpenHandle(this)->is_external();
 }
@@ skipping 2150 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8