Validation: Ban internal global usage in constant expressions

Author: kateinoigakukun

Sources/WasmKit/Execution/ConstEvaluation.swift

@@ -5,18 +5,23 @@ protocol ConstEvaluationContextProtocol {
     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]
+
+    init(functions: ImmutableArray<InternalFunction>, globals: [Value]) {
+        self.functions = functions
+        self.globals = globals
+    }
+
+    init(instance: InternalInstance, moduleImports: ModuleImports) {
+        // Constant expressions can only reference imported globals
+        let externalGlobals = instance.globals
+            .prefix(moduleImports.numberOfGlobals)
+            .map { $0.value }
+        self.init(functions: instance.functions, globals: Array(externalGlobals))
+    }
+
     func functionRef(_ index: FunctionIndex) throws -> Reference {
         return try .function(from: self.functions[validating: Int(index)])
     }

Sources/WasmKit/Module.swift

@@ -147,21 +147,22 @@ public struct Module {
             try? store.nameRegistry.register(instance: instance, nameSection: nameSection)
         }
 
+        let constEvalContext = ConstEvaluationContext(instance: instance, moduleImports: moduleImports)
         // Step 12-13.
 
         // Steps 14-15.
         do {
             for element in elements {
                 guard case let .active(tableIndex, offset) = element.mode else { continue }
-                let offsetValue = try offset.evaluate(context: instance)
+                let offsetValue = try offset.evaluate(context: constEvalContext)
                 let table = try instance.tables[validating: Int(tableIndex)]
                 try table.withValue { table in
                     guard let offset = offsetValue.maybeAddressOffset(table.limits.isMemory64) else {
                         throw InstantiationError.unsupported(
                             "Expect \(ValueType.addressType(isMemory64: table.limits.isMemory64)) offset of active element segment but got \(offsetValue)"
                         )
                     }
-                    let references = try element.evaluateInits(context: instance)
+                    let references = try element.evaluateInits(context: constEvalContext)
                     try table.initialize(
                         references, from: 0, to: Int(offset), count: references.count
                     )
@@ -176,7 +177,7 @@ public struct Module {
         // Step 16.
         do {
             for case let .active(data) in data {
-                let offsetValue = try data.offset.evaluate(context: instance)
+                let offsetValue = try data.offset.evaluate(context: constEvalContext)
                 let memory = try instance.memories[validating: Int(data.index)]
                 try memory.withValue { memory in
                     guard let offset = offsetValue.maybeAddressOffset(memory.limit.isMemory64) else {

Tests/WasmKitTests/SpectestTests.swift

@@ -22,10 +22,6 @@ final class SpectestTests: XCTestCase {
             path: Self.testPaths,
             include: [],
             exclude: [
-                "br_if.wast",
-                "call.wast",
-                "call_indirect.wast",
-                "data.wast",
                 "elem.wast",
                 "exports.wast",
                 "func.wast",