Get rid of HeapRootVisitor and make SlotVisitor less painful to use
[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     ASSERT(instance());
120     EncodedJSValue rawResult = vmEntryToWasm(m_jsEntrypoint->entrypoint(), &vm, protoCallFrame);
121     vm.topJSWebAssemblyInstance = prevJSWebAssemblyInstance;
122
123     // FIXME is this correct? https://bugs.webkit.org/show_bug.cgi?id=164876
124     switch (signature()->returnType) {
125     case Wasm::Void:
126         return JSValue::encode(jsUndefined());
127     case Wasm::I32:
128         return JSValue::encode(JSValue(static_cast<int32_t>(rawResult)));
129     case Wasm::F32:
130         return JSValue::encode(JSValue(bitwise_cast<float>(static_cast<int32_t>(rawResult))));
131     case Wasm::F64:
132         return JSValue::encode(JSValue(bitwise_cast<double>(rawResult)));
133     case Wasm::I64:
134     case Wasm::Func:
135     case Wasm::Anyfunc:
136         break;
137     }
138
139     RELEASE_ASSERT_NOT_REACHED();
140     return EncodedJSValue();
141 }
142
143 WebAssemblyFunction* WebAssemblyFunction::create(VM& vm, JSGlobalObject* globalObject, unsigned length, const String& name, JSWebAssemblyInstance* instance, JSWebAssemblyCallee* jsEntrypoint, JSWebAssemblyCallee* wasmEntrypoint, Wasm::Signature* signature)
144 {
145     NativeExecutable* executable = vm.getHostFunction(callWebAssemblyFunction, NoIntrinsic, callHostFunctionAsConstructor, nullptr, name);
146     Structure* structure = globalObject->webAssemblyFunctionStructure();
147     WebAssemblyFunction* function = new (NotNull, allocateCell<WebAssemblyFunction>(vm.heap)) WebAssemblyFunction(vm, globalObject, structure);
148     function->finishCreation(vm, executable, length, name, instance, jsEntrypoint, wasmEntrypoint, signature);
149     return function;
150 }
151
152 Structure* WebAssemblyFunction::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
153 {
154     ASSERT(globalObject);
155     return Structure::create(vm, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), info());
156 }
157
158 WebAssemblyFunction::WebAssemblyFunction(VM& vm, JSGlobalObject* globalObject, Structure* structure)
159     : Base(vm, globalObject, structure)
160 {
161 }
162
163 void WebAssemblyFunction::visitChildren(JSCell* cell, SlotVisitor& visitor)
164 {
165     WebAssemblyFunction* thisObject = jsCast<WebAssemblyFunction*>(cell);
166     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
167     Base::visitChildren(thisObject, visitor);
168     visitor.append(thisObject->m_instance);
169     visitor.append(thisObject->m_jsEntrypoint);
170     visitor.append(thisObject->m_wasmEntrypoint);
171 }
172
173 void WebAssemblyFunction::finishCreation(VM& vm, NativeExecutable* executable, unsigned length, const String& name, JSWebAssemblyInstance* instance, JSWebAssemblyCallee* jsEntrypoint, JSWebAssemblyCallee* wasmEntrypoint, Wasm::Signature* signature)
174 {
175     Base::finishCreation(vm, executable, length, name);
176     ASSERT(inherits(info()));
177     m_instance.set(vm, this, instance);
178     ASSERT(jsEntrypoint != wasmEntrypoint);
179     m_jsEntrypoint.set(vm, this, jsEntrypoint);
180     m_wasmEntrypoint.set(vm, this, wasmEntrypoint);
181     m_signature = signature;
182 }
183
184 } // namespace JSC
185
186 #endif // ENABLE(WEBASSEMBLY)