Fuzzing: Update FuzzTranslator to instantiate modules explicitly

Author: kateinoigakukun

FuzzTesting/Sources/FuzzTranslator/FuzzTranslator.swift

@@ -5,7 +5,28 @@ 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 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
+                    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 {
         // 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

@@ -23,6 +23,7 @@ final class FuzzTranslatorRegressionTests: XCTestCase {
                     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
                             fatalError("unreachable")