Changeset 238376 in webkit

Timestamp:

Nov 19, 2018 8:49:43 AM (5 years ago)

Author:

yusukesuzuki@slowstart.org

Message:

[WebAssembly] I64 arguments / return value check should be moved from callWebAssemblyFunction to JSToWasm wrapper
​https://bugs.webkit.org/show_bug.cgi?id=190512

Reviewed by Keith Miller.

This patch moves I64 arguments / return value check from callWebAssemblyFunction to JSToWasm wrapper. Since this
check can be done when compiling the function, we should encode the result into the generated wrapper instead of
checking every time we call callWebAssemblyFunction. This change is also one of the steps removing callWebAssemblyFunction
entirely.

• wasm/WasmExceptionType.h:
• wasm/js/JSToWasm.cpp:

(JSC::Wasm::createJSToWasmWrapper):

• wasm/js/WebAssemblyFunction.cpp:

(JSC::callWebAssemblyFunction):

• wasm/js/WebAssemblyWrapperFunction.cpp:

(JSC::callWebAssemblyWrapperFunction):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• wasm/WasmExceptionType.h (modified) (1 diff)
• wasm/js/JSToWasm.cpp (modified) (4 diffs)
• wasm/js/WebAssemblyFunction.cpp (modified) (4 diffs)
• wasm/js/WebAssemblyWrapperFunction.cpp (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2018-11-19  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
+
+        [WebAssembly] I64 arguments / return value check should be moved from callWebAssemblyFunction to JSToWasm wrapper
+        https://bugs.webkit.org/show_bug.cgi?id=190512
+
+        Reviewed by Keith Miller.
+
+        This patch moves I64 arguments / return value check from callWebAssemblyFunction to JSToWasm wrapper. Since this
+        check can be done when compiling the function, we should encode the result into the generated wrapper instead of
+        checking every time we call callWebAssemblyFunction. This change is also one of the steps removing callWebAssemblyFunction
+        entirely.
+
+        * wasm/WasmExceptionType.h:
+        * wasm/js/JSToWasm.cpp:
+        (JSC::Wasm::createJSToWasmWrapper):
+        * wasm/js/WebAssemblyFunction.cpp:
+        (JSC::callWebAssemblyFunction):
+        * wasm/js/WebAssemblyWrapperFunction.cpp:
+        (JSC::callWebAssemblyWrapperFunction):
+
 2018-11-12  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
 

trunk/Source/JavaScriptCore/wasm/WasmExceptionType.h

@@ -41 +41 @@
     macro(DivisionByZero, "Division by zero") \
     macro(IntegerOverflow, "Integer overflow") \
-    macro(StackOverflow, "Stack overflow")
+    macro(StackOverflow, "Stack overflow") \
+    macro(I64ArgumentType, "WebAssembly function with an i64 argument can't be called from JavaScript") \
+    macro(I64ReturnType, "WebAssembly function that returns i64 can't be called from JavaScript")
 
 enum class ExceptionType : uint32_t {

trunk/Source/JavaScriptCore/wasm/js/JSToWasm.cpp

@@ -31 +31 @@
 #include "CCallHelpers.h"
 #include "JSWebAssemblyInstance.h"
+#include "JSWebAssemblyRuntimeError.h"
+#include "MaxFrameExtentForSlowPathCall.h"
 #include "WasmCallingConvention.h"
 #include "WasmContextInlines.h"
 #include "WasmSignatureInlines.h"
+#include "WasmToJS.h"
 
 namespace JSC { namespace Wasm {
@@ -71 +74 @@
     unsigned numGPRs = 0;
     unsigned numFPRs = 0;
+    bool argumentsIncludeI64 = false;
     for (unsigned i = 0; i < signature.argumentCount(); i++) {
         switch (signature.argument(i)) {
         case Wasm::I64:
+            argumentsIncludeI64 = true;
+            FALLTHROUGH;
         case Wasm::I32:
             if (numGPRs >= wasmCallingConvention().m_gprArgs.size())
@@ -101 +107 @@
         ptrdiff_t offset = regAtOffset.offset();
         jit.storePtr(reg, CCallHelpers::Address(GPRInfo::callFrameRegister, offset));
+    }
+
+    if (argumentsIncludeI64 || signature.returnType() == Wasm::I64) {
+        if (Context::useFastTLS())
+            jit.loadWasmContextInstance(GPRInfo::argumentGPR2);
+        else {
+            // vmEntryToWasm passes the JSWebAssemblyInstance corresponding to Wasm::Context*'s
+            // instance as the first JS argument when we're not using fast TLS to hold the
+            // Wasm::Context*'s instance.
+            jit.loadPtr(CCallHelpers::Address(GPRInfo::callFrameRegister, CallFrameSlot::thisArgument * sizeof(EncodedJSValue)), GPRInfo::argumentGPR2);
+            jit.loadPtr(CCallHelpers::Address(GPRInfo::argumentGPR2, JSWebAssemblyInstance::offsetOfPoisonedInstance()), GPRInfo::argumentGPR2);
+            jit.move(CCallHelpers::TrustedImm64(JSWebAssemblyInstancePoison::key()), GPRInfo::argumentGPR0);
+            jit.xor64(GPRInfo::argumentGPR0, GPRInfo::argumentGPR2);
+        }
+
+        jit.loadPtr(CCallHelpers::Address(GPRInfo::argumentGPR2, Instance::offsetOfPointerToTopEntryFrame()), GPRInfo::argumentGPR0);
+        jit.loadPtr(CCallHelpers::Address(GPRInfo::argumentGPR0), GPRInfo::argumentGPR0);
+        jit.copyCalleeSavesToEntryFrameCalleeSavesBuffer(GPRInfo::argumentGPR0);
+        jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
+        jit.move(CCallHelpers::TrustedImm32(static_cast<int32_t>(argumentsIncludeI64 ? ExceptionType::I64ArgumentType : ExceptionType::I64ReturnType)), GPRInfo::argumentGPR1);
+
+        CCallHelpers::Call call = jit.call(OperationPtrTag);
+
+        jit.jump(GPRInfo::returnValueGPR, ExceptionHandlerPtrTag);
+        jit.breakpoint(); // We should not reach this.
+
+        jit.addLinkTask([=] (LinkBuffer& linkBuffer) {
+            linkBuffer.link(call, FunctionPtr<OperationPtrTag>(wasmToJSException));
+        });
+        return result;
     }
 
@@ -201 +237 @@
     });
 
-
     for (const RegisterAtOffset& regAtOffset : registersToSpill) {
         GPRReg reg = regAtOffset.reg().gpr();

trunk/Source/JavaScriptCore/wasm/js/WebAssemblyFunction.cpp

@@ -56 +56 @@
     VM& vm = exec->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
-    WebAssemblyFunction* wasmFunction = jsDynamicCast<WebAssemblyFunction*>(vm, exec->jsCallee());
-    if (!wasmFunction)
-        return JSValue::encode(throwException(exec, scope, createTypeError(exec, "expected a WebAssembly function", defaultSourceAppender, runtimeTypeForValue(vm, exec->jsCallee()))));
+    WebAssemblyFunction* wasmFunction = jsCast<WebAssemblyFunction*>(exec->jsCallee());
     Wasm::SignatureIndex signatureIndex = wasmFunction->signatureIndex();
     const Wasm::Signature& signature = Wasm::SignatureInformation::get(signatureIndex);
@@ -64 +62 @@
     // Make sure that the memory we think we are going to run with matches the one we expect.
     ASSERT(wasmFunction->instance()->instance().codeBlock()->isSafeToRun(wasmFunction->instance()->memory()->memory().mode()));
-    {
-        // Check if we have a disallowed I64 use.
-
-        for (unsigned argIndex = 0; argIndex < signature.argumentCount(); ++argIndex) {
-            if (signature.argument(argIndex) == Wasm::I64) {
-                JSWebAssemblyRuntimeError* error = JSWebAssemblyRuntimeError::create(exec, vm, exec->lexicalGlobalObject()->WebAssemblyRuntimeErrorStructure(),
-                    "WebAssembly function with an i64 argument can't be called from JavaScript");
-                return JSValue::encode(throwException(exec, scope, error));
-            }
-        }
-
-        if (signature.returnType() == Wasm::I64) {
-            JSWebAssemblyRuntimeError* error = JSWebAssemblyRuntimeError::create(exec, vm, exec->lexicalGlobalObject()->WebAssemblyRuntimeErrorStructure(),
-                "WebAssembly function that returns i64 can't be called from JavaScript");
-            return JSValue::encode(throwException(exec, scope, error));
-        }
-    }
 
     std::optional<TraceScope> traceScope;
@@ -100 +81 @@
             arg = JSValue::decode(arg.toInt32(exec));
             break;
+        case Wasm::I64:
+            arg = JSValue();
+            break;
         case Wasm::F32:
             arg = JSValue::decode(bitwise_cast<uint32_t>(arg.toFloat(exec)));
@@ -107 +91 @@
             break;
         case Wasm::Void:
-        case Wasm::I64:
         case Wasm::Func:
         case Wasm::Anyfunc:

trunk/Source/JavaScriptCore/wasm/js/WebAssemblyWrapperFunction.cpp

@@ -43 +43 @@
     VM& vm = exec->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
-    WebAssemblyWrapperFunction* wasmFunction = jsDynamicCast<WebAssemblyWrapperFunction*>(vm, exec->jsCallee());
-    if (!wasmFunction)
-        return JSValue::encode(throwException(exec, scope, createTypeError(exec, "expected a WebAssembly function")));
-
+    WebAssemblyWrapperFunction* wasmFunction = jsCast<WebAssemblyWrapperFunction*>(exec->jsCallee());
     CallData callData;
     JSObject* function = wasmFunction->function();