WebAssembly JS API: implement start function
[WebKit-https.git] / Source / JavaScriptCore / wasm / js / WebAssemblyFunction.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 "WebAssemblyFunction.h"
28
29 #if ENABLE(WEBASSEMBLY)
30
31 #include "B3Compilation.h"
32 #include "JSCInlines.h"
33 #include "JSFunctionInlines.h"
34 #include "JSObject.h"
35 #include "JSWebAssemblyCallee.h"
36 #include "JSWebAssemblyInstance.h"
37 #include "JSWebAssemblyMemory.h"
38 #include "LLIntThunks.h"
39 #include "ProtoCallFrame.h"
40 #include "VM.h"
41 #include "WasmFormat.h"
42 #include "WasmMemory.h"
43
44 namespace JSC {
45
46 const ClassInfo WebAssemblyFunction::s_info = { "WebAssemblyFunction", &Base::s_info, nullptr, CREATE_METHOD_TABLE(WebAssemblyFunction) };
47
48 static EncodedJSValue JSC_HOST_CALL callWebAssemblyFunction(ExecState* exec)
49 {
50     VM& vm = exec->vm();
51     auto scope = DECLARE_THROW_SCOPE(vm);
52     WebAssemblyFunction* wasmFunction = jsDynamicCast<WebAssemblyFunction*>(exec->jsCallee());
53     if (!wasmFunction)
54         return JSValue::encode(throwException(exec, scope, createTypeError(exec, "expected a WebAssembly function", defaultSourceAppender, runtimeTypeForValue(exec->jsCallee()))));
55     const Wasm::Signature* signature = wasmFunction->signature();
56
57     // FIXME is this the right behavior? https://bugs.webkit.org/show_bug.cgi?id=164876
58     if (exec->argumentCount() != signature->arguments.size())
59         return JSValue::encode(throwException(exec, scope, createNotEnoughArgumentsError(exec, defaultSourceAppender)));
60
61     // FIXME is this boxing correct? https://bugs.webkit.org/show_bug.cgi?id=164876
62     Vector<JSValue> boxedArgs;
63     for (unsigned argIndex = 0; argIndex < exec->argumentCount(); ++argIndex) {
64         JSValue arg = exec->uncheckedArgument(argIndex);
65         switch (signature->arguments[argIndex]) {
66         case Wasm::I32:
67             arg = JSValue::decode(arg.toInt32(exec));
68             break;
69         case Wasm::F32:
70             arg = JSValue::decode(bitwise_cast<uint32_t>(arg.toFloat(exec)));
71             break;
72         case Wasm::F64:
73             arg = JSValue::decode(bitwise_cast<uint64_t>(arg.toNumber(exec)));
74             break;
75         case Wasm::Void:
76         case Wasm::I64:
77         case Wasm::Func:
78         case Wasm::Anyfunc:
79             RELEASE_ASSERT_NOT_REACHED();
80         }
81         RETURN_IF_EXCEPTION(scope, { });
82         boxedArgs.append(arg);
83     }
84
85     JSValue firstArgument = JSValue();
86     int argCount = 1;
87     JSValue* remainingArgs = nullptr;
88     if (boxedArgs.size()) {
89         remainingArgs = boxedArgs.data();
90         firstArgument = *remainingArgs;
91         remainingArgs++;
92         argCount = boxedArgs.size();
93     }
94
95     // Note: we specifically use the WebAssemblyFunction as the callee to begin with in the ProtoCallFrame.
96     // The reason for this is that calling into the llint may stack overflow, and the stack overflow
97     // handler might read the global object from the callee. The JSWebAssemblyCallee doesn't have a
98     // global object, but the WebAssemblyFunction does.
99     ProtoCallFrame protoCallFrame;
100     protoCallFrame.init(nullptr, wasmFunction, firstArgument, argCount, remainingArgs);
101
102     return wasmFunction->call(vm, &protoCallFrame);
103 }
104
105 EncodedJSValue WebAssemblyFunction::call(VM& vm, ProtoCallFrame* protoCallFrame)
106 {
107     // Setup the memory that the entrance loads.
108     if (JSWebAssemblyMemory* memory = instance()->memory()) {
109         Wasm::Memory* wasmMemory = memory->memory();
110         vm.topWasmMemoryPointer = wasmMemory->memory();
111         vm.topWasmMemorySize = wasmMemory->size();
112     } else {
113         vm.topWasmMemoryPointer = nullptr;
114         vm.topWasmMemorySize = 0;
115     }
116
117     JSWebAssemblyInstance* prevJSWebAssemblyInstance = vm.topJSWebAssemblyInstance;
118     vm.topJSWebAssemblyInstance = instance();
119     EncodedJSValue rawResult = vmEntryToWasm(webAssemblyCallee()->jsToWasmEntryPoint(), &vm, protoCallFrame);
120     vm.topJSWebAssemblyInstance = prevJSWebAssemblyInstance;
121
122     // FIXME is this correct? https://bugs.webkit.org/show_bug.cgi?id=164876
123     switch (signature()->returnType) {
124     case Wasm::Void:
125         return JSValue::encode(jsUndefined());
126     case Wasm::I32:
127         return JSValue::encode(JSValue(static_cast<int32_t>(rawResult)));
128     case Wasm::F32:
129         return JSValue::encode(JSValue(bitwise_cast<float>(static_cast<int32_t>(rawResult))));
130     case Wasm::F64:
131         return JSValue::encode(JSValue(bitwise_cast<double>(rawResult)));
132     case Wasm::I64:
133     case Wasm::Func:
134     case Wasm::Anyfunc:
135         break;
136     }
137
138     RELEASE_ASSERT_NOT_REACHED();
139     return EncodedJSValue();
140 }
141
142 WebAssemblyFunction* WebAssemblyFunction::create(VM& vm, JSGlobalObject* globalObject, unsigned length, const String& name, JSWebAssemblyInstance* instance, JSWebAssemblyCallee* callee, Wasm::Signature* signature)
143 {
144     NativeExecutable* executable = vm.getHostFunction(callWebAssemblyFunction, NoIntrinsic, callHostFunctionAsConstructor, nullptr, name);
145     Structure* structure = globalObject->webAssemblyFunctionStructure();
146     WebAssemblyFunction* function = new (NotNull, allocateCell<WebAssemblyFunction>(vm.heap)) WebAssemblyFunction(vm, globalObject, structure);
147     function->finishCreation(vm, executable, length, name, instance, callee, signature);
148     return function;
149 }
150
151 Structure* WebAssemblyFunction::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
152 {
153     ASSERT(globalObject);
154     return Structure::create(vm, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), info());
155 }
156
157 WebAssemblyFunction::WebAssemblyFunction(VM& vm, JSGlobalObject* globalObject, Structure* structure)
158     : Base(vm, globalObject, structure)
159 {
160 }
161
162 void WebAssemblyFunction::visitChildren(JSCell* cell, SlotVisitor& visitor)
163 {
164     WebAssemblyFunction* thisObject = jsCast<WebAssemblyFunction*>(cell);
165     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
166     Base::visitChildren(thisObject, visitor);
167     visitor.append(&thisObject->m_instance);
168     visitor.append(&thisObject->m_wasmCallee);
169 }
170
171 void WebAssemblyFunction::finishCreation(VM& vm, NativeExecutable* executable, unsigned length, const String& name, JSWebAssemblyInstance* instance, JSWebAssemblyCallee* wasmCallee, Wasm::Signature* signature)
172 {
173     Base::finishCreation(vm, executable, length, name);
174     ASSERT(inherits(info()));
175     m_instance.set(vm, this, instance);
176     m_wasmCallee.set(vm, this, wasmCallee);
177     m_signature = signature;
178 }
179
180 } // namespace JSC
181
182 #endif // ENABLE(WEBASSEMBLY)