WebAssembly API: implement Instance
authorjfbastien@apple.com <jfbastien@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 27 Oct 2016 02:18:51 +0000 (02:18 +0000)
committerjfbastien@apple.com <jfbastien@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 27 Oct 2016 02:18:51 +0000 (02:18 +0000)
As described in: https://github.com/WebAssembly/design/blob/master/JS.md#webassemblyinstance-objects

 - Take ownership of Wasm::Plan's compilation result when successfully creating a JSWebAssemblyModule object.
 - Construct a basic Instance with a Module.
 - Handle second argument (importObject) of WebAssembly.Instance.
 - Add reference text from the spec to WebAssembly.Module's code.
 - Expose and test an empty 'exports' ModuleNamespaceObject on WebAssembly.Instance.

The implementation isn't complete yet: it relies on further work for which I've filed bugs.

WebAssembly API: implement Instance
https://bugs.webkit.org/show_bug.cgi?id=163998

Reviewed by Keith Miller.

JSTests:

* wasm/js-api/test_Instance.js: Added.
(EmptyModule): use the Builder, create the simplest Module possible, and create an Instance from it
* wasm/js-api/test_basic_api.js:
(const.c.in.constructorProperties.switch): basic tests of the API

Source/JavaScriptCore:

* wasm/WasmPlan.h:
(JSC::Wasm::Plan::getFunctions): allow transfering state out
(JSC::Wasm::Plan::getMemory): allow transfering state out
* wasm/js/JSWebAssemblyInstance.cpp:
(JSC::JSWebAssemblyInstance::create):
(JSC::JSWebAssemblyInstance::finishCreation): set the ModuleNamespaceObject, and expose it as "exports"
(JSC::JSWebAssemblyInstance::visitChildren): visit the ModuleNamespaceObject child
* wasm/js/JSWebAssemblyInstance.h:
* wasm/js/JSWebAssemblyModule.cpp:
(JSC::JSWebAssemblyModule::create):
(JSC::JSWebAssemblyModule::JSWebAssemblyModule): move in the compiled functions and the memory
* wasm/js/JSWebAssemblyModule.h:
* wasm/js/WebAssemblyInstanceConstructor.cpp:
(JSC::constructJSWebAssemblyInstance): take the Module, extract the Plan's results, and create the (empty for now) ModuleNamespaceObject
* wasm/js/WebAssemblyModuleConstructor.cpp:
(JSC::constructJSWebAssemblyModule): add a few comments from the spec, and pass out the Plan's results

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@207929 268f45cc-cd09-0410-ab3c-d52691b4dbfc

JSTests/ChangeLog
JSTests/wasm/js-api/test_Instance.js [new file with mode: 0644]
JSTests/wasm/js-api/test_basic_api.js
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/wasm/WasmPlan.h
Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.cpp
Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.h
Source/JavaScriptCore/wasm/js/JSWebAssemblyModule.cpp
Source/JavaScriptCore/wasm/js/JSWebAssemblyModule.h
Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp
Source/JavaScriptCore/wasm/js/WebAssemblyModuleConstructor.cpp

index b4a389f..b9050c9 100644 (file)
@@ -1,3 +1,27 @@
+2016-10-26  JF Bastien  <jfbastien@apple.com>
+
+        WebAssembly API: implement Instance
+
+        As described in: https://github.com/WebAssembly/design/blob/master/JS.md#webassemblyinstance-objects
+
+         - Take ownership of Wasm::Plan's compilation result when successfully creating a JSWebAssemblyModule object.
+         - Construct a basic Instance with a Module.
+         - Handle second argument (importObject) of WebAssembly.Instance.
+         - Add reference text from the spec to WebAssembly.Module's code.
+         - Expose and test an empty 'exports' ModuleNamespaceObject on WebAssembly.Instance.
+
+        The implementation isn't complete yet: it relies on further work for which I've filed bugs.
+
+        WebAssembly API: implement Instance
+        https://bugs.webkit.org/show_bug.cgi?id=163998
+
+        Reviewed by Keith Miller.
+
+        * wasm/js-api/test_Instance.js: Added.
+        (EmptyModule): use the Builder, create the simplest Module possible, and create an Instance from it
+        * wasm/js-api/test_basic_api.js:
+        (const.c.in.constructorProperties.switch): basic tests of the API
+
 2016-10-26  Mark Lam  <mark.lam@apple.com>
 
         JSGenericTypedArrayView::set() should check for exceptions.
diff --git a/JSTests/wasm/js-api/test_Instance.js b/JSTests/wasm/js-api/test_Instance.js
new file mode 100644 (file)
index 0000000..3f4e5ee
--- /dev/null
@@ -0,0 +1,10 @@
+import * as assert from '../assert.js';
+import Builder from '../Builder.js';
+
+(function EmptyModule() {
+    const builder = new Builder();
+    const bin = builder.WebAssembly().get();
+    const module = new WebAssembly.Module(bin);
+    const instance = new WebAssembly.Instance(module);
+    assert.instanceof(instance, WebAssembly.Instance);
+})();
index 4ee8853..054eaef 100644 (file)
@@ -2,7 +2,9 @@ import * as assert from '../assert.js';
 import * as utilities from '../utilities.js';
 
 const version = 0xC;
-const emptyModule = Uint8Array.of(0x0, 0x61, 0x73, 0x6d, version, 0x00, 0x00, 0x00);
+const emptyModuleArray = Uint8Array.of(0x0, 0x61, 0x73, 0x6d, version, 0x00, 0x00, 0x00);
+const invalidConstructorInputs = [undefined, null, "", 1, {}, []];
+const invalidInstanceImports = [null, "", 1];
 
 const checkOwnPropertyDescriptor = (obj, prop, expect) => {
     const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
@@ -49,17 +51,27 @@ for (const c in constructorProperties) {
     assert.throws(() => WebAssembly[c](), TypeError, `calling WebAssembly.${c} constructor without new is invalid`);
     switch (c) {
     case "Module":
-        for (const invalid of [undefined, "", 1, {}, []])
+        for (const invalid of invalidConstructorInputs)
             assert.throws(() => new WebAssembly[c](invalid), TypeError, `first argument to WebAssembly.Module must be an ArrayBufferView or an ArrayBuffer (evaluating 'new WebAssembly[c](invalid)')`);
         for (const buffer of [new ArrayBuffer(), new DataView(new ArrayBuffer()), new Int8Array(), new Uint8Array(), new Uint8ClampedArray(), new Int16Array(), new Uint16Array(), new Int32Array(), new Uint32Array(), new Float32Array(), new Float64Array()])
             // FIXME the following should be WebAssembly.CompileError. https://bugs.webkit.org/show_bug.cgi?id=163768
             assert.throws(() => new WebAssembly[c](buffer), Error, `Module is 0 bytes, expected at least 8 bytes (evaluating 'new WebAssembly[c](buffer)')`);
-        assert.instanceof(new WebAssembly[c](emptyModule), WebAssembly.Module);
+        assert.instanceof(new WebAssembly[c](emptyModuleArray), WebAssembly.Module);
         // FIXME test neutered TypedArray and TypedArrayView. https://bugs.webkit.org/show_bug.cgi?id=163899
         break;
     case "Instance":
-        // FIXME Implement and test these APIs further. For now they just throw. https://bugs.webkit.org/show_bug.cgi?id=159775
-        assert.throws(() => new WebAssembly[c](), Error, `WebAssembly doesn't yet implement the ${c} constructor property`);
+        for (const invalid of invalidConstructorInputs)
+            assert.throws(() => new WebAssembly[c](invalid), TypeError, `first argument to WebAssembly.Instance must be a WebAssembly.Module (evaluating 'new WebAssembly[c](invalid)')`);
+        const instance = new WebAssembly[c](new WebAssembly.Module(emptyModuleArray));
+        assert.instanceof(instance, WebAssembly.Instance);
+        for (const invalid of invalidInstanceImports)
+            assert.throws(() => new WebAssembly[c](new WebAssembly.Module(emptyModuleArray), invalid), TypeError, `second argument to WebAssembly.Instance must be undefined or an Object (evaluating 'new WebAssembly[c](new WebAssembly.Module(emptyModuleArray), invalid)')`);
+        assert.notUndef(instance.exports);
+        checkOwnPropertyDescriptor(instance, "exports", { typeofvalue: "object", writable: true, configurable: true, enumerable: true });
+        assert.isUndef(instance.exports.__proto__);
+        assert.eq(Reflect.isExtensible(instance.exports), false);
+        assert.eq(Symbol.iterator in instance.exports, true);
+        assert.eq(Symbol.toStringTag in instance.exports, true);
         break;
     case "Memory":
         // FIXME Implement and test these APIs further. For now they just throw. https://bugs.webkit.org/show_bug.cgi?id=159775
index 76b0c69..5ae7cd9 100644 (file)
@@ -1,3 +1,39 @@
+2016-10-26  JF Bastien  <jfbastien@apple.com>
+
+        WebAssembly API: implement Instance
+
+        As described in: https://github.com/WebAssembly/design/blob/master/JS.md#webassemblyinstance-objects
+
+         - Take ownership of Wasm::Plan's compilation result when successfully creating a JSWebAssemblyModule object.
+         - Construct a basic Instance with a Module.
+         - Handle second argument (importObject) of WebAssembly.Instance.
+         - Add reference text from the spec to WebAssembly.Module's code.
+         - Expose and test an empty 'exports' ModuleNamespaceObject on WebAssembly.Instance.
+
+        The implementation isn't complete yet: it relies on further work for which I've filed bugs.
+
+        WebAssembly API: implement Instance
+        https://bugs.webkit.org/show_bug.cgi?id=163998
+
+        Reviewed by Keith Miller.
+
+        * wasm/WasmPlan.h:
+        (JSC::Wasm::Plan::getFunctions): allow transfering state out
+        (JSC::Wasm::Plan::getMemory): allow transfering state out
+        * wasm/js/JSWebAssemblyInstance.cpp:
+        (JSC::JSWebAssemblyInstance::create):
+        (JSC::JSWebAssemblyInstance::finishCreation): set the ModuleNamespaceObject, and expose it as "exports"
+        (JSC::JSWebAssemblyInstance::visitChildren): visit the ModuleNamespaceObject child
+        * wasm/js/JSWebAssemblyInstance.h:
+        * wasm/js/JSWebAssemblyModule.cpp:
+        (JSC::JSWebAssemblyModule::create):
+        (JSC::JSWebAssemblyModule::JSWebAssemblyModule): move in the compiled functions and the memory
+        * wasm/js/JSWebAssemblyModule.h:
+        * wasm/js/WebAssemblyInstanceConstructor.cpp:
+        (JSC::constructJSWebAssemblyInstance): take the Module, extract the Plan's results, and create the (empty for now) ModuleNamespaceObject
+        * wasm/js/WebAssemblyModuleConstructor.cpp:
+        (JSC::constructJSWebAssemblyModule): add a few comments from the spec, and pass out the Plan's results
+
 2016-10-26  Brian Burg  <bburg@apple.com>
 
         Web Inspector: remove unused bool return value from FrontendChannel::sendMessageToFrontend
index b794f1e..b84f9d7 100644 (file)
@@ -38,6 +38,8 @@ class Memory;
 
 class Plan {
 public:
+    typedef Vector<std::unique_ptr<FunctionCompilation>> CompiledFunctions;
+
     JS_EXPORT_PRIVATE Plan(VM&, Vector<uint8_t>);
     JS_EXPORT_PRIVATE Plan(VM&, const uint8_t*, size_t);
     JS_EXPORT_PRIVATE ~Plan();
@@ -63,9 +65,20 @@ public:
         RELEASE_ASSERT(!failed());
         return m_memory.get();
     }
+    
+    CompiledFunctions* getFunctions()
+    {
+        RELEASE_ASSERT(!failed());
+        return &m_result;
+    }
+    std::unique_ptr<Memory>* getMemory()
+    {
+        RELEASE_ASSERT(!failed());
+        return &m_memory;
+    }
 
 private:
-    Vector<std::unique_ptr<FunctionCompilation>> m_result;
+    CompiledFunctions m_result;
     std::unique_ptr<Memory> m_memory;
     bool m_failed { true };
     String m_errorMessage;
index b1da4e2..1d7bc33 100644 (file)
 #if ENABLE(WEBASSEMBLY)
 
 #include "JSCInlines.h"
+#include "JSModuleNamespaceObject.h"
 
 namespace JSC {
 
-JSWebAssemblyInstance* JSWebAssemblyInstance::create(VM& vm, Structure* structure)
+JSWebAssemblyInstance* JSWebAssemblyInstance::create(VM& vm, Structure* structure, JSModuleNamespaceObject* moduleNamespaceObject)
 {
     auto* instance = new (NotNull, allocateCell<JSWebAssemblyInstance>(vm.heap)) JSWebAssemblyInstance(vm, structure);
-    instance->finishCreation(vm);
+    instance->finishCreation(vm, moduleNamespaceObject);
     return instance;
 }
 
@@ -49,9 +50,11 @@ JSWebAssemblyInstance::JSWebAssemblyInstance(VM& vm, Structure* structure)
 {
 }
 
-void JSWebAssemblyInstance::finishCreation(VM& vm)
+void JSWebAssemblyInstance::finishCreation(VM& vm, JSModuleNamespaceObject* moduleNamespaceObject)
 {
     Base::finishCreation(vm);
+    m_moduleNamespaceObject.set(vm, this, moduleNamespaceObject);
+    putDirectWithoutTransition(vm, Identifier::fromString(&vm, "exports"), m_moduleNamespaceObject.get(), None);
     ASSERT(inherits(info()));
 }
 
@@ -66,6 +69,7 @@ void JSWebAssemblyInstance::visitChildren(JSCell* cell, SlotVisitor& visitor)
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
 
     Base::visitChildren(thisObject, visitor);
+    visitor.append(&thisObject->m_moduleNamespaceObject);
 }
 
 const ClassInfo JSWebAssemblyInstance::s_info = { "WebAssembly.Instance", &Base::s_info, 0, CREATE_METHOD_TABLE(JSWebAssemblyInstance) };
index b21e45f..87acc97 100644 (file)
 #include "JSObject.h"
 
 namespace JSC {
+    
+class JSModuleNamespaceObject;
 
 class JSWebAssemblyInstance : public JSDestructibleObject {
 public:
     typedef JSDestructibleObject Base;
 
-    static JSWebAssemblyInstance* create(VM&, Structure*);
+    static JSWebAssemblyInstance* create(VM&, Structure*, JSModuleNamespaceObject*);
     static Structure* createStructure(VM&, JSGlobalObject*, JSValue);
 
     DECLARE_INFO;
 
 protected:
     JSWebAssemblyInstance(VM&, Structure*);
-    void finishCreation(VM&);
+    void finishCreation(VM&, JSModuleNamespaceObject*);
     static void destroy(JSCell*);
     static void visitChildren(JSCell*, SlotVisitor&);
+
+private:
+    WriteBarrier<JSModuleNamespaceObject> m_moduleNamespaceObject;
 };
 
 } // namespace JSC
index f28a4fc..65cca95 100644 (file)
 #if ENABLE(WEBASSEMBLY)
 
 #include "JSCInlines.h"
+#include "WasmFormat.h"
+#include "WasmMemory.h"
+#include <wtf/StdLibExtras.h>
 
 namespace JSC {
 
-JSWebAssemblyModule* JSWebAssemblyModule::create(VM& vm, Structure* structure)
+JSWebAssemblyModule* JSWebAssemblyModule::create(VM& vm, Structure* structure, Vector<std::unique_ptr<Wasm::FunctionCompilation>>* compiledFunctions, std::unique_ptr<Wasm::Memory>* memory)
 {
-    auto* instance = new (NotNull, allocateCell<JSWebAssemblyModule>(vm.heap)) JSWebAssemblyModule(vm, structure);
+    auto* instance = new (NotNull, allocateCell<JSWebAssemblyModule>(vm.heap)) JSWebAssemblyModule(vm, structure, compiledFunctions, memory);
     instance->finishCreation(vm);
     return instance;
 }
@@ -44,8 +47,10 @@ Structure* JSWebAssemblyModule::createStructure(VM& vm, JSGlobalObject* globalOb
     return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
 }
 
-JSWebAssemblyModule::JSWebAssemblyModule(VM& vm, Structure* structure)
+JSWebAssemblyModule::JSWebAssemblyModule(VM& vm, Structure* structure, Vector<std::unique_ptr<Wasm::FunctionCompilation>>* compiledFunctions, std::unique_ptr<Wasm::Memory>* memory)
     : Base(vm, structure)
+    , m_compiledFunctions(WTFMove(*compiledFunctions))
+    , m_memory(WTFMove(*memory))
 {
 }
 
index be7f692..a438a61 100644 (file)
 
 namespace JSC {
 
+namespace Wasm {
+struct FunctionCompilation;
+class Memory;
+}
+
 class JSWebAssemblyModule : public JSDestructibleObject {
 public:
     typedef JSDestructibleObject Base;
 
-    static JSWebAssemblyModule* create(VM&, Structure*);
+    static JSWebAssemblyModule* create(VM&, Structure*, Vector<std::unique_ptr<Wasm::FunctionCompilation>>*, std::unique_ptr<Wasm::Memory>*);
     static Structure* createStructure(VM&, JSGlobalObject*, JSValue);
 
     DECLARE_INFO;
 
 protected:
-    JSWebAssemblyModule(VM&, Structure*);
+    JSWebAssemblyModule(VM&, Structure*, Vector<std::unique_ptr<Wasm::FunctionCompilation>>*, std::unique_ptr<Wasm::Memory>*);
     void finishCreation(VM&);
     static void destroy(JSCell*);
     static void visitChildren(JSCell*, SlotVisitor&);
+
+private:
+    Vector<std::unique_ptr<Wasm::FunctionCompilation>> m_compiledFunctions;
+    std::unique_ptr<Wasm::Memory> m_memory;
 };
 
 } // namespace JSC
index 55bf4a1..a9ff11d 100644 (file)
 
 #include "FunctionPrototype.h"
 #include "JSCInlines.h"
+#include "JSModuleNamespaceObject.h"
+#include "JSModuleRecord.h"
+#include "JSWebAssemblyInstance.h"
+#include "JSWebAssemblyModule.h"
 #include "WebAssemblyInstancePrototype.h"
 
 #include "WebAssemblyInstanceConstructor.lut.h"
@@ -45,9 +49,42 @@ const ClassInfo WebAssemblyInstanceConstructor::s_info = { "Function", &Base::s_
 
 static EncodedJSValue JSC_HOST_CALL constructJSWebAssemblyInstance(ExecState* state)
 {
-    VM& vm = state->vm();
+    auto& vm = state->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
-    return JSValue::encode(throwException(state, scope, createError(state, ASCIILiteral("WebAssembly doesn't yet implement the Instance constructor property"))));
+    auto* globalObject = state->lexicalGlobalObject();
+
+    // If moduleObject is not a WebAssembly.Module instance, a TypeError is thrown.
+    JSWebAssemblyModule* module = jsDynamicCast<JSWebAssemblyModule*>(state->argument(0));
+    if (!module)
+        return JSValue::encode(throwException(state, scope, createTypeError(state, ASCIILiteral("first argument to WebAssembly.Instance must be a WebAssembly.Module"), defaultSourceAppender, runtimeTypeForValue(state->argument(0)))));
+
+    // If the importObject parameter is not undefined and Type(importObject) is not Object, a TypeError is thrown.
+    JSValue importArgument = state->argument(1);
+    JSObject* importObject = importArgument.getObject();
+    if (!importArgument.isUndefined() && !importObject)
+        return JSValue::encode(throwException(state, scope, createTypeError(state, ASCIILiteral("second argument to WebAssembly.Instance must be undefined or an Object"), defaultSourceAppender, runtimeTypeForValue(importArgument))));
+
+    // FIXME use the importObject. https://bugs.webkit.org/show_bug.cgi?id=164039
+    // If the list of module.imports is not empty and Type(importObject) is not Object, a TypeError is thrown.
+
+    // FIXME String things from https://bugs.webkit.org/show_bug.cgi?id=164023
+    // Let exports be a list of (string, JS value) pairs that is mapped from each external value e in instance.exports as follows:
+    IdentifierSet instanceExports;
+    for (const auto& name : instanceExports) {
+        // FIXME validate according to Module.Instance spec.
+        (void)name;
+    }
+    Identifier moduleKey;
+    SourceCode sourceCode;
+    VariableEnvironment declaredVariables;
+    VariableEnvironment lexicalVariables;
+    auto* moduleRecord = JSModuleRecord::create(state, vm, globalObject->moduleRecordStructure(), moduleKey, sourceCode, declaredVariables, lexicalVariables);
+    auto* moduleNamespaceObject = JSModuleNamespaceObject::create(state, globalObject, globalObject->moduleNamespaceObjectStructure(), moduleRecord, instanceExports);
+
+    auto* structure = InternalFunction::createSubclassStructure(state, state->newTarget(), globalObject->WebAssemblyInstanceStructure());
+    RETURN_IF_EXCEPTION(scope, encodedJSValue());
+
+    return JSValue::encode(JSWebAssemblyInstance::create(vm, structure, moduleNamespaceObject));
 }
 
 static EncodedJSValue JSC_HOST_CALL callJSWebAssemblyInstance(ExecState* state)
index e903eef..0b055a0 100644 (file)
@@ -54,6 +54,8 @@ static EncodedJSValue JSC_HOST_CALL constructJSWebAssemblyModule(ExecState* stat
     auto& vm = state->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
     JSValue val = state->argument(0);
+
+    // If the given bytes argument is not a BufferSource, a TypeError exception is thrown.
     JSArrayBuffer* arrayBuffer = val.getObject() ? jsDynamicCast<JSArrayBuffer*>(val.getObject()) : nullptr;
     JSArrayBufferView* arrayBufferView = val.getObject() ? jsDynamicCast<JSArrayBufferView*>(val.getObject()) : nullptr;
     if (!(arrayBuffer || arrayBufferView))
@@ -67,14 +69,17 @@ static EncodedJSValue JSC_HOST_CALL constructJSWebAssemblyModule(ExecState* stat
     const auto* base = arrayBufferView ? static_cast<uint8_t*>(arrayBufferView->vector()) : static_cast<uint8_t*>(arrayBuffer->impl()->data());
 
     Wasm::Plan plan(vm, base + byteOffset, byteSize);
+    // On failure, a new WebAssembly.CompileError is thrown.
     if (plan.failed())
         return JSValue::encode(throwException(state, scope, createWebAssemblyCompileError(state, plan.errorMessage())));
 
-    // FIXME take content from Plan.
+    // The spec string values inside Ast.module are decoded as UTF8 as described in Web.md. FIXME https://bugs.webkit.org/show_bug.cgi?id=164023
 
+    // On success, a new WebAssembly.Module object is returned with [[Module]] set to the validated Ast.module.
     auto* structure = InternalFunction::createSubclassStructure(state, state->newTarget(), asInternalFunction(state->callee())->globalObject()->WebAssemblyModuleStructure());
     RETURN_IF_EXCEPTION(scope, encodedJSValue());
-    return JSValue::encode(JSWebAssemblyModule::create(vm, structure));
+
+    return JSValue::encode(JSWebAssemblyModule::create(vm, structure, plan.getFunctions(), plan.getMemory()));
 }
 
 static EncodedJSValue JSC_HOST_CALL callJSWebAssemblyModule(ExecState* state)