address review feedback

Author: dicej

crates/environ/src/component/translate/adapt.rs

@@ -208,11 +208,7 @@ impl<'data> Translator<'_, 'data> {
         // the module using standard core wasm translation, and then fills out
         // the dfg metadata for each adapter.
         for (module_id, adapter_module) in state.adapter_modules.iter() {
-            let mut module = fact::Module::new(
-                self.types.types(),
-                self.tunables.debug_adapter_modules,
-                self.tunables.component_model_concurrency,
-            );
+            let mut module = fact::Module::new(self.types.types(), self.tunables);
             let mut names = Vec::with_capacity(adapter_module.adapters.len());
             for adapter in adapter_module.adapters.iter() {
                 let name = format!("adapter{}", adapter.as_u32());

crates/environ/src/fact.rs

@@ -24,7 +24,7 @@ use crate::component::{
     RuntimeComponentInstanceIndex, StringEncoding, Transcode, TypeFuncIndex,
 };
 use crate::fact::transcode::Transcoder;
-use crate::{EntityRef, FuncIndex, GlobalIndex, MemoryIndex, PrimaryMap};
+use crate::{EntityRef, FuncIndex, GlobalIndex, MemoryIndex, PrimaryMap, Tunables};
 use crate::{ModuleInternedTypeIndex, prelude::*};
 use std::collections::HashMap;
 use wasm_encoder::*;
@@ -52,10 +52,8 @@ pub static PREPARE_CALL_FIXED_PARAMS: &[ValType] = &[
 
 /// Representation of an adapter module.
 pub struct Module<'a> {
-    /// Whether or not debug code is inserted into the adapters themselves.
-    debug: bool,
-    /// Whether the `component-model-async` feature is enabled
-    enable_async: bool,
+    /// Compilation configuration
+    tunables: &'a Tunables,
     /// Type information from the creator of this `Module`
     types: &'a ComponentTypesBuilder,
 
@@ -246,10 +244,9 @@ enum HelperLocation {
 
 impl<'a> Module<'a> {
     /// Creates an empty module.
-    pub fn new(types: &'a ComponentTypesBuilder, debug: bool, enable_async: bool) -> Module<'a> {
+    pub fn new(types: &'a ComponentTypesBuilder, tunables: &'a Tunables) -> Module<'a> {
         Module {
-            debug,
-            enable_async,
+            tunables,
             types,
             core_types: Default::default(),
             core_imports: Default::default(),

crates/environ/src/fact/trampoline.rs

@@ -180,7 +180,7 @@ pub(super) fn compile(module: &mut Module<'_>, adapter: &AdapterData) {
             compiler.compile_sync_to_sync_adapter(adapter, &lower_sig, &lift_sig)
         }
         (true, true) => {
-            assert!(module.enable_async);
+            assert!(module.tunables.component_model_concurrency);
 
             // In the async->async case, we must compile a couple of helper functions:
             //
@@ -209,7 +209,7 @@ pub(super) fn compile(module: &mut Module<'_>, adapter: &AdapterData) {
             );
         }
         (false, true) => {
-            assert!(module.enable_async);
+            assert!(module.tunables.component_model_concurrency);
 
             // Like the async->async case above, for the sync->async case we
             // also need `async-start` and `async-return` helper functions to
@@ -235,7 +235,7 @@ pub(super) fn compile(module: &mut Module<'_>, adapter: &AdapterData) {
             );
         }
         (true, false) => {
-            assert!(module.enable_async);
+            assert!(module.tunables.component_model_concurrency);
 
             // As with the async->async and sync->async cases above, for the
             // async->sync case we use `async-start` and `async-return` helper
@@ -759,7 +759,7 @@ impl<'a, 'b> Compiler<'a, 'b> {
             Trap::CannotLeaveComponent,
         );
 
-        let old_task_may_block = if self.module.enable_async {
+        let old_task_may_block = if self.module.tunables.component_model_concurrency {
             // Save, clear, and later restore the `may_block` field.
             let task_may_block = self.module.import_task_may_block();
             let old_task_may_block = if self.types[adapter.lift.ty].async_ {
@@ -871,7 +871,7 @@ impl<'a, 'b> Compiler<'a, 'b> {
             self.instruction(Call(exit.as_u32()));
         }
 
-        if self.module.enable_async {
+        if self.module.tunables.component_model_concurrency {
             // Pop the task we pushed earlier off of the current task stack.
             //
             // FIXME: Apply the optimizations described in #12311.
@@ -1993,7 +1993,7 @@ impl<'a, 'b> Compiler<'a, 'b> {
 
         // In debug mode verify the first result consumed the entire string,
         // otherwise simply discard it.
-        if self.module.debug {
+        if self.module.tunables.debug_adapter_modules {
             self.instruction(LocalGet(src.len.idx));
             self.instruction(LocalGet(src_len_tmp.idx));
             self.ptr_sub(src_mem_opts);
@@ -2020,7 +2020,7 @@ impl<'a, 'b> Compiler<'a, 'b> {
 
         // If the first transcode was enough then assert that the returned
         // amount of destination items written equals the byte size.
-        if self.module.debug {
+        if self.module.tunables.debug_adapter_modules {
             self.instruction(Else);
 
             self.instruction(LocalGet(dst.len.idx));
@@ -2191,7 +2191,7 @@ impl<'a, 'b> Compiler<'a, 'b> {
 
         // Assert that the untagged code unit length is the same as the
         // source code unit length.
-        if self.module.debug {
+        if self.module.tunables.debug_adapter_modules {
             self.instruction(LocalGet(dst.len.idx));
             self.ptr_uconst(dst_mem_opts, !UTF16_TAG);
             self.ptr_and(dst_mem_opts);
@@ -3464,7 +3464,7 @@ impl<'a, 'b> Compiler<'a, 'b> {
 
     fn assert_aligned(&mut self, ty: &InterfaceType, mem: &Memory) {
         let mem_opts = mem.mem_opts();
-        if !self.module.debug {
+        if !self.module.tunables.debug_adapter_modules {
             return;
         }
         let align = self.types.align(mem_opts, ty);
@@ -3654,7 +3654,7 @@ impl<'a, 'b> Compiler<'a, 'b> {
     }
 
     fn assert_i64_upper_bits_not_set(&mut self, local: u32) {
-        if !self.module.debug {
+        if !self.module.tunables.debug_adapter_modules {
             return;
         }
         self.instruction(LocalGet(local));

crates/wasmtime/src/config.rs

@@ -125,7 +125,7 @@ pub struct Config {
     #[cfg(feature = "gc")]
     collector: Collector,
     profiling_strategy: ProfilingStrategy,
-    pub(crate) tunables: ConfigTunables,
+    tunables: ConfigTunables,
 
     #[cfg(feature = "cache")]
     pub(crate) cache: Option<Cache>,
@@ -294,20 +294,6 @@ impl Config {
         )
     }
 
-    pub(crate) fn enable_component_model_concurrency(&self) -> bool {
-        self.enabled_features.contains(WasmFeatures::CM_ASYNC)
-            || self
-                .enabled_features
-                .contains(WasmFeatures::CM_ASYNC_BUILTINS)
-            || self
-                .enabled_features
-                .contains(WasmFeatures::CM_ASYNC_STACKFUL)
-            || self.enabled_features.contains(WasmFeatures::CM_THREADING)
-            || self
-                .enabled_features
-                .contains(WasmFeatures::CM_ERROR_CONTEXT)
-    }
-
     /// Configure whether Wasm compilation is enabled.
     ///
     /// Disabling Wasm compilation will allow you to load and run
@@ -2536,7 +2522,10 @@ impl Config {
             );
         }
 
-        tunables.component_model_concurrency = self.enable_component_model_concurrency();
+        #[cfg(feature = "component-model")]
+        {
+            tunables.component_model_concurrency = self.cm_concurrency_enabled();
+        }
 
         Ok((tunables, features))
     }
@@ -3030,17 +3019,13 @@ impl Config {
     #[inline]
     pub(crate) fn cm_concurrency_enabled(&self) -> bool {
         cfg!(feature = "component-model-async")
-            && (self.enabled_features.contains(WasmFeatures::CM_ASYNC)
-                || self
-                    .enabled_features
-                    .contains(WasmFeatures::CM_ASYNC_BUILTINS)
-                || self
-                    .enabled_features
-                    .contains(WasmFeatures::CM_ASYNC_STACKFUL)
-                || self.enabled_features.contains(WasmFeatures::CM_THREADING)
-                || self
-                    .enabled_features
-                    .contains(WasmFeatures::CM_ERROR_CONTEXT))
+            && self.enabled_features.intersects(
+                WasmFeatures::CM_ASYNC
+                    | WasmFeatures::CM_ASYNC_BUILTINS
+                    | WasmFeatures::CM_ASYNC_STACKFUL
+                    | WasmFeatures::CM_THREADING
+                    | WasmFeatures::CM_ERROR_CONTEXT,
+            )
     }
 }