Validation: Check global mutability and types

Author: kateinoigakukun

Sources/WasmKit/Execution/ConstEvaluation.swift

@@ -34,7 +34,13 @@ struct ConstEvaluationContext: ConstEvaluationContextProtocol {
 }
 
 extension ConstExpression {
-    func evaluate<C: ConstEvaluationContextProtocol>(context: C) throws -> Value {
+    func evaluate<C: ConstEvaluationContextProtocol>(context: C, expectedType: WasmTypes.ValueType) throws -> Value {
+        let result = try self._evaluate(context: context)
+        try result.checkType(expectedType)
+        return result
+    }
+
+    private func _evaluate<C: ConstEvaluationContextProtocol>(context: C) throws -> Value {
         guard self.last == .end, self.count == 2 else {
             throw InstantiationError.unsupported("Expect `end` at the end of offset expression")
         }
@@ -101,3 +107,18 @@ fileprivate extension WasmTypes.Reference {
         }
     }
 }
+
+fileprivate extension Value {
+    func checkType(_ type: WasmTypes.ValueType) throws {
+        switch (self, type) {
+        case (.i32, .i32): return
+        case (.i64, .i64): return
+        case (.f32, .f32): return
+        case (.f64, .f64): return
+        case (.ref(let ref), .ref(let refType)):
+            try ref.checkType(refType)
+        default:
+            throw ValidationError("Expect \(type) but got \(self)")
+        }
+    }
+}

Sources/WasmKit/Execution/StoreAllocator.swift

@@ -361,16 +361,17 @@ extension StoreAllocator {
         )
 
         // Step 5.
-        var constEvalContext = ConstEvaluationContext(
+        let constEvalContext = ConstEvaluationContext(
             functions: functions,
             globals: importedGlobals.map(\.value)
         )
         let globals = try allocateEntities(
             imports: importedGlobals,
             internals: module.globals,
             allocateHandle: { global, i in
-                let initialValue = try global.initializer.evaluate(context: constEvalContext)
-                constEvalContext.globals.append(initialValue)
+                let initialValue = try global.initializer.evaluate(
+                    context: constEvalContext, expectedType: global.type.valueType
+                )
                 return allocate(globalType: global.type, initialValue: initialValue)
             }
         )

Sources/WasmKit/Module.swift

@@ -154,8 +154,11 @@ public struct Module {
         do {
             for element in elements {
                 guard case let .active(tableIndex, offset) = element.mode else { continue }
-                let offsetValue = try offset.evaluate(context: constEvalContext)
                 let table = try instance.tables[validating: Int(tableIndex)]
+                let offsetValue = try offset.evaluate(
+                    context: constEvalContext,
+                    expectedType: .addressType(isMemory64: table.limits.isMemory64)
+                )
                 try table.withValue { table in
                     guard let offset = offsetValue.maybeAddressOffset(table.limits.isMemory64) else {
                         throw InstantiationError.unsupported(
@@ -182,8 +185,11 @@ public struct Module {
         // Step 16.
         do {
             for case let .active(data) in data {
-                let offsetValue = try data.offset.evaluate(context: constEvalContext)
                 let memory = try instance.memories[validating: Int(data.index)]
+                let offsetValue = try data.offset.evaluate(
+                    context: constEvalContext,
+                    expectedType: .addressType(isMemory64: memory.limit.isMemory64)
+                )
                 try memory.withValue { memory in
                     guard let offset = offsetValue.maybeAddressOffset(memory.limit.isMemory64) else {
                         throw InstantiationError.unsupported(

Sources/WasmKit/Translator.swift

@@ -1537,6 +1537,7 @@ struct InstructionTranslator<Context: TranslatorContext>: InstructionVisitor {
             // Skip actual code emission if validation-only mode
             return
         }
+        try validator.validateGlobalSet(global.globalType)
         emit(.globalSet(Instruction.GlobalAndVRegOperand(reg: LLVReg(value), global: global)))
     }
 

Sources/WasmKit/Validator.swift

@@ -14,4 +14,13 @@ struct InstructionValidator {
             throw ValidationError("Alignment 2**\(memarg.align) is out of limit \(naturalAlignment)")
         }
     }
+
+    func validateGlobalSet(_ type: GlobalType) throws {
+        switch type.mutability {
+        case .constant:
+            throw ValidationError("Cannot set a constant global")
+        case .variable:
+            break
+        }
+    }
 }

Tests/WasmKitTests/SpectestTests.swift

@@ -22,7 +22,6 @@ final class SpectestTests: XCTestCase {
             path: Self.testPaths,
             include: [],
             exclude: [
-                "global.wast",
                 "if.wast",
                 "imports.wast",
                 "labels.wast",