Changeset 209830 in webkit for trunk/Source/JavaScriptCore/wasm/WasmValidate.cpp

Timestamp:

Dec 14, 2016, 1:29:14 PM (9 years ago)

Author:

[email protected]

Message:

WebAssembly JS API: implement Global
​https://bugs.webkit.org/show_bug.cgi?id=164133

Reviewed by Saam Barati.

JSTests:

• wasm/Builder.js:

(export.default.Builder.prototype._registerSectionBuilders.switch.case.string_appeared_here.this.section):

• wasm/Builder_WebAssemblyBinary.js:

(const.valueType.WASM.description.type.i32.type.const.putGlobalType):
(const.putOp):
(const.putInitExpr):
(const.emitters.Import):
(const.emitters.Global):
(const.emitters.Export):
(const.emitters.Code):

• wasm/LowLevelBinary.js:

(export.default.LowLevelBinary.prototype.varuint32):
(export.default.LowLevelBinary.prototype.varint32):

• wasm/js-api/global-error.js: Added.

(catch):
(assert.truthy):

• wasm/js-api/global-external-init-from-import.js: Added.
• wasm/js-api/global-internal-init-from-import.js: Added.
• wasm/js-api/global-mutate.js: Added.

(createInternalGlobalModule):

• wasm/js-api/globals-export.js: Added.
• wasm/js-api/globals-import.js: Added.
• wasm/wasm.json:

Source/JavaScriptCore:

This patch adds support for globals. It handles imports, exports
and internal globals. In the MVP only internal globals are allowed
to be mutable. This means we can store a C-array of 64-bit slots
off the instance holding them. When globals are exported to JS
they are done so as numbers. This means that i64 globals cannot be
imported or exported.

• wasm/WasmB3IRGenerator.cpp:

(JSC::Wasm::B3IRGenerator::B3IRGenerator):
(JSC::Wasm::B3IRGenerator::getGlobal):
(JSC::Wasm::B3IRGenerator::setGlobal):
(JSC::Wasm::B3IRGenerator::addCallIndirect):
(JSC::Wasm::parseAndCompile):

• wasm/WasmFormat.h:
• wasm/WasmFunctionParser.h:

(JSC::Wasm::FunctionParser<Context>::parseExpression):

• wasm/WasmModuleParser.cpp:

(JSC::Wasm::ModuleParser::parseImport):
(JSC::Wasm::ModuleParser::parseGlobal):
(JSC::Wasm::ModuleParser::parseExport):
(JSC::Wasm::ModuleParser::parseElement):
(JSC::Wasm::ModuleParser::parseInitExpr):
(JSC::Wasm::ModuleParser::parseGlobalType):
(JSC::Wasm::ModuleParser::parseData):

• wasm/WasmModuleParser.h:
• wasm/WasmParser.h:

(JSC::Wasm::Parser::parseVarInt32):
(JSC::Wasm::Parser::parseVarInt64):
(JSC::Wasm::Parser::parseUInt64):

• wasm/WasmValidate.cpp:

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

• wasm/generateWasmOpsHeader.py:
• wasm/js/JSWebAssemblyInstance.cpp:

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

• wasm/js/JSWebAssemblyInstance.h:

(JSC::JSWebAssemblyInstance::loadI32Global):
(JSC::JSWebAssemblyInstance::loadI64Global):
(JSC::JSWebAssemblyInstance::loadF32Global):
(JSC::JSWebAssemblyInstance::loadF64Global):
(JSC::JSWebAssemblyInstance::setGlobal):
(JSC::JSWebAssemblyInstance::offsetOfGlobals):

• wasm/js/WebAssemblyInstanceConstructor.cpp:

(JSC::constructJSWebAssemblyInstance):

• wasm/js/WebAssemblyModuleRecord.cpp:

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

File:

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

trunk/Source/JavaScriptCore/wasm/WasmValidate.cpp

@@ -87 +87 @@
     bool WARN_UNUSED_RETURN setLocal(uint32_t index, ExpressionType value);
 
+    // Globals
+    bool WARN_UNUSED_RETURN getGlobal(uint32_t index, ExpressionType& result);
+    bool WARN_UNUSED_RETURN setGlobal(uint32_t index, ExpressionType value);
+
     // Memory
     bool WARN_UNUSED_RETURN load(LoadOpType, ExpressionType pointer, ExpressionType& result, uint32_t offset);
@@ -117 +121 @@
     void dump(const Vector<ControlEntry>& controlStack, const ExpressionList& expressionStack);
 
-    bool hasMemory() const { return !!m_memory; }
+    bool hasMemory() const { return !!m_module.memory; }
 
     void setErrorMessage(String&& message) { ASSERT(m_errorMessage.isNull()); m_errorMessage = WTFMove(message); }
     String errorMessage() const { return m_errorMessage; }
-    Validate(ExpressionType returnType, const MemoryInformation& memory)
+    Validate(ExpressionType returnType, const ModuleInformation& module)
         : m_returnType(returnType)
-        , m_memory(memory)
+        , m_module(module)
     {
     }
@@ -136 +140 @@
     Vector<Type> m_locals;
     String m_errorMessage;
-    const MemoryInformation& m_memory;
+    const ModuleInformation& m_module;
 };
 
@@ -178 +182 @@
 
     m_errorMessage = makeString("Attempt to set local with type: ", toString(localType), " with a variable of type: ", toString(value));
+    return false;
+}
+
+bool Validate::getGlobal(uint32_t index, ExpressionType& result)
+{
+    if (index < m_module.globals.size()) {
+        result = m_module.globals[index].type;
+        ASSERT(isValueType(result));
+        return true;
+    }
+    m_errorMessage = ASCIILiteral("Attempt to use unknown global.");
+    return false;
+}
+
+bool Validate::setGlobal(uint32_t index, ExpressionType value)
+{
+    if (index >= m_module.globals.size()) {
+        m_errorMessage = ASCIILiteral("Attempt to use unknown global.");
+        return false;
+    }
+
+    if (m_module.globals[index].mutability == Global::Immutable) {
+        m_errorMessage = ASCIILiteral("Attempt to store to immutable global.");
+        return false;
+    }
+
+    ExpressionType globalType = m_module.globals[index].type;
+    ASSERT(isValueType(globalType));
+    if (globalType == value)
+        return true;
+
+    m_errorMessage = makeString("Attempt to set global with type: ", toString(globalType), " with a variable of type: ", toString(value));
     return false;
 }
@@ -402 +438 @@
 }
 
-String validateFunction(const uint8_t* source, size_t length, const Signature* signature, const ImmutableFunctionIndexSpace& functionIndexSpace, const ModuleInformation& info)
-{
-    Validate context(signature->returnType, info.memory);
-    FunctionParser<Validate> validator(context, source, length, signature, functionIndexSpace, info);
+String validateFunction(const uint8_t* source, size_t length, const Signature* signature, const ImmutableFunctionIndexSpace& functionIndexSpace, const ModuleInformation& module)
+{
+    Validate context(signature->returnType, module);
+    FunctionParser<Validate> validator(context, source, length, signature, functionIndexSpace, module);
 
     if (!validator.parse()) {