Engine API: Migrate fuzzing targets

Author: kateinoigakukun

FuzzTesting/Sources/FuzzDifferential/FuzzDifferential.swift

@@ -92,9 +92,10 @@ extension wasm_name_t {
 struct WasmKitEngine: Engine {
     func run(moduleBytes: [UInt8]) throws -> ExecResult {
         let module = try WasmKit.parseWasm(bytes: moduleBytes)
-        let runtime = Runtime()
-        let instance = try runtime.instantiate(module: module)
-        let exports = instance.exports.sorted(by: { $0.key < $1.key })
+        let engine = WasmKit.Engine()
+        let store = WasmKit.Store(engine: engine)
+        let instance = try module.instantiate(store: store)
+        let exports = instance.exports.sorted(by: { $0.name < $1.name })
         let memories: [Memory] = exports.compactMap {
             guard case let .memory(memory) = $0.value else {
                 return nil
@@ -117,7 +118,7 @@ struct WasmKitEngine: Engine {
         let type = fn.type
         let arguments = type.parameters.map { $0.defaultValue }
         do {
-            let results = try fn.invoke(arguments, runtime: runtime)
+            let results = try fn(arguments)
             return ExecResult(values: results, trap: nil, memory: memory?.data)
         } catch {
             return ExecResult(values: nil, trap: String(describing: error), memory: memory?.data)

FuzzTesting/Sources/FuzzExecute/FuzzExecute.swift

@@ -14,16 +14,17 @@ public func FuzzCheck(_ start: UnsafePointer<UInt8>, _ count: Int) -> CInt {
     let bytes = Array(UnsafeBufferPointer(start: start, count: count))
     do {
         let module = try WasmKit.parseWasm(bytes: bytes)
-        let runtime = WasmKit.Runtime()
-        runtime.store.resourceLimiter = FuzzerResourceLimiter()
-        let instance = try runtime.instantiate(module: module)
+        let engine = WasmKit.Engine()
+        let store = WasmKit.Store(engine: engine)
+        store.resourceLimiter = FuzzerResourceLimiter()
+        let instance = try module.instantiate(store: store)
         for export in instance.exports.values {
             guard case let .function(fn) = export else {
                 continue
             }
             let type = fn.type
             let arguments = type.parameters.map { $0.defaultValue }
-            _ = try fn.invoke(arguments, runtime: runtime)
+            _ = try fn(arguments)
         }
     } catch {
         // Ignore errors

Sources/WasmKit/Execution/Instances.swift

@@ -85,11 +85,16 @@ typealias InternalInstance = EntityHandle<InstanceEntity>
 /// A map of exported entities by name.
 public struct Exports: Sequence {
     let store: Store
-    let values: [String: InternalExternalValue]
+    let items: [String: InternalExternalValue]
+
+    /// A collection of exported entities without their names.
+    public var values: [ExternalValue] {
+        self.map { $0.value }
+    }
 
     /// Returns the exported entity with the given name.
     public subscript(_ name: String) -> ExternalValue? {
-        guard let entity = values[name] else { return nil }
+        guard let entity = items[name] else { return nil }
         return ExternalValue(handle: entity, store: store)
     }
 
@@ -123,10 +128,10 @@ public struct Exports: Sequence {
 
         init(parent: Exports) {
             self.store = parent.store
-            self.iterator = parent.values.makeIterator()
+            self.iterator = parent.items.makeIterator()
         }
 
-        public mutating func next() -> (String, ExternalValue)? {
+        public mutating func next() -> (name: String, value: ExternalValue)? {
             guard let (name, entity) = iterator.next() else { return nil }
             return (name, ExternalValue(handle: entity, store: store))
         }
@@ -170,7 +175,7 @@ public struct Instance {
 
     /// A dictionary of exported entities by name.
     public var exports: Exports {
-        Exports(store: store, values: handle.exports)
+        Exports(store: store, items: handle.exports)
     }
 
     /// Dumps the textual representation of all functions in the instance.

Sources/WasmKit/Execution/Runtime.swift

@@ -58,7 +58,7 @@ public final class Runtime {
             throw ImportError.moduleInstanceAlreadyRegistered(name)
         }
 
-        availableExports[name] = Dictionary(uniqueKeysWithValues: instance.exports)
+        availableExports[name] = Dictionary(uniqueKeysWithValues: instance.exports.map { ($0, $1) })
     }
 
     /// Legacy compatibility method to register a host module with a name.

Sources/WasmKit/Imports.swift

@@ -18,7 +18,7 @@ public struct Imports {
     ///   - module: The module name to be used for resolving the imports.
     ///   - values: The values to be imported keyed by their name.
     public mutating func define(module: String, _ values: Exports) {
-        definitions[module, default: [:]].merge(values, uniquingKeysWith: { _, new in new })
+        definitions[module, default: [:]].merge(values.map { ($0, $1) }, uniquingKeysWith: { _, new in new })
     }
 
     mutating func define(_ importEntry: Import, _ value: ExternalValue) {