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)