review: plumb through a TypeFuncIndex for checking the indirectly-retrieved spawn function

Author: abrown

Diff for: crates/cranelift/src/compiler/component.rs

@@ -280,10 +280,8 @@ impl<'a> TrampolineCompiler<'a> {
                     rets[0] = me.raise_if_negative_one_and_truncate(rets[0]);
                 })
             }
-            Trampoline::ThreadSpawnIndirect { ty: _, table } => {
-                // TODO: eventually pass through the `ty` argument to check the
-                // table's funcref signature.
-                self.translate_thread_spawn_indirect(*table)
+            Trampoline::ThreadSpawnIndirect { ty, table } => {
+                self.translate_thread_spawn_indirect(*ty, *table)
             }
         }
     }
@@ -1336,12 +1334,22 @@ impl<'a> TrampolineCompiler<'a> {
         );
     }
 
-    fn translate_thread_spawn_indirect(&mut self, table: RuntimeTableIndex) {
+    fn translate_thread_spawn_indirect(
+        &mut self,
+        func_ty: TypeFuncIndex,
+        table: RuntimeTableIndex,
+    ) {
         let args = self.builder.func.dfg.block_params(self.block0).to_vec();
         let vmctx = args[0];
         let element = args[1];
         let context = args[2];
 
+        // func_ty: u32
+        let func_ty = self
+            .builder
+            .ins()
+            .iconst(ir::types::I32, i64::from(func_ty.as_u32()));
+
         // table: u32
         let table = self
             .builder
@@ -1351,7 +1359,7 @@ impl<'a> TrampolineCompiler<'a> {
         self.translate_intrinsic_libcall(
             vmctx,
             host::thread_spawn_indirect,
-            &[vmctx, table, element, context],
+            &[vmctx, func_ty, table, element, context],
             TrapSentinel::Falsy,
         );
     }

Diff for: crates/environ/src/component.rs

@@ -155,7 +155,7 @@ macro_rules! foreach_builtin_component_function {
             error_context_transfer(vmctx: vmctx, src_idx: u32, src_table: u32, dst_table: u32) -> u64;
 
             #[cfg(feature = "threads")]
-            thread_spawn_indirect(vmctx: vmctx, table: u32, element: u32, context: u32 ) -> u64;
+            thread_spawn_indirect(vmctx: vmctx, func_ty: u32, table: u32, element: u32, context: u32 ) -> u64;
 
             trap(vmctx: vmctx, code: u8);
 

Diff for: crates/environ/src/component/info.rs

@@ -997,9 +997,10 @@ pub enum Trampoline {
     /// The `thread.spawn_indirect` intrinsic to spawn a thread from a function
     /// of type `ty` stored in a `table`.
     ThreadSpawnIndirect {
-        /// TODO
+        /// The type of the function that is being spawned.
         ty: TypeFuncIndex,
-        /// TODO
+        /// The table from which to indirectly retrieve retrieve the spawn
+        /// function.
         table: RuntimeTableIndex,
     },
 }

Diff for: crates/wasmtime/src/runtime/vm/component.rs

@@ -749,7 +749,8 @@ impl ComponentInstance {
     #[cfg(feature = "threads")]
     pub(crate) fn thread_spawn_indirect(
         &mut self,
-        table: u32,
+        _func_ty: TypeFuncIndex,
+        table: RuntimeTableIndex,
         element: u32,
         _context: u32,
     ) -> Result<u32> {
@@ -760,7 +761,7 @@ impl ComponentInstance {
         // Retrieve the table referenced by the canonical builtin (i.e.,
         // `table`). By validation this is guaranteed to be a `shared funcref`
         // table.
-        let VMTable { vmctx, from } = self.runtime_table(RuntimeTableIndex::from_u32(table));
+        let VMTable { vmctx, from } = self.runtime_table(table);
         let element = u64::from(element);
         let table = unsafe {
             Instance::from_vmctx(vmctx.as_non_null(), |handle| {

Diff for: crates/wasmtime/src/runtime/vm/component/libcalls.rs

@@ -1271,11 +1271,16 @@ unsafe fn error_context_drop(
 #[cfg(feature = "threads")]
 unsafe fn thread_spawn_indirect(
     vmctx: NonNull<VMComponentContext>,
+    func_ty: u32,
     table: u32,
     element: u32,
     context: u32,
 ) -> Result<u32> {
+    use wasmtime_environ::component::{RuntimeTableIndex, TypeFuncIndex};
+
+    let func_ty = TypeFuncIndex::from_bits(func_ty);
+    let table = RuntimeTableIndex::from_u32(table);
     ComponentInstance::from_vmctx(vmctx, |instance| {
-        instance.thread_spawn_indirect(table, element, context)
+        instance.thread_spawn_indirect(func_ty, table, element, context)
     })
 }