Add skeleton copying collector (#13093)

This commit adds the skeleton of a new copying collector, guarded behind a new
"gc-copying" cargo feature. It compiles and implements the various `Gc*` traits
to interface with the runtime and compiler, but is not yet actually functional.

The copying collector is intentionally excluded from the fuzzing config
generator, as it isn't ready to be fuzzed yet.

Author: fitzgen

.github/workflows/main.yml

@@ -360,6 +360,9 @@ jobs:
               -p wasmtime --no-default-features --features gc-null
               -p wasmtime --no-default-features --features runtime,gc-null
               -p wasmtime --no-default-features --features cranelift,gc-null
+              -p wasmtime --no-default-features --features gc-copying
+              -p wasmtime --no-default-features --features runtime,gc-copying
+              -p wasmtime --no-default-features --features cranelift,gc-copying
               -p wasmtime --no-default-features --features runtime
               -p wasmtime --no-default-features --features threads
               -p wasmtime --no-default-features --features runtime,threads

Cargo.toml

@@ -583,6 +583,7 @@ threads = ["wasmtime-cli-flags/threads"]
 gc = ["wasmtime-cli-flags/gc", "wasmtime/gc"]
 gc-drc = ["gc", "wasmtime/gc-drc", "wasmtime-cli-flags/gc-drc"]
 gc-null = ["gc", "wasmtime/gc-null", "wasmtime-cli-flags/gc-null"]
+gc-copying = ["gc", "wasmtime/gc-copying", "wasmtime-cli-flags/gc-copying"]
 pulley = ["wasmtime-cli-flags/pulley"]
 stack-switching = ["wasmtime/stack-switching", "wasmtime-cli-flags/stack-switching"]
 debug = ["wasmtime-cli-flags/debug", "wasmtime/debug", "component-model"]

crates/c-api/Cargo.toml

@@ -58,6 +58,7 @@ threads = ["wasmtime/threads"]
 gc = ["wasmtime/gc"]
 gc-drc = ["wasmtime/gc-drc"]
 gc-null = ["wasmtime/gc-null"]
+gc-copying = ["wasmtime/gc-copying"]
 cranelift = ['wasmtime/cranelift']
 winch = ['wasmtime/winch']
 debug-builtins = ['wasmtime/debug-builtins']

crates/c-api/artifact/Cargo.toml

@@ -64,6 +64,7 @@ threads = ["wasmtime-c-api/threads"]
 gc = ["wasmtime-c-api/gc"]
 gc-drc = ["wasmtime-c-api/gc-drc"]
 gc-null = ["wasmtime-c-api/gc-null"]
+gc-copying = ["wasmtime-c-api/gc-copying"]
 cranelift = ["wasmtime-c-api/cranelift"]
 winch = ["wasmtime-c-api/winch"]
 debug-builtins = ["wasmtime-c-api/debug-builtins"]

crates/cli-flags/Cargo.toml

@@ -35,6 +35,7 @@ coredump = ["wasmtime/coredump"]
 gc = ["wasmtime/gc"]
 gc-drc = ["gc", "wasmtime/gc-drc"]
 gc-null = ["gc", "wasmtime/gc-null"]
+gc-copying = ["gc", "wasmtime/gc-copying"]
 threads = ["wasmtime/threads"]
 memory-protection-keys = ["wasmtime/memory-protection-keys"]
 pulley = ["wasmtime/pulley"]

crates/cli-flags/src/lib.rs

@@ -234,13 +234,15 @@ wasmtime_option_group! {
         #[serde(default)]
         #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")]
         pub compiler: Option<wasmtime::Strategy>,
-        /// Which garbage collector to use: `drc` or `null`.
+        /// Which garbage collector to use: `drc`, `null`, or `copying`.
         ///
         /// `drc` is the deferred reference-counting collector.
         ///
         /// `null` is the null garbage collector, which does not collect any
         /// garbage.
         ///
+        /// `copying` is the copying garbage collector (not yet implemented).
+        ///
         /// Note that not all builds of Wasmtime will have support for garbage
         /// collection included.
         #[serde(default)]
@@ -1325,6 +1327,7 @@ mod tests {
                 Some(wasmtime::Collector::DeferredReferenceCounting),
             ),
             ("\"null\"", Some(wasmtime::Collector::Null)),
+            ("\"copying\"", Some(wasmtime::Collector::Copying)),
             ("\"hello\"", None), // should fail
             ("5", None),         // should fail
             ("true", None),      // should fail

crates/cli-flags/src/opt.rs

@@ -548,19 +548,23 @@ impl WasmtimeOptionValue for wasmtime::Strategy {
 }
 
 impl WasmtimeOptionValue for wasmtime::Collector {
-    const VAL_HELP: &'static str = "=drc|null";
+    const VAL_HELP: &'static str = "=drc|null|copying";
     fn parse(val: Option<&str>) -> Result<Self> {
         match String::parse(val)?.as_str() {
             "drc" => Ok(wasmtime::Collector::DeferredReferenceCounting),
             "null" => Ok(wasmtime::Collector::Null),
-            other => bail!("unknown collector `{other}` only `drc` and `null` accepted",),
+            "copying" => Ok(wasmtime::Collector::Copying),
+            other => {
+                bail!("unknown collector `{other}` only `drc`, `null`, and `copying` accepted",)
+            }
         }
     }
 
     fn display(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             wasmtime::Collector::DeferredReferenceCounting => f.write_str("drc"),
             wasmtime::Collector::Null => f.write_str("null"),
+            wasmtime::Collector::Copying => f.write_str("copying"),
             _ => unreachable!(),
         }
     }

crates/cranelift/Cargo.toml

@@ -46,5 +46,6 @@ wmemcheck = ["wasmtime-environ/wmemcheck"]
 gc = ["wasmtime-environ/gc"]
 gc-drc = ["gc", "wasmtime-environ/gc-drc"]
 gc-null = ["gc", "wasmtime-environ/gc-null"]
+gc-copying = ["gc", "wasmtime-environ/gc-copying"]
 stack-switching = []
 threads = ["wasmtime-environ/threads"]

crates/cranelift/src/func_environ/gc.rs

@@ -26,7 +26,10 @@ pub use imp::*;
 
 /// How to initialize a newly-allocated array's elements.
 #[derive(Clone, Copy)]
-#[cfg_attr(not(feature = "gc"), expect(dead_code))]
+#[cfg_attr(
+    not(any(feature = "gc-drc", feature = "gc-null")),
+    allow(dead_code, reason = "easier to define")
+)]
 pub enum ArrayInit<'a> {
     /// Initialize the array's elements with the given values.
     Elems(&'a [ir::Value]),

crates/cranelift/src/func_environ/gc/enabled.rs

@@ -24,6 +24,9 @@ mod drc;
 #[cfg(feature = "gc-null")]
 mod null;
 
+#[cfg(feature = "gc-copying")]
+mod copying;
+
 /// Get the default GC compiler.
 pub fn gc_compiler(func_env: &mut FuncEnvironment<'_>) -> WasmResult<Box<dyn GcCompiler>> {
     // If this function requires a GC compiler, that is not too bad of an
@@ -47,11 +50,19 @@ pub fn gc_compiler(func_env: &mut FuncEnvironment<'_>) -> WasmResult<Box<dyn GcC
              was disabled at compile time",
         )),
 
-        #[cfg(any(feature = "gc-drc", feature = "gc-null"))]
+        #[cfg(feature = "gc-copying")]
+        Some(Collector::Copying) => Ok(Box::new(copying::CopyingCompiler::default())),
+        #[cfg(not(feature = "gc-copying"))]
+        Some(Collector::Copying) => Err(wasm_unsupported!(
+            "the copying collector is unavailable because the `gc-copying` feature \
+             was disabled at compile time",
+        )),
+
+        #[cfg(any(feature = "gc-drc", feature = "gc-null", feature = "gc-copying"))]
         None => Err(wasm_unsupported!(
             "support for GC types disabled at configuration time"
         )),
-        #[cfg(not(any(feature = "gc-drc", feature = "gc-null")))]
+        #[cfg(not(any(feature = "gc-drc", feature = "gc-null", feature = "gc-copying")))]
         None => Err(wasm_unsupported!(
             "support for GC types disabled because no collector implementation \
              was selected at compile time; enable one of the `gc-drc` or \