Engine API: Split const evaluation into a separate file

This is a preparation for the future removal of Runtime.swift.

Author: kateinoigakukun

Sources/WasmKit/CMakeLists.txt

@@ -16,6 +16,7 @@ add_wasmkit_library(WasmKit
   Execution/Instructions/Memory.swift
   Execution/Instructions/Misc.swift
   Execution/Instructions/InstructionSupport.swift
+  Execution/ConstEvaluation.swift
   Execution/DispatchInstruction.swift
   Execution/EngineInterceptor.swift
   Execution/Errors.swift

Sources/WasmKit/Execution/ConstEvaluation.swift

@@ -0,0 +1,80 @@
+import WasmParser
+
+protocol ConstEvaluationContextProtocol {
+    func functionRef(_ index: FunctionIndex) throws -> Reference
+    func globalValue(_ index: GlobalIndex) throws -> Value
+}
+
+extension InternalInstance: ConstEvaluationContextProtocol {
+    func functionRef(_ index: FunctionIndex) throws -> Reference {
+        return try .function(from: self.functions[validating: Int(index)])
+    }
+    func globalValue(_ index: GlobalIndex) throws -> Value {
+        return try self.globals[validating: Int(index)].value
+    }
+}
+
+struct ConstEvaluationContext: ConstEvaluationContextProtocol {
+    let functions: ImmutableArray<InternalFunction>
+    var globals: [Value]
+    func functionRef(_ index: FunctionIndex) throws -> Reference {
+        return try .function(from: self.functions[validating: Int(index)])
+    }
+    func globalValue(_ index: GlobalIndex) throws -> Value {
+        guard index < globals.count else {
+            throw GlobalEntity.createOutOfBoundsError(index: Int(index), count: globals.count)
+        }
+        return self.globals[Int(index)]
+    }
+}
+
+extension ConstExpression {
+    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")
+        }
+        let constInst = self[0]
+        switch constInst {
+        case .i32Const(let value): return .i32(UInt32(bitPattern: value))
+        case .i64Const(let value): return .i64(UInt64(bitPattern: value))
+        case .f32Const(let value): return .f32(value.bitPattern)
+        case .f64Const(let value): return .f64(value.bitPattern)
+        case .globalGet(let globalIndex):
+            return try context.globalValue(globalIndex)
+        case .refNull(let type):
+            switch type {
+            case .externRef: return .ref(.extern(nil))
+            case .funcRef: return .ref(.function(nil))
+            }
+        case .refFunc(let functionIndex):
+            return try .ref(context.functionRef(functionIndex))
+        default:
+            throw InstantiationError.unsupported("illegal const expression instruction: \(constInst)")
+        }
+    }
+}
+
+extension WasmParser.ElementSegment {
+    func evaluateInits<C: ConstEvaluationContextProtocol>(context: C) throws -> [Reference] {
+        try self.initializer.map { expression -> Reference in
+            switch expression[0] {
+            case let .refFunc(index):
+                return try context.functionRef(index)
+            case .refNull(.funcRef):
+                return .function(nil)
+            case .refNull(.externRef):
+                return .extern(nil)
+            case .globalGet(let index):
+                let value = try context.globalValue(index)
+                switch value {
+                case .ref(.function(let addr)):
+                    return .function(addr)
+                default:
+                    throw Trap._raw("Unexpected global value type for element initializer expression")
+                }
+            default:
+                throw Trap._raw("Unexpected element initializer expression: \(expression)")
+            }
+        }
+    }
+}

Sources/WasmKit/Execution/Runtime.swift

@@ -241,82 +241,3 @@ public struct HostModule {
     /// Names of functions exported by this module mapped to corresponding host functions.
     public var functions: [String: HostFunction]
 }
-
-protocol ConstEvaluationContextProtocol {
-    func functionRef(_ index: FunctionIndex) throws -> Reference
-    func globalValue(_ index: GlobalIndex) throws -> Value
-}
-
-extension InternalInstance: ConstEvaluationContextProtocol {
-    func functionRef(_ index: FunctionIndex) throws -> Reference {
-        return try .function(from: self.functions[validating: Int(index)])
-    }
-    func globalValue(_ index: GlobalIndex) throws -> Value {
-        return try self.globals[validating: Int(index)].value
-    }
-}
-
-struct ConstEvaluationContext: ConstEvaluationContextProtocol {
-    let functions: ImmutableArray<InternalFunction>
-    var globals: [Value]
-    func functionRef(_ index: FunctionIndex) throws -> Reference {
-        return try .function(from: self.functions[validating: Int(index)])
-    }
-    func globalValue(_ index: GlobalIndex) throws -> Value {
-        guard index < globals.count else {
-            throw GlobalEntity.createOutOfBoundsError(index: Int(index), count: globals.count)
-        }
-        return self.globals[Int(index)]
-    }
-}
-
-extension ConstExpression {
-    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")
-        }
-        let constInst = self[0]
-        switch constInst {
-        case .i32Const(let value): return .i32(UInt32(bitPattern: value))
-        case .i64Const(let value): return .i64(UInt64(bitPattern: value))
-        case .f32Const(let value): return .f32(value.bitPattern)
-        case .f64Const(let value): return .f64(value.bitPattern)
-        case .globalGet(let globalIndex):
-            return try context.globalValue(globalIndex)
-        case .refNull(let type):
-            switch type {
-            case .externRef: return .ref(.extern(nil))
-            case .funcRef: return .ref(.function(nil))
-            }
-        case .refFunc(let functionIndex):
-            return try .ref(context.functionRef(functionIndex))
-        default:
-            throw InstantiationError.unsupported("illegal const expression instruction: \(constInst)")
-        }
-    }
-}
-
-extension WasmParser.ElementSegment {
-    func evaluateInits<C: ConstEvaluationContextProtocol>(context: C) throws -> [Reference] {
-        try self.initializer.map { expression -> Reference in
-            switch expression[0] {
-            case let .refFunc(index):
-                return try context.functionRef(index)
-            case .refNull(.funcRef):
-                return .function(nil)
-            case .refNull(.externRef):
-                return .extern(nil)
-            case .globalGet(let index):
-                let value = try context.globalValue(index)
-                switch value {
-                case .ref(.function(let addr)):
-                    return .function(addr)
-                default:
-                    throw Trap._raw("Unexpected global value type for element initializer expression")
-                }
-            default:
-                throw Trap._raw("Unexpected element initializer expression: \(expression)")
-            }
-        }
-    }
-}