[wasm] Compile and Instantiation

src/wasm/wasm-js.cc

 // Copyright 2015 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-natives.h"
 #include "src/api.h"
 #include "src/asmjs/asm-wasm-builder.h"
 #include "src/asmjs/typing-asm.h"
 #include "src/assert-scope.h"
 #include "src/ast/ast.h"
@@ skipping 281 matching lines @@
   if (args.Length() < 1) {
     thrower.Error("Argument 0 must be a buffer source");
     return;
   }
   RawBuffer buffer = GetRawBufferSource(args[0], &thrower);
   if (buffer.start == nullptr) return;
 
   InstantiateModuleCommon(args, buffer.start, buffer.end, &thrower);
 }
 
-
 static i::MaybeHandle<i::JSObject> CreateModuleObject(
     v8::Isolate* isolate, const v8::Local<v8::Value> source,
     ErrorThrower* thrower) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  i::MaybeHandle<i::JSObject> nothing;
 
   RawBuffer buffer = GetRawBufferSource(source, thrower);
   if (buffer.start == nullptr) return i::MaybeHandle<i::JSObject>();
 
-  // TODO(rossberg): Once we can, do compilation here.
   DCHECK(source->IsArrayBuffer() || source->IsTypedArray());
+  i::Zone zone(i_isolate->allocator());
+  i::wasm::ModuleResult result = i::wasm::DecodeWasmModule(
+      i_isolate, &zone, buffer.start, buffer.end, false, i::wasm::kWasmOrigin);
+  std::unique_ptr<const i::wasm::WasmModule> decoded_module(result.val);
+  if (result.failed()) {
+    thrower->Failed("", result);
+    return nothing;
+  }
+  i::MaybeHandle<i::FixedArray> compiled_module =
+      decoded_module->CompileFunctions(i_isolate);
+  if (compiled_module.is_null()) return nothing;

[rossberg, 2016/07/04 10:04:00]

It seems like CompileFunctions eagerly raises exceptions in the error case, but
that breaks the asynchronous WebAssembly.compile method, which should capture
all exceptions in a rejected promise.

To make that work, CompileFunctions will need to take an ErrorThrower and report
all failures through that (and then use the thrower-Reify method in
WebAssemblyComile to get a handle on the exception).

As a temporary solution, WebAssemblyCompile could also implement a catch-handler
that reifies the exceptions retroactively. However, that won't fly any longer
once compilation will actually be performed asynchronously, e.g. when off-loaded
to another thread.

[Mircea Trofin, 2016/07/14 16:02:58]

Done, + test

   Local<Context> context = isolate->GetCurrentContext();
   i::Handle<i::Context> i_context = Utils::OpenHandle(*context);
   i::Handle<i::JSFunction> module_cons(i_context->wasm_module_constructor());
+  i::Handle<i::Map> map = i_isolate->factory()->NewMap(

[rossberg, 2016/07/04 10:04:00]

It isn't desirable to create a new map creation for each module object. Can you
move this to the Install function and store the map in the native context?

[Mircea Trofin, 2016/07/14 16:02:58]

Done.

+      i::JS_OBJECT_TYPE, i::JSObject::kHeaderSize + i::kPointerSize);
+  module_cons->set_prototype_or_initial_map(*map);
+  map->SetConstructor(*module_cons);
   i::Handle<i::JSObject> module_obj =
       i_isolate->factory()->NewJSObject(module_cons);
+  module_obj->SetInternalField(0, *compiled_module.ToHandleChecked());
   i::Handle<i::Object> module_ref = Utils::OpenHandle(*source);
   i::Handle<i::Symbol> module_sym(i_context->wasm_module_sym());
   i::Object::SetProperty(module_obj, module_sym, module_ref, i::STRICT).Check();
 
   return module_obj;
 }
 
 void WebAssemblyCompile(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   HandleScope scope(isolate);
@@ skipping 31 matching lines @@
       CreateModuleObject(isolate, args[0], &thrower);
   if (module_obj.is_null()) return;
 
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
   return_value.Set(Utils::ToLocal(module_obj.ToHandleChecked()));
 }
 
 void WebAssemblyInstance(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
   v8::Isolate* isolate = args.GetIsolate();
-  ErrorThrower thrower(reinterpret_cast<i::Isolate*>(isolate),
-                       "WebAssembly.Instance()");
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
-  if (args.Length() < 1) {
+  ErrorThrower thrower(i_isolate, "WebAssembly.Instance()");
+
+  if (args.Length() < 1 || !args[0]->IsObject()) {

[rossberg, 2016/07/04 10:04:00]

This check is not sufficient (nor necessary). You should be checking that the
value has the module_sym property, like in the previous code, which brands it as
a module object.

[Mircea Trofin, 2016/07/05 06:02:42]

Done.

[rossberg, 2016/07/14 13:30:28]

Hm, I still don't see the code that addresses this comment. In its current form,
the CL is unsafe, because you could be looking at another kind of object that
just happens to have a FixedArray in its internal field 0 as well. You need the
private symbol to identify the object as a module unambiguously.

[Mircea Trofin, 2016/07/14 16:02:58]

Done (hopefully this time I won't delete my own patch again)

     thrower.Error("Argument 0 must be a WebAssembly.Module");
     return;
   }
-  Local<Context> context = isolate->GetCurrentContext();
-  i::Handle<i::Context> i_context = Utils::OpenHandle(*context);
-  i::Handle<i::Symbol> module_sym(i_context->wasm_module_sym());
-  i::MaybeHandle<i::Object> source =
-      i::Object::GetProperty(Utils::OpenHandle(*args[0]), module_sym);
-  if (source.is_null()) return;
+  Local<Object> obj = Local<Object>::Cast(args[0]);
 
-  RawBuffer buffer =
-      GetRawBufferSource(Utils::ToLocal(source.ToHandleChecked()), &thrower);
-  if (buffer.start == nullptr) return;
+  i::Handle<i::JSObject> module_obj =
+      i::Handle<i::JSObject>::cast(v8::Utils::OpenHandle(*obj));
+  if (module_obj->GetInternalFieldCount() < 1 ||
+      !module_obj->GetInternalField(0)->IsFixedArray()) {
+    thrower.Error("Argument 0 is an invalid WebAssembly.Module");
+    return;
+  }
 
-  InstantiateModuleCommon(args, buffer.start, buffer.end, &thrower);
+  i::Handle<i::FixedArray> compiled_code = i::Handle<i::FixedArray>(
+      i::FixedArray::cast(module_obj->GetInternalField(0)));
+
+  i::Handle<i::JSReceiver> ffi = i::Handle<i::JSObject>::null();
+  if (args.Length() > 1 && args[1]->IsObject()) {
+    Local<Object> obj = Local<Object>::Cast(args[1]);
+    ffi = i::Handle<i::JSReceiver>::cast(v8::Utils::OpenHandle(*obj));
+  }
+
+  i::Handle<i::JSArrayBuffer> memory = i::Handle<i::JSArrayBuffer>::null();
+  if (args.Length() > 2 && args[2]->IsArrayBuffer()) {
+    Local<Object> obj = Local<Object>::Cast(args[2]);
+    i::Handle<i::Object> mem_obj = v8::Utils::OpenHandle(*obj);
+    memory = i::Handle<i::JSArrayBuffer>(i::JSArrayBuffer::cast(*mem_obj));
+  }
+  i::MaybeHandle<i::JSObject> instance =
+      i::wasm::WasmModule::Instantiate(i_isolate, compiled_code, ffi, memory);
+  if (instance.is_null()) {
+    thrower.Error("Could not instantiate module");
+    return;
+  }
+  v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
+  return_value.Set(Utils::ToLocal(instance.ToHandleChecked()));
 }
 }  // namespace
 
 // TODO(titzer): we use the API to create the function template because the
 // internal guts are too ugly to replicate here.
 static i::Handle<i::FunctionTemplateInfo> NewTemplate(i::Isolate* i_isolate,
                                                       FunctionCallback func) {
   Isolate* isolate = reinterpret_cast<Isolate*>(i_isolate);
   Local<FunctionTemplate> local = FunctionTemplate::New(isolate, func);
   return v8::Utils::OpenHandle(*local);
@@ skipping 107 matching lines @@
     int unused_property_fields = in_object_properties - pre_allocated;
     Handle<Map> map = Map::CopyInitialMap(
         prev_map, instance_size, in_object_properties, unused_property_fields);
 
     context->set_wasm_function_map(*map);
   }
 }
 
 }  // namespace internal
 }  // namespace v8