Fuzzing: Update FuzzTranslator to instantiate modules explicitly

Author: kateinoigakukun

FuzzTesting/Sources/FuzzTranslator/FuzzTranslator.swift

@@ -4,8 +4,31 @@ import WasmKit
 public func FuzzCheck(_ start: UnsafePointer<UInt8>, _ count: Int) -> CInt {
     let bytes = Array(UnsafeBufferPointer(start: start, count: count))
     do {
-        var module = try WasmKit.parseWasm(bytes: bytes)
-        try module.materializeAll()
+        let module = try WasmKit.parseWasm(bytes: bytes)
+        let engine = Engine(configuration: EngineConfiguration(compilationMode: .eager))
+        let store = Store(engine: engine)
+        var imports = Imports()
+        for importEntry in module.imports {
+            let value: ExternalValueConvertible
+            switch importEntry.descriptor {
+            case .function(let typeIndex):
+                guard typeIndex < module.types.count else { return 0 }
+                let type = module.types[Int(typeIndex)]
+                value = Function(store: store, type: type) { _, _ in
+                    // Provide "start function" with empty results
+                    if type.results.isEmpty { return [] }
+                    fatalError("Unexpected function call")
+                }
+            case .global(let globalType):
+                value = try Global(store: store, type: globalType, value: .i32(0))
+            case .memory(let memoryType):
+                value = try Memory(store: store, type: memoryType)
+            case .table(let tableType):
+                value = try Table(store: store, type: tableType)
+            }
+            imports.define(module: importEntry.module, name: importEntry.name, value.externalValue)
+        }
+        _ = try module.instantiate(store: store, imports: imports)
     } catch {
         // Ignore errors
     }

Sources/WasmKit/Module.swift

@@ -227,13 +227,8 @@ public struct Module {
     }
 
     /// Materialize lazily-computed elements in this module
-    public mutating func materializeAll() throws {
-        let allocator = ISeqAllocator()
-        let funcTypeInterner = Interner<FunctionType>()
-        for function in functions {
-            _ = try function.compile(module: self, funcTypeInterner: funcTypeInterner, allocator: allocator)
-        }
-    }
+    @available(*, deprecated, message: "Module materialization is no longer supported. Instantiate the module explicitly instead.")
+    public mutating func materializeAll() throws {}
 }
 
 extension Module {
@@ -275,8 +270,4 @@ typealias LabelIndex = UInt32
 struct GuestFunction {
     let type: FunctionType
     let code: Code
-
-    func compile(module: Module, funcTypeInterner: Interner<FunctionType>, allocator: ISeqAllocator) throws -> InstructionSequence {
-        throw TranslationError("Compile without instantiation is no longer supported")
-    }
 }

Tests/WasmKitTests/FuzzTranslatorRegressionTests.swift

@@ -2,7 +2,7 @@ import WasmKit
 import XCTest
 
 final class FuzzTranslatorRegressionTests: XCTestCase {
-    func testRunAll() async throws {
+    func testRunAll() throws {
         let sourceRoot = URL(fileURLWithPath: #filePath)
             .deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent()
         let failCasesDir =
@@ -12,34 +12,40 @@ final class FuzzTranslatorRegressionTests: XCTestCase {
         for file in try FileManager.default.contentsOfDirectory(atPath: failCasesDir.path) {
             let path = failCasesDir.appendingPathComponent(file).path
             print("Fuzz regression test: \(path.dropFirst(sourceRoot.path.count + 1))")
-
-            let data = try Data(contentsOf: URL(fileURLWithPath: path))
-            do {
-                let module = try WasmKit.parseWasm(bytes: Array(data))
-                let engine = Engine(configuration: EngineConfiguration(compilationMode: .eager))
-                let store = Store(engine: engine)
-                var imports = Imports()
-                for importEntry in module.imports {
-                    let value: ExternalValueConvertible
-                    switch importEntry.descriptor {
-                    case .function(let typeIndex):
-                        let type = module.types[Int(typeIndex)]
-                        value = Function(store: store, type: type) { _, _ in
-                            fatalError("unreachable")
-                        }
-                    case .global(let globalType):
-                        value = try Global(store: store, type: globalType, value: .i32(0))
-                    case .memory(let memoryType):
-                        value = try Memory(store: store, type: memoryType)
-                    case .table(let tableType):
-                        value = try Table(store: store, type: tableType)
-                    }
-                    imports.define(module: importEntry.module, name: importEntry.name, value.externalValue)
-                }
-                _ = try module.instantiate(store: store, imports: imports)
-            } catch {
-                // Explicit errors are ok
-            }
+            try checkFuzzCase(path: path)
         }
     }
+
+    func checkFuzzCase(path: String) throws {
+       let data = try Data(contentsOf: URL(fileURLWithPath: path))
+       do {
+           let module = try WasmKit.parseWasm(bytes: Array(data))
+           let engine = Engine(configuration: EngineConfiguration(compilationMode: .eager))
+           let store = Store(engine: engine)
+           var imports = Imports()
+           for importEntry in module.imports {
+               let value: ExternalValueConvertible
+               switch importEntry.descriptor {
+               case .function(let typeIndex):
+                   guard typeIndex < module.types.count else { return } 
+                   let type = module.types[Int(typeIndex)]
+                   value = Function(store: store, type: type) { _, _ in
+                       // Provide "start function" with empty results
+                       if type.results.isEmpty { return [] }
+                       fatalError("Unexpected function call")
+                   }
+               case .global(let globalType):
+                   value = try Global(store: store, type: globalType, value: .i32(0))
+               case .memory(let memoryType):
+                   value = try Memory(store: store, type: memoryType)
+               case .table(let tableType):
+                   value = try Table(store: store, type: tableType)
+               }
+               imports.define(module: importEntry.module, name: importEntry.name, value.externalValue)
+           }
+           _ = try module.instantiate(store: store, imports: imports)
+       } catch {
+           // Explicit errors are ok
+       }
+    }
 }