Changeset 209560 in webkit for trunk/Source/JavaScriptCore/wasm/WasmPlan.cpp

Timestamp:

Dec 8, 2016, 1:09:06 PM (9 years ago)

Author:

[email protected]

Message:

WebAssembly JS API: wire up Instance imports
​https://bugs.webkit.org/show_bug.cgi?id=165118

Reviewed by Saam Barati.

JSTests:

• wasm/js-api/test_Instance.js: add the test, disabled for now

Source/JavaScriptCore:

Change a bunch of the WebAssembly object model, and pipe the
necessary changes to be able to call JS imports from
WebAssembly. This will make it easier to call_indirect, and
unblock many other missing features.

As a follow-up I need to teach JSC::linkFor to live without a
CodeBlock: wasm doesn't have one and the IC patching is sad. We'll
switch on the callee (or its type?) and then use that as the owner
(because the callee is alive if the instance is alive, ditto
module, and module owns the CallLinkInfo).

• CMakeLists.txt:
• JavaScriptCore.xcodeproj/project.pbxproj:
• interpreter/CallFrame.h:

(JSC::ExecState::callee): give access to the callee as a JSCell

• jit/RegisterSet.cpp: dead code from previous WebAssembly implementation
• jsc.cpp:

(callWasmFunction):
(functionTestWasmModuleFunctions):

• runtime/JSCellInlines.h:

(JSC::ExecState::vm): check callee instead of jsCallee: wasm only has a JSCell and not a JSObject

• runtime/VM.cpp:

(JSC::VM::VM): store the "top" WebAssembly.Instance on entry to WebAssembly (and restore the previous one on exit)

• runtime/VM.h:
• testWasm.cpp:

(runWasmTests):

• wasm/JSWebAssembly.h:
• wasm/WasmB3IRGenerator.cpp:

(JSC::Wasm::B3IRGenerator::B3IRGenerator): pass unlinked calls around to shorten their lifetime: they're ony needed until the Plan is done
(JSC::Wasm::B3IRGenerator::addCall):
(JSC::Wasm::createJSToWasmWrapper):
(JSC::Wasm::parseAndCompile): also pass in the function index space, so that imports can be signature-checked along with internal functions

• wasm/WasmB3IRGenerator.h:
• wasm/WasmBinding.cpp: Added.

(JSC::Wasm::importStubGenerator): stubs from wasm to JS

• wasm/WasmBinding.h: Copied from Source/JavaScriptCore/wasm/WasmValidate.h.
• wasm/WasmCallingConvention.h:

(JSC::Wasm::CallingConvention::setupFrameInPrologue):

• wasm/WasmFormat.h: fix the object model

(JSC::Wasm::CallableFunction::CallableFunction):

• wasm/WasmFunctionParser.h: simplify some of the failure condition checks

(JSC::Wasm::FunctionParser<Context>::FunctionParser): need function index space, not just internal functions
(JSC::Wasm::FunctionParser<Context>::parseExpression):

• wasm/WasmModuleParser.cpp: early-create some of the structures which will be needed later

(JSC::Wasm::ModuleParser::parseImport):
(JSC::Wasm::ModuleParser::parseFunction):
(JSC::Wasm::ModuleParser::parseMemory):
(JSC::Wasm::ModuleParser::parseExport):
(JSC::Wasm::ModuleParser::parseCode):

• wasm/WasmModuleParser.h:

(JSC::Wasm::ModuleParser::functionIndexSpace):
(JSC::Wasm::ModuleParser::functionLocations):

• wasm/WasmParser.h:

(JSC::Wasm::Parser::consumeUTF8String):

• wasm/WasmPlan.cpp: pass around the wasm objects at the right time, reducing their lifetime and making it easier to pass them around when needed

(JSC::Wasm::Plan::run):
(JSC::Wasm::Plan::initializeCallees):

• wasm/WasmPlan.h:

(JSC::Wasm::Plan::exports):
(JSC::Wasm::Plan::internalFunctionCount):
(JSC::Wasm::Plan::jsToWasmEntryPointForFunction):
(JSC::Wasm::Plan::takeModuleInformation):
(JSC::Wasm::Plan::takeCallLinkInfos):
(JSC::Wasm::Plan::takeWasmToJSStubs):
(JSC::Wasm::Plan::takeFunctionIndexSpace):

• wasm/WasmValidate.cpp: check function index space instead of only internal functions

(JSC::Wasm::Validate::addCall):
(JSC::Wasm::validateFunction):

• wasm/WasmValidate.h:
• wasm/js/JSWebAssemblyCallee.cpp:

(JSC::JSWebAssemblyCallee::finishCreation):

• wasm/js/JSWebAssemblyCallee.h:

(JSC::JSWebAssemblyCallee::create):
(JSC::JSWebAssemblyCallee::jsToWasmEntryPoint):

• wasm/js/JSWebAssemblyInstance.cpp:

(JSC::JSWebAssemblyInstance::create):
(JSC::JSWebAssemblyInstance::JSWebAssemblyInstance):
(JSC::JSWebAssemblyInstance::visitChildren):

• wasm/js/JSWebAssemblyInstance.h: hold the import functions off the end of the Instance

(JSC::JSWebAssemblyInstance::importFunction):
(JSC::JSWebAssemblyInstance::importFunctions):
(JSC::JSWebAssemblyInstance::setImportFunction):
(JSC::JSWebAssemblyInstance::offsetOfImportFunctions):
(JSC::JSWebAssemblyInstance::offsetOfImportFunction):
(JSC::JSWebAssemblyInstance::allocationSize):

• wasm/js/JSWebAssemblyModule.cpp:

(JSC::JSWebAssemblyModule::create):
(JSC::JSWebAssemblyModule::JSWebAssemblyModule):
(JSC::JSWebAssemblyModule::visitChildren):

• wasm/js/JSWebAssemblyModule.h: hold the link call info, the import function stubs, and the function index space

(JSC::JSWebAssemblyModule::signatureForFunctionIndexSpace):
(JSC::JSWebAssemblyModule::importCount):
(JSC::JSWebAssemblyModule::calleeFromFunctionIndexSpace):

• wasm/js/WebAssemblyFunction.cpp:

(JSC::callWebAssemblyFunction): set top Instance on VM

• wasm/js/WebAssemblyFunction.h:

(JSC::WebAssemblyFunction::instance):

• wasm/js/WebAssemblyInstanceConstructor.cpp:

(JSC::constructJSWebAssemblyInstance): handle function imports

• wasm/js/WebAssemblyModuleConstructor.cpp:

(JSC::constructJSWebAssemblyModule): generate the stubs for import functions

• wasm/js/WebAssemblyModuleRecord.cpp:

(JSC::WebAssemblyModuleRecord::link):

• wasm/js/WebAssemblyToJSCallee.cpp: Copied from Source/JavaScriptCore/wasm/js/JSWebAssemblyCallee.cpp.

(JSC::WebAssemblyToJSCallee::create): dummy JSCell singleton which lives on the VM, and is put as the callee in the import stub's frame to identified it when unwinding
(JSC::WebAssemblyToJSCallee::createStructure):
(JSC::WebAssemblyToJSCallee::WebAssemblyToJSCallee):
(JSC::WebAssemblyToJSCallee::finishCreation):
(JSC::WebAssemblyToJSCallee::destroy):

• wasm/js/WebAssemblyToJSCallee.h: Copied from Source/JavaScriptCore/wasm/WasmB3IRGenerator.h.

File:

• trunk/Source/JavaScriptCore/wasm/WasmPlan.cpp (modified) (6 diffs)

trunk/Source/JavaScriptCore/wasm/WasmPlan.cpp

@@ -34 +34 @@
 #include "JSWebAssemblyCallee.h"
 #include "WasmB3IRGenerator.h"
+#include "WasmBinding.h"
 #include "WasmCallingConvention.h"
 #include "WasmMemory.h"
@@ -39 +40 @@
 #include "WasmValidate.h"
 #include <wtf/DataLog.h>
+#include <wtf/StdLibExtras.h>
 #include <wtf/text/StringBuilder.h>
 
@@ -70 +72 @@
         }
         m_moduleInformation = WTFMove(moduleParser.moduleInformation());
+        m_functionLocationInBinary = WTFMove(moduleParser.functionLocationInBinary());
+        m_functionIndexSpace = WTFMove(moduleParser.functionIndexSpace());
     }
     if (verbose)
         dataLogLn("Parsed module.");
 
-    if (!m_compiledFunctions.tryReserveCapacity(m_moduleInformation->functions.size())) {
-        StringBuilder builder;
-        builder.appendLiteral("Failed allocating enough space for ");
-        builder.appendNumber(m_moduleInformation->functions.size());
-        builder.appendLiteral(" compiled functions");
-        m_errorMessage = builder.toString();
+    auto tryReserveCapacity = [this] (auto& vector, size_t size, const char* what) {
+        if (UNLIKELY(!vector.tryReserveCapacity(size))) {
+            StringBuilder builder;
+            builder.appendLiteral("Failed allocating enough space for ");
+            builder.appendNumber(size);
+            builder.append(what);
+            m_errorMessage = builder.toString();
+            return false;
+        }
+        return true;
+    };
+    Vector<Vector<UnlinkedWasmToWasmCall>> unlinkedWasmToWasmCalls;
+    if (!tryReserveCapacity(m_wasmToJSStubs, m_moduleInformation->importFunctions.size(), " WebAssembly to JavaScript stubs")
+        || !tryReserveCapacity(unlinkedWasmToWasmCalls, m_functionLocationInBinary.size(), " unlinked WebAssembly to WebAssembly calls")
+        || !tryReserveCapacity(m_wasmInternalFunctions, m_functionLocationInBinary.size(), " WebAssembly functions"))
         return;
+
+    for (unsigned importIndex = 0; importIndex < m_moduleInformation->imports.size(); ++importIndex) {
+        Import* import = &m_moduleInformation->imports[importIndex];
+        if (import->kind != External::Function)
+            continue;
+        unsigned importFunctionIndex = m_wasmToJSStubs.size();
+        if (verbose)
+            dataLogLn("Processing import function number ", importFunctionIndex, ": ", import->module, ": ", import->field);
+        Signature* signature = m_moduleInformation->importFunctions.at(import->kindIndex);
+        m_wasmToJSStubs.uncheckedAppend(importStubGenerator(m_vm, m_callLinkInfos, signature, importFunctionIndex));
+        m_functionIndexSpace[importFunctionIndex].code = m_wasmToJSStubs[importFunctionIndex].code().executableAddress();
     }
 
-    for (const FunctionInformation& info : m_moduleInformation->functions) {
+    for (unsigned functionIndex = 0; functionIndex < m_functionLocationInBinary.size(); ++functionIndex) {
         if (verbose)
-            dataLogLn("Processing function starting at: ", info.start, " and ending at: ", info.end);
-        const uint8_t* functionStart = m_source + info.start;
-        size_t functionLength = info.end - info.start;
+            dataLogLn("Processing function starting at: ", m_functionLocationInBinary[functionIndex].start, " and ending at: ", m_functionLocationInBinary[functionIndex].end);
+        const uint8_t* functionStart = m_source + m_functionLocationInBinary[functionIndex].start;
+        size_t functionLength = m_functionLocationInBinary[functionIndex].end - m_functionLocationInBinary[functionIndex].start;
         ASSERT(functionLength <= m_sourceLength);
+        Signature* signature = m_moduleInformation->internalFunctionSignatures[functionIndex];
+        unsigned functionIndexSpace = m_wasmToJSStubs.size() + functionIndex;
+        ASSERT(m_functionIndexSpace[functionIndexSpace].signature == signature);
 
-        String error = validateFunction(functionStart, functionLength, info.signature, m_moduleInformation->functions);
+        String error = validateFunction(functionStart, functionLength, signature, m_functionIndexSpace);
         if (!error.isNull()) {
             if (verbose) {
@@ -101 +128 @@
         }
 
-        m_compiledFunctions.uncheckedAppend(parseAndCompile(*m_vm, functionStart, functionLength, m_moduleInformation->memory.get(), info.signature, m_moduleInformation->functions));
+        unlinkedWasmToWasmCalls.uncheckedAppend(Vector<UnlinkedWasmToWasmCall>());
+        m_wasmInternalFunctions.uncheckedAppend(parseAndCompile(*m_vm, functionStart, functionLength, m_moduleInformation->memory.get(), signature, unlinkedWasmToWasmCalls.at(functionIndex), m_functionIndexSpace));
+        m_functionIndexSpace[functionIndexSpace].code = m_wasmInternalFunctions[functionIndex]->code->code().executableAddress();
     }
 
-    // Patch the call sites for each function.
-    for (std::unique_ptr<FunctionCompilation>& functionPtr : m_compiledFunctions) {
-        FunctionCompilation* function = functionPtr.get();
-        for (auto& call : function->unlinkedCalls)
-            MacroAssembler::repatchCall(call.callLocation, CodeLocationLabel(m_compiledFunctions[call.functionIndex]->code->code()));
+    // Patch the call sites for each WebAssembly function.
+    for (auto& unlinked : unlinkedWasmToWasmCalls) {
+        for (auto& call : unlinked)
+            MacroAssembler::repatchCall(call.callLocation, CodeLocationLabel(m_functionIndexSpace[call.functionIndex].code));
     }
 
@@ -117 +145 @@
 {
     ASSERT(!failed());
-    for (unsigned i = 0; i < m_compiledFunctions.size(); i++) {
-        std::unique_ptr<FunctionCompilation>& compilation = m_compiledFunctions[i];
-        CodeLocationDataLabelPtr calleeMoveLocation = compilation->calleeMoveLocation;
-        JSWebAssemblyCallee* callee = JSWebAssemblyCallee::create(globalObject->vm(), WTFMove(compilation));
+    for (unsigned internalFunctionIndex = 0; internalFunctionIndex < m_wasmInternalFunctions.size(); ++internalFunctionIndex) {
+        WasmInternalFunction* function = m_wasmInternalFunctions[internalFunctionIndex].get();
+        CodeLocationDataLabelPtr calleeMoveLocation = function->calleeMoveLocation;
+        JSWebAssemblyCallee* callee = JSWebAssemblyCallee::create(globalObject->vm(), WTFMove(function->code), WTFMove(function->jsToWasmEntryPoint));
 
         MacroAssembler::repatchPointer(calleeMoveLocation, callee);
@@ -127 +155 @@
             dataLogLn("Made Wasm callee: ", RawPointer(callee));
 
-        callback(i, callee);
+        callback(internalFunctionIndex, callee);
     }
 }