Change how wasm features/gc support work in Config (bytecodealliance#11463)

This commit aims to address bytecodealliance#11450 in complementary but somewhat
orthogonal ways. First a new `Config::gc_support` option is added which
is hooked up to the CLI as `-Wgc-support`. This option controls the
wasmparser-internal `GC_TYPES` feature. Its default value, like before,
is `cfg!(feature = "gc")` and additionally enabling it requires the `gc`
crate feature to be enabled.

This commit then additionally updates how wasm features are processed
during validating a deserialized module to only require enabled features
to be enabled in the host. Previously modules that disabled a feature
but the feature was enabled in the host would fail to deserialize. All
WebAssembly proposals are additive, however, so it's always ok to
disable a feature and then load it into a module that enables the wasm
proposal.

Closes bytecodealliance#11450

Author: alexcrichton

crates/cli-flags/src/lib.rs

@@ -403,6 +403,8 @@ wasmtime_option_group! {
         pub exceptions: Option<bool>,
         /// DEPRECATED: Configure support for the legacy exceptions proposal.
         pub legacy_exceptions: Option<bool>,
+        /// Whether or not any GC infrastructure in Wasmtime is enabled or not.
+        pub gc_support: Option<bool>,
     }
 
     enum Wasm {
@@ -990,6 +992,10 @@ impl CommonOptions {
             true => err,
         }
 
+        if let Some(enable) = self.wasm.gc_support {
+            config.gc_support(enable);
+        }
+
         Ok(config)
     }
 

crates/wasmtime/src/config.rs

@@ -2226,11 +2226,14 @@ impl Config {
         if self.max_wasm_stack == 0 {
             bail!("max_wasm_stack size cannot be zero");
         }
-        #[cfg(not(feature = "wmemcheck"))]
-        if self.wmemcheck {
+        if !cfg!(feature = "wmemcheck") && self.wmemcheck {
             bail!("wmemcheck (memory checker) was requested but is not enabled in this build");
         }
 
+        if !cfg!(feature = "gc") && features.gc_types() {
+            bail!("support for GC was disabled at compile time")
+        }
+
         let mut tunables = Tunables::default_for_target(&self.compiler_target())?;
 
         // If no target is explicitly specified then further refine `tunables`
@@ -2675,6 +2678,20 @@ impl Config {
         self.tunables.signals_based_traps = Some(enable);
         self
     }
+
+    /// Enable/disable GC support in Wasmtime entirely.
+    ///
+    /// This flag can be used to gate whether GC infrastructure is enabled or
+    /// initialized in Wasmtime at all. Wasmtime's GC implementation is required
+    /// for the [`Self::wasm_gc`] proposal, [`Self::wasm_function_references`],
+    /// and [`Self::wasm_exceptions`] at this time. None of those proposal can
+    /// be enabled without also having this option enabled.
+    ///
+    /// This option defaults to whether the crate `gc` feature is enabled or
+    /// not.
+    pub fn gc_support(&mut self, enable: bool) -> &mut Self {
+        self.wasm_feature(WasmFeatures::GC_TYPES, enable)
+    }
 }
 
 impl Default for Config {

crates/wasmtime/src/engine/serialization.rs

@@ -376,76 +376,29 @@ impl Metadata<'_> {
         Ok(())
     }
 
-    fn check_cfg_bool(
-        cfg: bool,
-        cfg_str: &str,
-        found: bool,
-        expected: bool,
-        feature: impl fmt::Display,
-    ) -> Result<()> {
-        if cfg {
-            Self::check_bool(found, expected, feature)
-        } else {
-            assert!(!expected);
-            ensure!(
-                !found,
-                "Module was compiled with {feature} but support in the host \
-                 was disabled at compile time because the `{cfg_str}` Cargo \
-                 feature was not enabled",
-            );
-            Ok(())
-        }
-    }
-
     fn check_features(&mut self, other: &wasmparser::WasmFeatures) -> Result<()> {
         let module_features = wasmparser::WasmFeatures::from_bits_truncate(self.features);
-        let difference = *other ^ module_features;
-        for (name, flag) in difference.iter_names() {
-            let found = module_features.contains(flag);
-            let expected = other.contains(flag);
-            // Give a slightly more specialized error message for the `GC_TYPES`
-            // feature which isn't actually part of wasm itself but is gated by
-            // compile-time crate features.
-            if flag == wasmparser::WasmFeatures::GC_TYPES {
-                Self::check_cfg_bool(
-                    cfg!(feature = "gc"),
-                    "gc",
-                    found,
-                    expected,
-                    WasmFeature(name),
-                )?;
-            } else {
-                Self::check_bool(found, expected, WasmFeature(name))?;
-            }
-        }
-
-        return Ok(());
-
-        struct WasmFeature<'a>(&'a str);
-
-        impl fmt::Display for WasmFeature<'_> {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                write!(f, "support for WebAssembly feature `")?;
-                for c in self.0.chars().map(|c| c.to_lowercase()) {
-                    write!(f, "{c}")?;
-                }
-                write!(f, "`")?;
-                Ok(())
-            }
+        let missing_features = (*other & module_features) ^ module_features;
+        for (name, _) in missing_features.iter_names() {
+            let name = name.to_ascii_lowercase();
+            bail!(
+                "Module was compiled with support for WebAssembly feature \
+                `{name}` but it is not enabled for the host",
+            );
         }
+        Ok(())
     }
 
     fn check_collector(
         module: Option<wasmtime_environ::Collector>,
         host: Option<wasmtime_environ::Collector>,
     ) -> Result<()> {
         match (module, host) {
-            (None, None) => Ok(()),
+            // If the module doesn't require GC support it doesn't matter
+            // whether the host has GC support enabled or not.
+            (None, _) => Ok(()),
             (Some(module), Some(host)) if module == host => Ok(()),
 
-            (None, Some(_)) => {
-                bail!("module was compiled without GC but GC is enabled in the host")
-            }
             (Some(_), None) => {
                 bail!("module was compiled with GC however GC is disabled in the host")
             }
@@ -647,14 +600,9 @@ Caused by:
         let mut metadata = Metadata::new(&engine);
         metadata.features &= !wasmparser::WasmFeatures::THREADS.bits();
 
-        match metadata.check_compatible(&engine) {
-            Ok(_) => unreachable!(),
-            Err(e) => assert_eq!(
-                e.to_string(),
-                "Module was compiled without support for WebAssembly feature \
-                 `threads` but it is enabled for the host"
-            ),
-        }
+        // If a feature is disabled in the module and enabled in the host,
+        // that's always ok.
+        metadata.check_compatible(&engine)?;
 
         let mut config = Config::new();
         config.wasm_threads(false);