Changeset 209630 in webkit for trunk/Source/JavaScriptCore/wasm/WasmModuleParser.cpp

Timestamp:

Dec 9, 2016, 2:38:39 PM (9 years ago)

Author:

[email protected]

Message:

WebAssembly JS API: implement importing and defining Memory
​https://bugs.webkit.org/show_bug.cgi?id=164134

Reviewed by Keith Miller.

JSTests:

• wasm/Builder.js:

(const._importMemoryContinuation.section):
(const._importMemoryContinuation.assert):
(const._importMemoryContinuation):
(const._exportFunctionContinuation.const): Deleted.
(const._exportFunctionContinuation): Deleted.

• wasm/Builder_WebAssemblyBinary.js:

(const.emitters.Import):

• wasm/js-api/test_basic_api.js:

(const.c.in.constructorProperties.switch):

• wasm/js-api/test_memory.js: Added.

(assert):
(binaryShouldNotParse):
(test):
(test.testMemImportError):

• wasm/js-api/test_memory_constructor.js: Added.

(assert):
(throw.new.Error):
(testInvalidSize):
(assert.testInvalidInitial):
(testInvalidInitial.testInvalidMaximum):
(testInvalidInitial):
(testInvalidMaximum):

• wasm/self-test/test_BuilderJSON.js:

Source/JavaScriptCore:

This patch implements the WebAssembly.Memory object. It refactors
the code to now associate a Memory with the instance instead of
the Module.

• CMakeLists.txt:
• JavaScriptCore.xcodeproj/project.pbxproj:
• jsc.cpp:

(functionTestWasmModuleFunctions):

• runtime/VM.h:
• shell/CMakeLists.txt:
• testWasm.cpp: Removed.

This has bitrotted. I'm removing it.

• wasm/WasmB3IRGenerator.cpp:

(JSC::Wasm::B3IRGenerator::B3IRGenerator):
(JSC::Wasm::sizeOfLoadOp):
(JSC::Wasm::createJSToWasmWrapper):
(JSC::Wasm::parseAndCompile):

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

(JSC::Wasm::ModuleInformation::~ModuleInformation): Deleted.

• wasm/WasmFormat.h:
• wasm/WasmMemory.cpp:

(JSC::Wasm::Memory::Memory):

• wasm/WasmMemory.h:

(JSC::Wasm::Memory::size):
(JSC::Wasm::Memory::initial):
(JSC::Wasm::Memory::maximum):
(JSC::Wasm::Memory::pinnedRegisters): Deleted.

• wasm/WasmMemoryInformation.cpp: Added.

(JSC::Wasm::MemoryInformation::MemoryInformation):

• wasm/WasmMemoryInformation.h: Added.

(JSC::Wasm::MemoryInformation::MemoryInformation):
(JSC::Wasm::MemoryInformation::pinnedRegisters):
(JSC::Wasm::MemoryInformation::initial):
(JSC::Wasm::MemoryInformation::maximum):
(JSC::Wasm::MemoryInformation::isImport):
(JSC::Wasm::MemoryInformation::operator bool):

• wasm/WasmModuleParser.cpp:

(JSC::Wasm::ModuleParser::parseImport):
(JSC::Wasm::ModuleParser::parseMemoryHelper):
(JSC::Wasm::ModuleParser::parseMemory):
(JSC::Wasm::ModuleParser::parseExport):

• wasm/WasmModuleParser.h:
• wasm/WasmPageCount.h: Added. Implement a new way of describing Wasm

pages and then asking for how many bytes a quantity of pages is. This
class also makes it clear when we're talking about bytes or pages.

(JSC::Wasm::PageCount::PageCount):
(JSC::Wasm::PageCount::bytes):
(JSC::Wasm::PageCount::isValid):
(JSC::Wasm::PageCount::max):
(JSC::Wasm::PageCount::operator bool):
(JSC::Wasm::PageCount::operator<):
(JSC::Wasm::PageCount::operator>):
(JSC::Wasm::PageCount::operator>=):

• wasm/WasmPlan.cpp:

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

• wasm/WasmPlan.h:

(JSC::Wasm::Plan::memory): Deleted.

• wasm/WasmValidate.cpp:

(JSC::Wasm::Validate::hasMemory):
(JSC::Wasm::Validate::Validate):
(JSC::Wasm::validateFunction):

• wasm/WasmValidate.h:
• wasm/generateWasmValidateInlinesHeader.py:
• wasm/js/JSWebAssemblyInstance.cpp:

(JSC::JSWebAssemblyInstance::visitChildren):

• wasm/js/JSWebAssemblyInstance.h:

(JSC::JSWebAssemblyInstance::memory):
(JSC::JSWebAssemblyInstance::setMemory):
(JSC::JSWebAssemblyInstance::offsetOfImportFunctions):
(JSC::JSWebAssemblyInstance::allocationSize):

• wasm/js/JSWebAssemblyMemory.cpp:

(JSC::JSWebAssemblyMemory::create):
(JSC::JSWebAssemblyMemory::JSWebAssemblyMemory):
(JSC::JSWebAssemblyMemory::buffer):
(JSC::JSWebAssemblyMemory::visitChildren):

• wasm/js/JSWebAssemblyMemory.h:

(JSC::JSWebAssemblyMemory::memory):

• wasm/js/WebAssemblyFunction.cpp:

(JSC::callWebAssemblyFunction):

• wasm/js/WebAssemblyInstanceConstructor.cpp:

Handle importing and creating of memory according
to the spec. This also does the needed validation
of making sure the memory defined in the module
is compatible with the imported memory.

(JSC::constructJSWebAssemblyInstance):

• wasm/js/WebAssemblyMemoryConstructor.cpp:

(JSC::constructJSWebAssemblyMemory):
(JSC::callJSWebAssemblyMemory):

• wasm/js/WebAssemblyMemoryPrototype.cpp:

(JSC::webAssemblyMemoryProtoFuncBuffer):
(JSC::WebAssemblyMemoryPrototype::create):
(JSC::WebAssemblyMemoryPrototype::finishCreation):

• wasm/js/WebAssemblyMemoryPrototype.h:
• wasm/js/WebAssemblyModuleRecord.cpp:

(JSC::WebAssemblyModuleRecord::finishCreation):
(JSC::WebAssemblyModuleRecord::link):

File:

• trunk/Source/JavaScriptCore/wasm/WasmModuleParser.cpp (modified) (5 diffs)

trunk/Source/JavaScriptCore/wasm/WasmModuleParser.cpp

@@ -31 +31 @@
 #include "IdentifierInlines.h"
 #include "WasmFormat.h"
-#include "WasmMemory.h"
+#include "WasmMemoryInformation.h"
 #include "WasmOps.h"
 #include "WasmSections.h"
@@ -257 +257 @@
         }
         case External::Memory: {
-            // FIXME https://bugs.webkit.org/show_bug.cgi?id=164134
+            bool isImport = true;
+            if (!parseMemoryHelper(isImport))
+                return false;
             break;
         }
@@ -306 +308 @@
 }
 
+bool ModuleParser::parseMemoryHelper(bool isImport)
+{
+    // We don't allow redeclaring memory. Either via import or definition.
+    if (m_module->memory)
+        return false;
+
+    uint8_t flags;
+    if (!parseVarUInt1(flags))
+        return false;
+
+    uint32_t initial;
+    if (!parseVarUInt32(initial))
+        return false;
+
+    if (!PageCount::isValid(initial))
+        return false;
+
+    PageCount initialPageCount(initial);
+
+    PageCount maximumPageCount;
+    if (flags) {
+        uint32_t maximum;
+        if (!parseVarUInt32(maximum))
+            return false;
+
+        if (!PageCount::isValid(maximum))
+            return false;
+
+        maximumPageCount = PageCount(maximum);
+        if (initialPageCount > maximumPageCount)
+            return false;
+    }
+
+    Vector<unsigned> pinnedSizes = { 0 };
+    m_module->memory = MemoryInformation(initialPageCount, maximumPageCount, pinnedSizes, isImport);
+    return true;
+}
+
 bool ModuleParser::parseMemory()
 {
@@ -315 +355 @@
         return true;
 
-    uint8_t flags;
-    uint32_t size;
-    if (!parseVarUInt1(flags)
-        || !parseVarUInt32(size)
-        || size > maxPageCount)
-        return false;
-
-    uint32_t capacity = maxPageCount;
-    if (flags) {
-        if (!parseVarUInt32(capacity)
-            || size > capacity
-            || capacity > maxPageCount)
-            return false;
-    }
-
-    capacity *= pageSize;
-    size *= pageSize;
-
-    Vector<unsigned> pinnedSizes = { 0 };
-    m_module->memory = std::make_unique<Memory>(size, capacity, pinnedSizes);
-    return m_module->memory->memory();
+    // We only allow one memory for now.
+    if (count != 1)
+        return false;
+
+    bool isImport = false;
+    return parseMemoryHelper(isImport);
 }
 
@@ -373 +398 @@
         }
         case External::Memory: {
-            // FIXME https://bugs.webkit.org/show_bug.cgi?id=164134
+            // FIXME: https://bugs.webkit.org/show_bug.cgi?id=165671
             break;
         }