[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-typer.h"
 #include "src/asmjs/asm-wasm-builder.h"
 #include "src/assert-scope.h"
 #include "src/ast/ast.h"
@@ skipping 177 matching lines @@
     }
 
     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::FixedArray> compiled_module =
-        result.val->CompileFunctions(isolate);
-    if (!compiled_module.is_null()) {
+        result.val->CompileFunctions(isolate, thrower);
+    if (!thrower->error()) {
+      DCHECK(!compiled_module.is_null());
       object = i::wasm::WasmModule::Instantiate(
           isolate, compiled_module.ToHandleChecked(), ffi, memory);
       if (!object.is_null()) {
         args.GetReturnValue().Set(v8::Utils::ToLocal(object.ToHandleChecked()));
       }
     }
   }
 
   if (result.val) delete result.val;
   return object;
@@ skipping 79 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, thrower);
+  if (compiled_module.is_null()) return nothing;
   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::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);
   ErrorThrower thrower(reinterpret_cast<i::Isolate*>(isolate),
                        "WebAssembly.compile()");
 
   if (args.Length() < 1) {
     thrower.Error("Argument 0 must be a buffer source");
     return;
   }
   i::MaybeHandle<i::JSObject> module_obj =
       CreateModuleObject(isolate, args[0], &thrower);
-  if (module_obj.is_null()) return;
 
   Local<Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Promise::Resolver> resolver;
   if (!v8::Promise::Resolver::New(context).ToLocal(&resolver)) return;
-  resolver->Resolve(context, Utils::ToLocal(module_obj.ToHandleChecked()));
-
+  if (thrower.error()) {
+    resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+  } else {
+    resolver->Resolve(context, Utils::ToLocal(module_obj.ToHandleChecked()));
+  }
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
   return_value.Set(resolver->GetPromise());
 }
 
 void WebAssemblyModule(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   HandleScope scope(isolate);
   ErrorThrower thrower(reinterpret_cast<i::Isolate*>(isolate),
                        "WebAssembly.Module()");
 
   if (args.Length() < 1) {
     thrower.Error("Argument 0 must be a buffer source");
     return;
   }
   i::MaybeHandle<i::JSObject> module_obj =
       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);
+
+  ErrorThrower thrower(i_isolate, "WebAssembly.Instance()");
 
   if (args.Length() < 1) {
-    thrower.Error("Argument 0 must be a WebAssembly.Module");
+    thrower.Error(
+        "Argument 0 must be provided, and must be a WebAssembly.Module object");
     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;
+  if (source.is_null() || source.ToHandleChecked()->IsUndefined(i_isolate)) {
+    thrower.Error("Argument 0 must be a WebAssembly.Module");
+    return;
+  }
 
-  RawBuffer buffer =
-      GetRawBufferSource(Utils::ToLocal(source.ToHandleChecked()), &thrower);
-  if (buffer.start == nullptr) return;
+  Local<Object> obj = Local<Object>::Cast(args[0]);
 
-  InstantiateModuleCommon(args, buffer.start, buffer.end, &thrower);
+  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;
+  }
+
+  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 76 matching lines @@
   Handle<JSObject> wasm_object = factory->NewJSObject(cons, TENURED);
   PropertyAttributes attributes = static_cast<PropertyAttributes>(DONT_ENUM);
   JSObject::AddProperty(global, name, wasm_object, attributes);
 
   // Install static methods on WebAssembly object.
   InstallFunc(isolate, wasm_object, "compile", WebAssemblyCompile);
   Handle<JSFunction> module_constructor =
       InstallFunc(isolate, wasm_object, "Module", WebAssemblyModule);
   Handle<JSFunction> instance_constructor =
       InstallFunc(isolate, wasm_object, "Instance", WebAssemblyInstance);
+  i::Handle<i::Map> map = isolate->factory()->NewMap(
+      i::JS_OBJECT_TYPE, i::JSObject::kHeaderSize + i::kPointerSize);
+  module_constructor->set_prototype_or_initial_map(*map);
+  map->SetConstructor(*module_constructor);
+
   context->set_wasm_module_constructor(*module_constructor);
   context->set_wasm_instance_constructor(*instance_constructor);
 }
 
 void WasmJs::InstallWasmFunctionMap(Isolate* isolate, Handle<Context> context) {
   if (!context->get(Context::WASM_FUNCTION_MAP_INDEX)->IsMap()) {
     // TODO(titzer): Move this to bootstrapper.cc??
     // TODO(titzer): Also make one for strict mode functions?
     Handle<Map> prev_map = Handle<Map>(context->sloppy_function_map(), isolate);
 
@@ skipping 11 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