fix table resolution for thread.new-indirect intrinsic calls (#2585)

Previously, the encoding of `thread.new-indirect` calls looked for an
`__indirect_function_table` export in the same module as the one importing that
intrinsic.  However, when linking shared libraries together, the
intrinsic-importing library module will be different from the table-exporting
main module.  In practice, this means we should always be looking for the table
in the main module, regardless of which module is importing the intrinsic.

Fixes #2583

Author: dicej

crates/wit-component/src/encoding.rs

@@ -1474,18 +1474,15 @@ impl<'a> EncodingState<'a> {
                             .into_iter(*encoding, self.memory_index, realloc_index)?;
                     self.component.task_return(result, options)
                 }
-                ShimKind::ThreadNewIndirect {
-                    for_module,
-                    func_ty,
-                } => {
+                ShimKind::ThreadNewIndirect { func_ty } => {
                     // Encode the function type for the thread start function so we can reference it in the `canon` call.
                     let (func_ty_idx, f) = self.component.core_type(Some("thread-start"));
                     f.core().func_type(func_ty);
 
                     // In order for the funcref table referenced by `thread.new-indirect` to be used,
-                    // it must have been exported by the module.
-                    let exports = self.info.exports_for(*for_module);
-                    let instance_index = self.instance_for(*for_module);
+                    // it must have been exported by the main module.
+                    let exports = self.info.exports_for(CustomModule::Main);
+                    let instance_index = self.instance_for(CustomModule::Main);
                     let table_idx = exports.indirect_function_table().map(|table| {
                         self.core_alias_export(
                             Some("indirect-function-table"),
@@ -2005,7 +2002,6 @@ impl<'a> EncodingState<'a> {
             Import::ThreadNewIndirect => Ok(self.materialize_shim_import(
                 shims,
                 &ShimKind::ThreadNewIndirect {
-                    for_module,
                     // This is fixed for now
                     func_ty: FuncType::new([ValType::I32], []),
                 },
@@ -2611,8 +2607,6 @@ enum ShimKind<'a> {
     /// A shim used for the `thread.new-indirect` built-in function, which
     /// must refer to the core module instance's indirect function table.
     ThreadNewIndirect {
-        /// Which instance to pull the function table from.
-        for_module: CustomModule<'a>,
         /// The function type to use when creating the thread.
         func_ty: FuncType,
     },
@@ -2866,7 +2860,6 @@ impl<'a> Shims<'a> {
                         debug_name: "thread.new-indirect".to_string(),
                         options: RequiredOptions::empty(),
                         kind: ShimKind::ThreadNewIndirect {
-                            for_module,
                             // This is fixed for now
                             func_ty: FuncType::new([ValType::I32], vec![]),
                         },

crates/wit-component/src/linking.rs

@@ -1408,7 +1408,7 @@ pub struct Linker {
 impl Linker {
     /// Add a dynamic library module to this linker.
     ///
-    /// If `dl_openable` is true, all of the libraries exports will be added to the `dlopen`/`dlsym` lookup table
+    /// If `dl_openable` is true, all of the library's exports will be added to the `dlopen`/`dlsym` lookup table
     /// for runtime resolution.
     pub fn library(mut self, name: &str, module: &[u8], dl_openable: bool) -> Result<Self> {
         self.libraries

crates/wit-component/tests/components/link-thread-new-indirect/component.wat

@@ -0,0 +1,95 @@
+(component
+  (core module $main (;0;)
+    (table (;0;) 2 funcref)
+    (memory (;0;) 17)
+    (global (;0;) i32 i32.const 1048584)
+    (global (;1;) i32 i32.const 2)
+    (export "foo:memory_base" (global 0))
+    (export "foo:table_base" (global 1))
+    (export "__indirect_function_table" (table 0))
+    (export "memory" (memory 0))
+    (@producers
+      (processed-by "wit-component" "$CARGO_PKG_VERSION")
+    )
+  )
+  (core module $foo (;1;)
+    (@dylink.0)
+    (type (;0;) (func (param i32 i32) (result i32)))
+    (type (;1;) (func))
+    (import "$root" "[thread-new-indirect-v0]" (func (;0;) (type 0)))
+    (export "hi" (func 1))
+    (func (;1;) (type 1))
+  )
+  (core module $__init (;2;)
+    (type (;0;) (func))
+    (type (;1;) (func (param i32)))
+    (import "env" "memory" (memory (;0;) 0))
+    (import "env" "__indirect_function_table" (table (;0;) 0 funcref))
+    (start 0)
+    (elem (;0;) (i32.const 1) func)
+    (elem (;1;) (i32.const 2) func)
+    (func (;0;) (type 0))
+    (data (;0;) (i32.const 1048576) "\00\00\00\00\00\00\10\00")
+    (@producers
+      (processed-by "wit-component" "$CARGO_PKG_VERSION")
+    )
+  )
+  (core module $wit-component-shim-module (;3;)
+    (type (;0;) (func (param i32 i32) (result i32)))
+    (table (;0;) 1 1 funcref)
+    (export "0" (func $thread.new-indirect))
+    (export "$imports" (table 0))
+    (func $thread.new-indirect (;0;) (type 0) (param i32 i32) (result i32)
+      local.get 0
+      local.get 1
+      i32.const 0
+      call_indirect (type 0)
+    )
+    (@producers
+      (processed-by "wit-component" "$CARGO_PKG_VERSION")
+    )
+  )
+  (core module $wit-component-fixup (;4;)
+    (type (;0;) (func (param i32 i32) (result i32)))
+    (import "" "0" (func (;0;) (type 0)))
+    (import "" "$imports" (table (;0;) 1 1 funcref))
+    (elem (;0;) (i32.const 0) func 0)
+    (@producers
+      (processed-by "wit-component" "$CARGO_PKG_VERSION")
+    )
+  )
+  (core instance $wit-component-shim-instance (;0;) (instantiate $wit-component-shim-module))
+  (core instance $main (;1;) (instantiate $main))
+  (alias core export $main "memory" (core memory $memory (;0;)))
+  (alias core export $wit-component-shim-instance "0" (core func $thread.new-indirect (;0;)))
+  (core instance $$root (;2;)
+    (export "[thread-new-indirect-v0]" (func $thread.new-indirect))
+  )
+  (core instance $foo (;3;) (instantiate $foo
+      (with "$root" (instance $$root))
+    )
+  )
+  (alias core export $wit-component-shim-instance "$imports" (core table $"shim table" (;0;)))
+  (core type $thread-start (;0;) (func (param i32)))
+  (alias core export $main "__indirect_function_table" (core table $indirect-function-table (;1;)))
+  (core func $"#core-func1 thread.new-indirect" (@name "thread.new-indirect") (;1;) (canon thread.new-indirect $thread-start $indirect-function-table))
+  (core instance $fixup-args (;4;)
+    (export "$imports" (table $"shim table"))
+    (export "0" (func $"#core-func1 thread.new-indirect"))
+  )
+  (core instance $fixup (;5;) (instantiate $wit-component-fixup
+      (with "" (instance $fixup-args))
+    )
+  )
+  (core instance $__init (;6;) (instantiate $__init
+      (with "env" (instance $main))
+    )
+  )
+  (type (;0;) (func))
+  (alias core export $foo "hi" (core func $hi (;2;)))
+  (func $hi (;0;) (type 0) (canon lift (core func $hi)))
+  (export $"#func1 hi" (@name "hi") (;1;) "hi" (func $hi))
+  (@producers
+    (processed-by "wit-component" "$CARGO_PKG_VERSION")
+  )
+)

crates/wit-component/tests/components/link-thread-new-indirect/component.wit.print

@@ -0,0 +1,5 @@
+package root:component;
+
+world root {
+  export hi: func();
+}

crates/wit-component/tests/components/link-thread-new-indirect/lib-foo.wat

@@ -0,0 +1,6 @@
+(module
+  (@dylink.0)
+  (import "$root" "[thread-new-indirect-v0]" (func (param i32 i32) (result i32)))
+
+  (func (export "hi"))
+)

crates/wit-component/tests/components/link-thread-new-indirect/lib-foo.wit

@@ -0,0 +1,5 @@
+package test:test;
+
+world lib-foo {
+  export hi: func();
+}