f3b7fdeb99600455730330527658eab765b20550
[WebKit-https.git] / Source / JavaScriptCore / wasm / js / WebAssemblyInstanceConstructor.cpp
1 /*
2  * Copyright (C) 2016 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "WebAssemblyInstanceConstructor.h"
28
29 #if ENABLE(WEBASSEMBLY)
30
31 #include "FunctionPrototype.h"
32 #include "JSCInlines.h"
33 #include "JSModuleEnvironment.h"
34 #include "JSModuleNamespaceObject.h"
35 #include "JSWebAssemblyInstance.h"
36 #include "JSWebAssemblyModule.h"
37 #include "WebAssemblyFunction.h"
38 #include "WebAssemblyInstancePrototype.h"
39 #include "WebAssemblyModuleRecord.h"
40
41 #include "WebAssemblyInstanceConstructor.lut.h"
42
43 namespace JSC {
44
45 static const bool verbose = false;
46
47 const ClassInfo WebAssemblyInstanceConstructor::s_info = { "Function", &Base::s_info, &constructorTableWebAssemblyInstance, CREATE_METHOD_TABLE(WebAssemblyInstanceConstructor) };
48
49 /* Source for WebAssemblyInstanceConstructor.lut.h
50  @begin constructorTableWebAssemblyInstance
51  @end
52  */
53
54 static EncodedJSValue JSC_HOST_CALL constructJSWebAssemblyInstance(ExecState* state)
55 {
56     auto& vm = state->vm();
57     auto scope = DECLARE_THROW_SCOPE(vm);
58     auto* globalObject = state->lexicalGlobalObject();
59
60     // If moduleObject is not a WebAssembly.Module instance, a TypeError is thrown.
61     JSWebAssemblyModule* jsModule = jsDynamicCast<JSWebAssemblyModule*>(state->argument(0));
62     if (!jsModule)
63         return JSValue::encode(throwException(state, scope, createTypeError(state, ASCIILiteral("first argument to WebAssembly.Instance must be a WebAssembly.Module"), defaultSourceAppender, runtimeTypeForValue(state->argument(0)))));
64     const Wasm::ModuleInformation& moduleInformation = jsModule->moduleInformation();
65
66     // If the importObject parameter is not undefined and Type(importObject) is not Object, a TypeError is thrown.
67     JSValue importArgument = state->argument(1);
68     JSObject* importObject = importArgument.getObject();
69     if (!importArgument.isUndefined() && !importObject)
70         return JSValue::encode(throwException(state, scope, createTypeError(state, ASCIILiteral("second argument to WebAssembly.Instance must be undefined or an Object"), defaultSourceAppender, runtimeTypeForValue(importArgument))));
71
72     // If the list of module.imports is not empty and Type(importObject) is not Object, a TypeError is thrown.
73     if (moduleInformation.imports.size() && !importObject)
74         return JSValue::encode(throwException(state, scope, createTypeError(state, ASCIILiteral("second argument to WebAssembly.Instance must be Object because the WebAssembly.Module has imports"), defaultSourceAppender, runtimeTypeForValue(importArgument))));
75
76     Identifier moduleKey = Identifier::fromUid(PrivateName(PrivateName::Description, "WebAssemblyInstance"));
77     WebAssemblyModuleRecord* moduleRecord = WebAssemblyModuleRecord::create(state, vm, globalObject->webAssemblyModuleRecordStructure(), moduleKey, moduleInformation);
78     RETURN_IF_EXCEPTION(scope, { });
79
80     Structure* instanceStructure = InternalFunction::createSubclassStructure(state, state->newTarget(), globalObject->WebAssemblyInstanceStructure());
81     RETURN_IF_EXCEPTION(scope, { });
82
83     JSWebAssemblyInstance* instance = JSWebAssemblyInstance::create(vm, instanceStructure, jsModule, moduleRecord->getModuleNamespace(state), moduleInformation.imports.size());
84     RETURN_IF_EXCEPTION(scope, { });
85
86     // Let funcs, memories and tables be initially-empty lists of callable JavaScript objects, WebAssembly.Memory objects and WebAssembly.Table objects, respectively.
87     // Let imports be an initially-empty list of external values.
88     unsigned numImportFunctions = 0;
89
90     // FIXME implement Table https://bugs.webkit.org/show_bug.cgi?id=164135
91     // FIXME implement Memory https://bugs.webkit.org/show_bug.cgi?id=164134
92     // FIXME implement Global https://bugs.webkit.org/show_bug.cgi?id=164133
93
94     // For each import i in module.imports:
95     for (auto& import : moduleInformation.imports) {
96         // 1. Let o be the resultant value of performing Get(importObject, i.module_name).
97         JSValue importModuleValue = importObject->get(state, import.module);
98         RETURN_IF_EXCEPTION(scope, { });
99         // 2. If Type(o) is not Object, throw a TypeError.
100         if (!importModuleValue.isObject())
101             return JSValue::encode(throwException(state, scope, createTypeError(state, ASCIILiteral("import must be an object"), defaultSourceAppender, runtimeTypeForValue(importModuleValue))));
102         // 3. Let v be the value of performing Get(o, i.item_name)
103         JSObject* object = jsCast<JSObject*>(importModuleValue);
104         JSValue value = object->get(state, import.field);
105         RETURN_IF_EXCEPTION(scope, { });
106         switch (import.kind) {
107         case Wasm::External::Function: {
108             // 4. If i is a function import:
109             // i. If IsCallable(v) is false, throw a TypeError.
110             if (!value.isFunction())
111                 return JSValue::encode(throwException(state, scope, createTypeError(state, ASCIILiteral("import function must be callable"), defaultSourceAppender, runtimeTypeForValue(value))));
112             JSCell* cell = value.asCell();
113             // ii. If v is an Exported Function Exotic Object:
114             if (WebAssemblyFunction* importedExports = jsDynamicCast<WebAssemblyFunction*>(object)) {
115                 // FIXME handle Function Exotic Object properly. https://bugs.webkit.org/show_bug.cgi?id=165282
116                 // a. If the signature of v does not match the signature of i, throw a TypeError.
117                 // b. Let closure be v.[[Closure]].
118                 RELEASE_ASSERT_NOT_REACHED();
119                 UNUSED_PARAM(importedExports);
120                 break;
121             }
122             // iii. Otherwise:
123             // a. Let closure be a new host function of the given signature which calls v by coercing WebAssembly arguments to JavaScript arguments via ToJSValue and returns the result, if any, by coercing via ToWebAssemblyValue.
124             // Note: done as part of Plan compilation.
125             // iv. Append v to funcs.
126             instance->setImportFunction(vm, cell, numImportFunctions++);
127             // v. Append closure to imports.
128             break;
129         }
130         case Wasm::External::Table: {
131             // 7. Otherwise (i is a table import):
132             // FIXME implement Table https://bugs.webkit.org/show_bug.cgi?id=164135
133             // i. If v is not a WebAssembly.Table object, throw a TypeError.
134             // ii. Append v to tables.
135             // iii. Append v.[[Table]] to imports.
136             RELEASE_ASSERT_NOT_REACHED();
137             break;
138         }
139         case Wasm::External::Memory: {
140             // 6. If i is a memory import:
141             // FIXME implement Memory https://bugs.webkit.org/show_bug.cgi?id=164134
142             // i. If v is not a WebAssembly.Memory object, throw a TypeError.
143             // ii. Append v to memories.
144             // iii. Append v.[[Memory]] to imports.
145             RELEASE_ASSERT_NOT_REACHED();
146             break;
147         }
148         case Wasm::External::Global: {
149             // 5. If i is a global import:
150             // FIXME implement Global https://bugs.webkit.org/show_bug.cgi?id=164133
151             // i. If i is not an immutable global, throw a TypeError.
152             // ii. If Type(v) is not Number, throw a TypeError.
153             // iii. Append ToWebAssemblyValue(v) to imports.
154             RELEASE_ASSERT_NOT_REACHED();
155             break;
156         }
157         }
158     }
159
160     moduleRecord->link(state, instance);
161     RETURN_IF_EXCEPTION(scope, { });
162     if (verbose)
163         moduleRecord->dump();
164     JSValue startResult = moduleRecord->evaluate(state);
165     UNUSED_PARAM(startResult);
166     RETURN_IF_EXCEPTION(scope, { });
167
168     return JSValue::encode(instance);
169 }
170
171 static EncodedJSValue JSC_HOST_CALL callJSWebAssemblyInstance(ExecState* state)
172 {
173     VM& vm = state->vm();
174     auto scope = DECLARE_THROW_SCOPE(vm);
175     return JSValue::encode(throwConstructorCannotBeCalledAsFunctionTypeError(state, scope, "WebAssembly.Instance"));
176 }
177
178 WebAssemblyInstanceConstructor* WebAssemblyInstanceConstructor::create(VM& vm, Structure* structure, WebAssemblyInstancePrototype* thisPrototype)
179 {
180     auto* constructor = new (NotNull, allocateCell<WebAssemblyInstanceConstructor>(vm.heap)) WebAssemblyInstanceConstructor(vm, structure);
181     constructor->finishCreation(vm, thisPrototype);
182     return constructor;
183 }
184
185 Structure* WebAssemblyInstanceConstructor::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
186 {
187     return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
188 }
189
190 void WebAssemblyInstanceConstructor::finishCreation(VM& vm, WebAssemblyInstancePrototype* prototype)
191 {
192     Base::finishCreation(vm, ASCIILiteral("Instance"));
193     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, DontEnum | DontDelete | ReadOnly);
194     putDirectWithoutTransition(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontEnum | DontDelete);
195 }
196
197 WebAssemblyInstanceConstructor::WebAssemblyInstanceConstructor(VM& vm, Structure* structure)
198     : Base(vm, structure)
199 {
200 }
201
202 ConstructType WebAssemblyInstanceConstructor::getConstructData(JSCell*, ConstructData& constructData)
203 {
204     constructData.native.function = constructJSWebAssemblyInstance;
205     return ConstructType::Host;
206 }
207
208 CallType WebAssemblyInstanceConstructor::getCallData(JSCell*, CallData& callData)
209 {
210     callData.native.function = callJSWebAssemblyInstance;
211     return CallType::Host;
212 }
213
214 void WebAssemblyInstanceConstructor::visitChildren(JSCell* cell, SlotVisitor& visitor)
215 {
216     auto* thisObject = jsCast<WebAssemblyInstanceConstructor*>(cell);
217     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
218     Base::visitChildren(thisObject, visitor);
219 }
220
221 } // namespace JSC
222
223 #endif // ENABLE(WEBASSEMBLY)
224