Fix function index in backtrace with imported functions

Author: kateinoigakukun

Sources/WasmKit/Execution/StoreAllocator.swift

@@ -315,9 +315,10 @@ extension StoreAllocator {
                 for (index, importedEntity) in imports.enumerated() {
                     buffer.initializeElement(at: index, to: importedEntity)
                 }
-                for (index, internalEntity) in internals.enumerated() {
+                for (internalIndex, internalEntity) in internals.enumerated() {
+                    let index = imports.count + internalIndex
                     let allocated = try allocateHandle(internalEntity, index)
-                    buffer.initializeElement(at: imports.count + index, to: allocated)
+                    buffer.initializeElement(at: index, to: allocated)
                 }
             }
         }
@@ -372,7 +373,7 @@ extension StoreAllocator {
         let globals = try allocateEntities(
             imports: importedGlobals,
             internals: module.globals,
-            allocateHandle: { global, i in
+            allocateHandle: { global, _ in
                 let initialValue = try global.initializer.evaluate(
                     context: constEvalContext, expectedType: global.type.valueType
                 )

Tests/WasmKitTests/ExecutionTests.swift

@@ -52,31 +52,26 @@ final class ExecutionTests: XCTestCase {
         XCTAssertEqual(results, [.i32(42)])
     }
 
-    func testBacktrace() throws {
+    func expectTrap(_ wat: String, assertTrap: (Trap) throws -> Void) throws {
         let module = try parseWasm(
-            bytes: wat2wasm(
-                """
-                (module
-                  (memory (export "memory") 1)
-                  (func $foo (result i32)
-                    unreachable
-                  )
-                  (func $bar (result i32)
-                    (call $foo)
-                  )
-                  (func (export "_start")
-                    (call $bar)
-                    (drop)
-                  )
-                )
-                """,
-                options: EncodeOptions(nameSection: true)
-            )
+            bytes: wat2wasm(wat, options: EncodeOptions(nameSection: true))
         )
 
         let engine = Engine()
         let store = Store(engine: engine)
-        let instance = try module.instantiate(store: store)
+        var imports = Imports()
+        for importEntry in module.imports {
+            guard case .function(let type) = importEntry.descriptor else { continue }
+            let function = try Function(
+                store: store,
+                type: module.resolveFunctionType(type),
+                body: { _, _ in
+                    return []
+                }
+            )
+            imports.define(importEntry, .function(function))
+        }
+        let instance = try module.instantiate(store: store, imports: imports)
         let _start = try XCTUnwrap(instance.exports[function: "_start"])
 
         let trap: Trap
@@ -87,13 +82,59 @@ final class ExecutionTests: XCTestCase {
         } catch let error {
             trap = try XCTUnwrap(error as? Trap)
         }
+        try assertTrap(trap)
+    }
 
-        XCTAssertEqual(
-            trap.backtrace?.symbols.compactMap(\.?.name),
-            [
-                "foo",
-                "bar",
-                "_start",
-            ])
+    func testBacktraceBasic() throws {
+        try expectTrap(
+            """
+            (module
+                (func $foo
+                    unreachable
+                )
+                (func $bar
+                    (call $foo)
+                )
+                (func (export "_start")
+                    (call $bar)
+                )
+            )
+            """
+        ) { trap in
+            XCTAssertEqual(
+                trap.backtrace?.symbols.compactMap(\.?.name),
+                [
+                    "foo",
+                    "bar",
+                    "_start",
+                ])
+        }
+    }
+
+    func testBacktraceWithImports() throws {
+        try expectTrap(
+            """
+            (module
+                (func (import "env" "bar"))
+                (func
+                    unreachable
+                )
+                (func $bar
+                    (call 1)
+                )
+                (func (export "_start")
+                    (call $bar)
+                )
+            )
+            """
+        ) { trap in
+            XCTAssertEqual(
+                trap.backtrace?.symbols.compactMap(\.?.name),
+                [
+                    "wasm function[1]",
+                    "bar",
+                    "_start",
+                ])
+        }
     }
 }