Validation: Add memory type validation

Author: kateinoigakukun

Sources/WasmKit/Execution/Instances.swift

@@ -418,6 +418,10 @@ public struct Table: Equatable {
 struct MemoryEntity /* : ~Copyable */ {
     static let pageSize = 64 * 1024
 
+    static func maxPageCount(isMemory64: Bool) -> UInt64 {
+        isMemory64 ? UInt64.max : UInt64(1 << 32) / UInt64(pageSize)
+    }
+
     var data: [UInt8]
     let maxPageCount: UInt64
     let limit: Limits
@@ -428,7 +432,7 @@ struct MemoryEntity /* : ~Copyable */ {
             throw Trap._raw("Initial memory size exceeds the resource limit: \(byteSize) bytes")
         }
         data = Array(repeating: 0, count: byteSize)
-        let defaultMaxPageCount = (memoryType.isMemory64 ? UInt64.max : UInt64(UInt32.max)) / UInt64(Self.pageSize)
+        let defaultMaxPageCount = Self.maxPageCount(isMemory64: memoryType.isMemory64)
         maxPageCount = memoryType.max ?? defaultMaxPageCount
         limit = memoryType
     }

Sources/WasmKit/Module.swift

@@ -129,7 +129,7 @@ public struct Module {
     /// > Note:
     /// <https://webassembly.github.io/spec/core/exec/modules.html#instantiation>
     private func instantiateHandle(store: Store, imports: Imports) throws -> InternalInstance {
-        try ModuleValidator().validate(self)
+        try ModuleValidator(module: self).validate()
 
         // Steps 5-8.
 

Sources/WasmKit/Validator.swift

@@ -35,9 +35,50 @@ struct InstructionValidator {
 }
 
 struct ModuleValidator {
-    func validate(_ module: Module) throws {
+    let module: Module
+    init(module: Module) {
+        self.module = module
+    }
+
+    func validate() throws {
         if module.memoryTypes.count > 1 {
             throw ValidationError("Multiple memories are not permitted")
         }
+        for memoryType in module.memoryTypes {
+            try Self.checkMemoryType(memoryType, features: module.features)
+        }
+    }
+
+    static func checkMemoryType(_ type: MemoryType, features: WasmFeatureSet) throws {
+        try checkLimit(type)
+
+        if type.isMemory64 {
+            guard features.contains(.memory64) else {
+                throw ValidationError("memory64 feature is required for 64-bit memories")
+            }
+        }
+
+        let hardMax = MemoryEntity.maxPageCount(isMemory64: type.isMemory64)
+
+        if type.min > hardMax {
+            throw ValidationError("size minimum must not be greater than \(hardMax)")
+        }
+
+        if let max = type.max, max > hardMax {
+            throw ValidationError("size maximum must not be greater than \(hardMax)")
+        }
+
+        if type.shared {
+            guard features.contains(.threads) else {
+                throw ValidationError("reference-types feature is required for shared memories")
+            }
+        }
+    }
+
+    private static func checkLimit(_ limit: Limits) throws {
+        guard let max = limit.max else { return }
+        if limit.min > max {
+            throw ValidationError("size minimum must not be greater than maximum")
+        }
     }
 }

Tests/WasmKitTests/SpectestTests.swift

@@ -22,8 +22,6 @@ final class SpectestTests: XCTestCase {
             path: Self.testPaths,
             include: [],
             exclude: [
-                "loop.wast",
-                "memory.wast",
                 "memory_grow.wast",
                 "memory_size.wast",
                 "proposals/memory64/align64.wast",