threads: add thread.spawn_indirect

As discussed in [bytecodealliance#89], this adds support for a new intrinsic,
`thread.spawn_indirect`. This new operation would allow spawning a
shared function stored in a table via a table index.

This leaves some future work undone:
- `thread.spawn` could/should be renamed to `thread.spawn_ref`
- `thread.spawn_indirect` could/should take the encoding byte from
  `thread.hw_concurrency`--swap `0x07` for `0x06`
- importantly, `thread.spawn_indirect` should gain a field indicating
  which type to expect in the indirect table; due to current limitations
  in `wasm-tools`, the locations to check once this is possible are
  marked with `TODO: spawn indirect types`.

[bytecodealliance#89]: WebAssembly/shared-everything-threads#89

Author: abrown

crates/wasm-encoder/src/component/canonicals.rs

@@ -158,7 +158,7 @@ impl CanonicalFunctionSection {
         self
     }
 
-    /// Defines a function which will spawns a new thread by invoking a shared
+    /// Defines a function which will spawn a new thread by invoking a shared
     /// function of type `ty_index`.
     pub fn thread_spawn(&mut self, ty_index: u32) -> &mut Self {
         self.bytes.push(0x05);
@@ -167,6 +167,15 @@ impl CanonicalFunctionSection {
         self
     }
 
+    /// Defines a function which will spawn a new thread by invoking a shared
+    /// function indirectly through a `funcref` table.
+    pub fn thread_spawn_indirect(&mut self, table_index: u32) -> &mut Self {
+        self.bytes.push(0x24);
+        table_index.encode(&mut self.bytes);
+        self.num_added += 1;
+        self
+    }
+
     /// Defines a function which will return the number of threads that can be
     /// expected to execute concurrently.
     pub fn thread_available_parallelism(&mut self) -> &mut Self {

crates/wasm-encoder/src/reencode/component.rs

@@ -957,6 +957,10 @@ pub mod component_utils {
                 let func_ty = reencoder.type_index(func_ty_index);
                 section.thread_spawn(func_ty);
             }
+            wasmparser::CanonicalFunction::ThreadSpawnIndirect { table_index } => {
+                let table_index = reencoder.table_index(table_index);
+                section.thread_spawn_indirect(table_index);
+            }
             wasmparser::CanonicalFunction::ThreadAvailableParallelism => {
                 section.thread_available_parallelism();
             }

crates/wasmparser/src/readers/component/canonicals.rs

@@ -75,6 +75,19 @@ pub enum CanonicalFunction {
         /// The index of the function to spawn.
         func_ty_index: u32,
     },
+    /// A function which spawns a new thread by invoking the shared function
+    /// passed as an index into a `funcref` table.
+    ///
+    /// Eventually, this will include a core `type_index` field to specify what
+    /// type of functions the table will contain. Currently, however,
+    /// `wasm-tools` makes it difficult to pass along the core type information
+    /// downstream, so we fix the type of the table temporarily to `funcref` and
+    /// check at runtime that the entry has type `[i32] -> []`. (TODO: spawn
+    /// indirect types).
+    ThreadSpawnIndirect {
+        /// The index of the table to use for the indirect spawn.
+        table_index: u32,
+    },
     /// A function which returns the number of threads that can be expected to
     /// execute concurrently
     ThreadAvailableParallelism,
@@ -281,6 +294,9 @@ impl<'a> FromReader<'a> for CanonicalFunction {
                 func_ty_index: reader.read()?,
             },
             0x06 => CanonicalFunction::ThreadAvailableParallelism,
+            0x24 => CanonicalFunction::ThreadSpawnIndirect {
+                table_index: reader.read()?,
+            },
             0x08 => CanonicalFunction::BackpressureSet,
             0x09 => CanonicalFunction::TaskReturn {
                 result: crate::read_resultlist(reader)?,

crates/wasmparser/src/validator/component.rs

@@ -990,6 +990,9 @@ impl ComponentState {
             CanonicalFunction::ThreadSpawn { func_ty_index } => {
                 self.thread_spawn(func_ty_index, types, offset, features)
             }
+            CanonicalFunction::ThreadSpawnIndirect { table_index } => {
+                self.thread_spawn_indirect(table_index, types, offset, features)
+            }
             CanonicalFunction::ThreadAvailableParallelism => {
                 self.thread_available_parallelism(types, offset, features)
             }
@@ -1975,6 +1978,43 @@ impl ComponentState {
         Ok(())
     }
 
+    fn thread_spawn_indirect(
+        &mut self,
+        table_index: u32,
+        types: &mut TypeAlloc,
+        offset: usize,
+        features: &WasmFeatures,
+    ) -> Result<()> {
+        if !features.shared_everything_threads() {
+            bail!(
+                offset,
+                "`thread.spawn_indirect` requires the shared-everything-threads proposal"
+            )
+        }
+
+        // Check this much like `call_indirect` (see
+        // `OperatorValidatorTemp::check_call_indirect_ty`), but loosen the
+        // table type restrictions for now to just a `funcref`. Once the
+        // `spawn_indirect` gains a type immediate, this should look that type
+        // up and verify that it is (a) shared and (b) matches the table type
+        // (TODO: spawn indirect types).
+        let table = self.table_at(table_index, offset)?;
+        let expected_ty = RefType::FUNCREF
+            .shared()
+            .expect("a funcref can always be shared");
+        if table.element_type != expected_ty {
+            bail!(offset, "expected a table of shared `funcref`");
+        }
+
+        // Insert the core function.
+        let func_ty = FuncType::new([ValType::I32, ValType::I32], [ValType::I32]);
+        let core_ty = SubType::func(func_ty, true);
+        let id = types.intern_sub_type(core_ty, offset);
+        self.core_funcs.push(id);
+
+        Ok(())
+    }
+
     fn thread_available_parallelism(
         &mut self,
         types: &mut TypeAlloc,

crates/wasmprinter/src/component.rs

@@ -895,23 +895,21 @@ impl Printer<'_, '_> {
                 CanonicalFunction::ThreadSpawn {
                     func_ty_index: func_index,
                 } => {
-                    self.start_group("core func ")?;
-                    self.print_name(&state.core.func_names, state.core.funcs)?;
-                    self.result.write_str(" ")?;
-                    self.start_group("canon thread.spawn ")?;
-                    self.print_idx(&state.core.type_names, func_index)?;
-                    self.end_group()?;
-                    self.end_group()?;
-                    state.core.funcs += 1;
+                    self.print_intrinsic(state, "canon thread.spawn ", &|me, state| {
+                        me.print_idx(&state.core.type_names, func_index)
+                    })?;
+                }
+                CanonicalFunction::ThreadSpawnIndirect { table_index } => {
+                    self.print_intrinsic(state, "canon thread.spawn_indirect ", &|me, state| {
+                        me.start_group("table ")?;
+                        me.print_idx(&state.core.table_names, table_index)?;
+                        me.end_group()
+                    })?;
                 }
                 CanonicalFunction::ThreadAvailableParallelism => {
-                    self.start_group("core func ")?;
-                    self.print_name(&state.core.func_names, state.core.funcs)?;
-                    self.result.write_str(" ")?;
-                    self.start_group("canon thread.available_parallelism")?;
-                    self.end_group()?;
-                    self.end_group()?;
-                    state.core.funcs += 1;
+                    self.print_intrinsic(state, "canon thread.available_parallelism", &|_, _| {
+                        Ok(())
+                    })?;
                 }
                 CanonicalFunction::BackpressureSet => {
                     self.print_intrinsic(state, "canon backpressure.set", &|_, _| Ok(()))?;

crates/wast/src/component/binary.rs

@@ -357,6 +357,10 @@ impl<'a> Encoder<'a> {
                     self.core_func_names.push(name);
                     self.funcs.thread_spawn(info.ty.into());
                 }
+                CoreFuncKind::ThreadSpawnIndirect(info) => {
+                    self.core_func_names.push(name);
+                    self.funcs.thread_spawn_indirect(info.table.idx.into());
+                }
                 CoreFuncKind::ThreadAvailableParallelism(_info) => {
                     self.core_func_names.push(name);
                     self.funcs.thread_available_parallelism();

crates/wast/src/component/func.rs

@@ -52,6 +52,7 @@ pub enum CoreFuncKind<'a> {
     ResourceDrop(CanonResourceDrop<'a>),
     ResourceRep(CanonResourceRep<'a>),
     ThreadSpawn(CanonThreadSpawn<'a>),
+    ThreadSpawnIndirect(CanonThreadSpawnIndirect<'a>),
     ThreadAvailableParallelism(CanonThreadAvailableParallelism),
     BackpressureSet,
     TaskReturn(CanonTaskReturn<'a>),
@@ -111,6 +112,8 @@ impl<'a> CoreFuncKind<'a> {
             Ok(CoreFuncKind::ResourceRep(parser.parse()?))
         } else if l.peek::<kw::thread_spawn>()? {
             Ok(CoreFuncKind::ThreadSpawn(parser.parse()?))
+        } else if l.peek::<kw::thread_spawn_indirect>()? {
+            Ok(CoreFuncKind::ThreadSpawnIndirect(parser.parse()?))
         } else if l.peek::<kw::thread_available_parallelism>()? {
             Ok(CoreFuncKind::ThreadAvailableParallelism(parser.parse()?))
         } else if l.peek::<kw::backpressure_set>()? {
@@ -488,6 +491,30 @@ impl<'a> Parse<'a> for CanonThreadSpawn<'a> {
     }
 }
 
+/// Information relating to the `thread.spawn_indirect` intrinsic.
+///
+/// This should look identical to that of `CallIndirect`. The only difference is
+/// that, temporarily, the `ty` field (`pub ty: TypeUse<'a, FunctionType<'a>>`)
+/// is fixed to a shared `funcref`, instead of allowing programs to specify the
+/// type. This is due to `wasm-tools` limitations making it difficult to pass
+/// core type indexes downstream (TODO: spawn indirect types).
+#[derive(Debug)]
+pub struct CanonThreadSpawnIndirect<'a> {
+    /// The table that this spawn is going to be indexing.
+    pub table: CoreItemRef<'a, kw::table>,
+}
+
+impl<'a> Parse<'a> for CanonThreadSpawnIndirect<'a> {
+    fn parse(parser: Parser<'a>) -> Result<Self> {
+        parser.parse::<kw::thread_spawn_indirect>()?;
+        let table = parser.parens(|parser| {
+            let span = parser.parse::<kw::table>()?.0;
+            parse_trailing_item_ref(kw::table(span), parser)
+        })?;
+        Ok(Self { table })
+    }
+}
+
 /// Information relating to the `thread.spawn` intrinsic.
 #[derive(Debug)]
 pub struct CanonThreadAvailableParallelism;

crates/wast/src/component/resolve.rs

@@ -390,6 +390,13 @@ impl<'a> Resolver<'a> {
                 CoreFuncKind::ThreadSpawn(info) => {
                     self.resolve_ns(&mut info.ty, Ns::CoreType)?;
                 }
+                CoreFuncKind::ThreadSpawnIndirect(info) => {
+                    self.core_item_ref(&mut info.table)?;
+                    // Eventually this should resolve the specific type associated
+                    // with this canonical function, e.g.,
+                    // `self.resolve_type_use(&mut info.ty)?;` (TODO: spawn indirect
+                    // types).
+                }
                 CoreFuncKind::ThreadAvailableParallelism(_)
                 | CoreFuncKind::BackpressureSet
                 | CoreFuncKind::Yield(_)
@@ -1094,6 +1101,7 @@ component_item!(kw::module, CoreModule);
 
 core_item!(kw::func, CoreFunc);
 core_item!(kw::memory, CoreMemory);
+core_item!(kw::table, CoreTable);
 core_item!(kw::r#type, CoreType);
 core_item!(kw::r#instance, CoreInstance);
 

crates/wast/src/lib.rs

@@ -555,6 +555,7 @@ pub mod kw {
     custom_keyword!(import_info = "import-info");
     custom_keyword!(thread);
     custom_keyword!(thread_spawn = "thread.spawn");
+    custom_keyword!(thread_spawn_indirect = "thread.spawn_indirect");
     custom_keyword!(thread_available_parallelism = "thread.available_parallelism");
     custom_keyword!(backpressure_set = "backpressure.set");
     custom_keyword!(task_return = "task.return");

src/bin/wasm-tools/dump.rs

@@ -420,6 +420,7 @@ impl<'a> Dump<'a> {
                             | CanonicalFunction::ResourceDropAsync { .. }
                             | CanonicalFunction::ResourceRep { .. }
                             | CanonicalFunction::ThreadSpawn { .. }
+                            | CanonicalFunction::ThreadSpawnIndirect { .. }
                             | CanonicalFunction::ThreadAvailableParallelism
                             | CanonicalFunction::BackpressureSet
                             | CanonicalFunction::TaskReturn { .. }

tests/cli/missing-features/component-model/shared-everything-threads-builtins.wast

@@ -8,6 +8,14 @@
   )
   "`thread.spawn` requires the shared-everything-threads proposal")
 
+(assert_invalid
+  (component
+    (core module $libc (table (export "start-table") 1 funcref))
+    (core instance $libc (instantiate $libc))
+    (core func $spawn_indirect (canon thread.spawn_indirect (table $libc "start-table")))
+  )
+  "`thread.spawn_indirect` requires the shared-everything-threads proposal")
+
 (assert_invalid
   (component
     (core func $parallelism (canon thread.available_parallelism))

tests/cli/shared-everything-threads/builtins.wast

@@ -5,23 +5,35 @@
 (component
   (core type $start (shared (func (param $context i32))))
   (core func $spawn (canon thread.spawn $start))
+
+  (core module $libc (table (export "start-table") 1 (ref null (shared func))))
+  (core instance $libc (instantiate $libc))
+  (core func $spawn_indirect (canon thread.spawn_indirect (table $libc "start-table")))
+
   (core func $parallelism (canon thread.available_parallelism))
 )
 
 (component
   (core type $start (shared (func (param $context i32))))
   (core func $spawn (canon thread.spawn $start))
+
+  (core module $libc (table (export "start-table") 1 (ref null (shared func))))
+  (core instance $libc (instantiate $libc))
+  (core func $spawn_indirect (canon thread.spawn_indirect (table $libc "start-table")))
+
   (core func $parallelism (canon thread.available_parallelism))
 
   (core module $m
     (type $st (shared (func (param $context i32))))
     (import "" "spawn" (func (param (ref null $st)) (param i32) (result i32)))
+    (import "" "spawn_indirect" (func (param i32) (param i32) (result i32)))
     (import "" "parallelism" (func (result i32)))
   )
 
   (core instance (instantiate $m
     (with "" (instance
       (export "spawn" (func $spawn))
+      (export "spawn_indirect" (func $spawn_indirect))
       (export "parallelism" (func $parallelism))
     ))
   ))

tests/snapshots/cli/missing-features/component-model/shared-everything-threads-builtins.wast.json

@@ -13,6 +13,13 @@
       "line": 12,
       "filename": "shared-everything-threads-builtins.1.wasm",
       "module_type": "binary",
+      "text": "`thread.spawn_indirect` requires the shared-everything-threads proposal"
+    },
+    {
+      "type": "assert_invalid",
+      "line": 20,
+      "filename": "shared-everything-threads-builtins.2.wasm",
+      "module_type": "binary",
       "text": "`thread.available_parallelism` requires the shared-everything-threads proposal"
     }
   ]

tests/snapshots/cli/shared-everything-threads/builtins.wast.json

@@ -9,20 +9,20 @@
     },
     {
       "type": "module",
-      "line": 11,
+      "line": 16,
       "filename": "builtins.1.wasm",
       "module_type": "binary"
     },
     {
       "type": "assert_invalid",
-      "line": 31,
+      "line": 43,
       "filename": "builtins.2.wasm",
       "module_type": "binary",
       "text": "spawn type must be shared"
     },
     {
       "type": "assert_invalid",
-      "line": 39,
+      "line": 51,
       "filename": "builtins.3.wasm",
       "module_type": "binary",
       "text": "spawn function must take a single `i32` argument (currently)"

tests/snapshots/cli/shared-everything-threads/builtins.wast/0.print

@@ -1,5 +1,12 @@
 (component
   (core type $start (;0;) (shared (func (param i32))))
   (core func $spawn (;0;) (canon thread.spawn $start))
-  (core func $parallelism (;1;) (canon thread.available_parallelism))
+  (core module $libc (;0;)
+    (table (;0;) 1 (ref null (shared func)))
+    (export "start-table" (table 0))
+  )
+  (core instance $libc (;0;) (instantiate $libc))
+  (alias core export $libc "start-table" (core table (;0;)))
+  (core func $spawn_indirect (;1;) (canon thread.spawn_indirect (table 0)))
+  (core func $parallelism (;2;) (canon thread.available_parallelism))
 )

tests/snapshots/cli/shared-everything-threads/builtins.wast/1.print

@@ -1,20 +1,30 @@
 (component
   (core type $start (;0;) (shared (func (param i32))))
   (core func $spawn (;0;) (canon thread.spawn $start))
-  (core func $parallelism (;1;) (canon thread.available_parallelism))
-  (core module $m (;0;)
+  (core module $libc (;0;)
+    (table (;0;) 1 (ref null (shared func)))
+    (export "start-table" (table 0))
+  )
+  (core instance $libc (;0;) (instantiate $libc))
+  (alias core export $libc "start-table" (core table (;0;)))
+  (core func $spawn_indirect (;1;) (canon thread.spawn_indirect (table 0)))
+  (core func $parallelism (;2;) (canon thread.available_parallelism))
+  (core module $m (;1;)
     (type $st (;0;) (shared (func (param i32))))
     (type (;1;) (func (param (ref null $st) i32) (result i32)))
-    (type (;2;) (func (result i32)))
+    (type (;2;) (func (param i32 i32) (result i32)))
+    (type (;3;) (func (result i32)))
     (import "" "spawn" (func (;0;) (type 1)))
-    (import "" "parallelism" (func (;1;) (type 2)))
+    (import "" "spawn_indirect" (func (;1;) (type 2)))
+    (import "" "parallelism" (func (;2;) (type 3)))
   )
-  (core instance (;0;)
+  (core instance (;1;)
     (export "spawn" (func $spawn))
+    (export "spawn_indirect" (func $spawn_indirect))
     (export "parallelism" (func $parallelism))
   )
-  (core instance (;1;) (instantiate $m
-      (with "" (instance 0))
+  (core instance (;2;) (instantiate $m
+      (with "" (instance 1))
     )
   )
 )