Refactor how inlining is configured in Wasmtime (#13250)

* Refactor how inlining is configured in Wasmtime

Fold the `inlining` boolean and the `inlining_intra_module` options into
a single `Inlining` enum option. This option encompasses both and has an
additional mode which is "only intrinsics" where inter-module and
intra-module calls are never inlined, but intrinsics for Wasmtime are
allowed to be inlined. This is inspired from discussion on #13214 and
after some performance work and/or confirmations the expectation is to
turn the default inlining mode to `Inlining::Intrinsics`.

* Fix doc example

* Review comments

* Fix benchmark  tests

Author: alexcrichton

benches/compile_time_builtins.rs

@@ -88,11 +88,8 @@ impl ExposedBuf {
 
 fn make_engine() -> Result<Engine, Error> {
     let mut config = Config::new();
-    config.compiler_inlining(true);
+    config.compiler_inlining(wasmtime::Inlining::Yes);
     config.concurrency_support(false);
-    unsafe {
-        config.cranelift_flag_set("wasmtime_inlining_intra_module", "yes");
-    }
     let engine = Engine::new(&config)?;
     Ok(engine)
 }

crates/cli-flags/src/lib.rs

@@ -262,7 +262,9 @@ wasmtime_option_group! {
         pub native_unwind_info: Option<bool>,
 
         /// Whether to perform function inlining during compilation.
-        pub inlining: Option<bool>,
+        #[serde(default)]
+        #[serde(deserialize_with = "crate::opt::cli_parse_wrapper")]
+        pub inlining: Option<wasmtime::Inlining>,
 
         #[prefixed = "cranelift"]
         #[serde(default)]

crates/cli-flags/src/opt.rs

@@ -590,6 +590,20 @@ impl WasmtimeOptionValue for wasmtime::Enabled {
     }
 }
 
+impl WasmtimeOptionValue for wasmtime::Inlining {
+    const VAL_HELP: &'static str = "[=y|n|gc|inter-module|intrinsics]";
+    fn parse(val: Option<&str>) -> Result<Self> {
+        match val {
+            None => Ok(wasmtime::Inlining::Yes),
+            Some(val) => val.parse(),
+        }
+    }
+
+    fn display(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{self}")
+    }
+}
+
 impl WasmtimeOptionValue for WasiNnGraph {
     const VAL_HELP: &'static str = "=<format>::<dir>";
     fn parse(val: Option<&str>) -> Result<Self> {

crates/cranelift/src/builder.rs

@@ -87,9 +87,6 @@ impl CompilerBuilder for Builder {
             "wasmtime_linkopt_force_jump_veneer" => {
                 self.linkopts.force_jump_veneers = value.parse()?;
             }
-            "wasmtime_inlining_intra_module" => {
-                self.tunables.as_mut().unwrap().inlining_intra_module = value.parse()?;
-            }
             "wasmtime_inlining_small_callee_size" => {
                 self.tunables.as_mut().unwrap().inlining_small_callee_size = value.parse()?;
             }

crates/cranelift/src/compiler.rs

@@ -36,9 +36,10 @@ use wasmtime_environ::obj::{ELF_WASMTIME_EXCEPTIONS, ELF_WASMTIME_FRAMES};
 use wasmtime_environ::{
     Abi, AddressMapSection, BuiltinFunctionIndex, CacheStore, CompileError, CompiledFunctionBody,
     DefinedFuncIndex, FlagValue, FrameInstPos, FrameStackShape, FrameStateSlotBuilder,
-    FrameTableBuilder, FuncKey, FunctionBodyData, FunctionLoc, HostCall, InliningCompiler,
-    ModulePC, ModuleTranslation, ModuleTypesBuilder, PtrSize, StackMapSection, StaticModuleIndex,
-    TrapEncodingBuilder, TrapSentinel, TripleExt, Tunables, WasmFuncType, WasmValType, prelude::*,
+    FrameTableBuilder, FuncKey, FunctionBodyData, FunctionLoc, HostCall, Inlining,
+    InliningCompiler, ModulePC, ModuleTranslation, ModuleTypesBuilder, PtrSize, StackMapSection,
+    StaticModuleIndex, TrapEncodingBuilder, TrapSentinel, TripleExt, Tunables, WasmFuncType,
+    WasmValType, prelude::*,
 };
 use wasmtime_unwinder::ExceptionTableBuilder;
 
@@ -325,7 +326,7 @@ impl wasmtime_environ::Compiler for Compiler {
             &mut func_env,
         )?;
 
-        if self.tunables.inlining {
+        if self.tunables.inlining != Inlining::No {
             compiler
                 .cx
                 .codegen_context

crates/environ/src/tunables.rs

@@ -133,10 +133,7 @@ define_tunables! {
 
         /// Whether to enable inlining in Wasmtime's compilation orchestration
         /// or not.
-        pub inlining: bool,
-
-        /// Whether to inline calls within the same core Wasm module or not.
-        pub inlining_intra_module: IntraModuleInlining,
+        pub inlining: Inlining,
 
         /// The size of "small callees" that can be inlined regardless of the
         /// caller's size.
@@ -255,8 +252,7 @@ impl Tunables {
             winch_callable: false,
             signals_based_traps: false,
             memory_init_cow: true,
-            inlining: false,
-            inlining_intra_module: IntraModuleInlining::WhenUsingGc,
+            inlining: Inlining::No,
             inlining_small_callee_size: 50,
             inlining_sum_size_threshold: 2000,
             debug_guest: false,
@@ -426,31 +422,70 @@ impl fmt::Display for Collector {
     }
 }
 
-/// Whether to inline function calls within the same module.
+/// Inlining modes supported by Wasmtime.
 #[derive(Clone, Copy, Hash, Serialize, Deserialize, Debug, PartialEq, Eq)]
-#[expect(missing_docs, reason = "self-describing variants")]
-pub enum IntraModuleInlining {
+pub enum Inlining {
+    /// All inlining is enabled wherever possible.
+    ///
+    /// This includes inter-module inlining (across modules) as well as
+    /// intra-module inlining (within a module).
+    ///
+    /// Note that backtraces may omit inlined stack frames.
     Yes,
+
+    /// Inter-module inlining (across modules) is allowed, but intra-module
+    /// (within a module) is only allowed when the module is using GC.
+    ///
+    /// Note that backtraces may omit inlined stack frames.
+    InterModuleAndIntraGc,
+
+    /// Inter-module inlining (across modules) is allowed, but intra-module
+    /// (within a module) is not allowed.
+    ///
+    /// Note that backtraces may omit inlined stack frames.
+    InterModule,
+
+    /// No module inlining is allowed, either inter- or intra-module. Only
+    /// inlining Wasmtime's intrinsics are allowed.
+    ///
+    /// This option, for example, never emits WebAssembly stack frames from
+    /// backtraces.
+    Intrinsics,
+
+    /// Inlining is disabled entirely.
     No,
-    WhenUsingGc,
 }
 
-impl FromStr for IntraModuleInlining {
+impl FromStr for Inlining {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "y" | "yes" | "true" => Ok(Self::Yes),
             "n" | "no" | "false" => Ok(Self::No),
-            "gc" => Ok(Self::WhenUsingGc),
+            "gc" => Ok(Self::InterModuleAndIntraGc),
+            "inter-module" => Ok(Self::InterModuleAndIntraGc),
+            "intrinsics" => Ok(Self::Intrinsics),
             _ => bail!(
                 "invalid intra-module inlining option string: `{s}`, \
-                 only yes,no,gc accepted"
+                 only yes,no,gc,inter-module,intrinsics accepted"
             ),
         }
     }
 }
 
+impl fmt::Display for Inlining {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Inlining::Yes => write!(f, "yes"),
+            Inlining::InterModuleAndIntraGc => write!(f, "gc"),
+            Inlining::InterModule => write!(f, "inter-module"),
+            Inlining::Intrinsics => write!(f, "intrinsics"),
+            Inlining::No => write!(f, "no"),
+        }
+    }
+}
+
 /// The cost of each operator.
 ///
 /// Note: a more dynamic approach (e.g. a user-supplied callback) can be

crates/fuzzing/src/generators/config.rs

@@ -350,7 +350,7 @@ impl Config {
 
         self.wasmtime.codegen.configure(&mut cfg);
 
-        cfg.codegen.inlining = self.wasmtime.inlining;
+        cfg.codegen.inlining = self.wasmtime.inlining.map(|i| i.into());
 
         // If the wasm-smith-generated module use nan canonicalization then we
         // don't need to enable it, but if it doesn't enable it already then we
@@ -360,12 +360,6 @@ impl Config {
         // Only set cranelift specific flags when the Cranelift strategy is
         // chosen.
         if cranelift_strategy {
-            if let Some(option) = self.wasmtime.inlining_intra_module {
-                cfg.codegen.cranelift.push((
-                    "wasmtime_inlining_intra_module".to_string(),
-                    Some(option.to_string()),
-                ));
-            }
             if let Some(size) = self.wasmtime.inlining_small_callee_size {
                 cfg.codegen.cranelift.push((
                     "wasmtime_inlining_small_callee_size".to_string(),
@@ -579,8 +573,7 @@ pub struct WasmtimeConfig {
     force_jump_veneers: bool,
     memory_init_cow: bool,
     memory_guaranteed_dense_image_size: u64,
-    inlining: Option<bool>,
-    inlining_intra_module: Option<IntraModuleInlining>,
+    inlining: Option<Inlining>,
     inlining_small_callee_size: Option<u32>,
     inlining_sum_size_threshold: Option<u32>,
     use_precompiled_cwasm: bool,
@@ -892,18 +885,33 @@ impl RegallocAlgorithm {
 }
 
 #[derive(Arbitrary, Clone, Copy, Debug, PartialEq, Eq, Hash)]
-enum IntraModuleInlining {
+enum Inlining {
     Yes,
+    InterModuleAndIntraGc,
+    InterModule,
+    Intrinsics,
     No,
-    WhenUsingGc,
 }
 
-impl std::fmt::Display for IntraModuleInlining {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            IntraModuleInlining::Yes => write!(f, "yes"),
-            IntraModuleInlining::No => write!(f, "no"),
-            IntraModuleInlining::WhenUsingGc => write!(f, "gc"),
+impl From<Inlining> for wasmtime::Inlining {
+    fn from(i: Inlining) -> Self {
+        let ret = match i {
+            Inlining::Yes => wasmtime::Inlining::Yes,
+            Inlining::InterModuleAndIntraGc => wasmtime::Inlining::InterModuleAndIntraGc,
+            Inlining::InterModule => wasmtime::Inlining::InterModule,
+            Inlining::Intrinsics => wasmtime::Inlining::Intrinsics,
+            Inlining::No => wasmtime::Inlining::No,
+        };
+
+        match ret {
+            wasmtime::Inlining::Yes
+            | wasmtime::Inlining::No
+            | wasmtime::Inlining::InterModuleAndIntraGc
+            | wasmtime::Inlining::InterModule
+            | wasmtime::Inlining::Intrinsics
+            // NOTE: if you add another arm here, be sure to update the
+            // `Inlining` enum above.
+            => ret,
         }
     }
 }

crates/wasmtime/src/compile.rs

@@ -30,7 +30,7 @@ use std::{any::Any, borrow::Cow, collections::BTreeMap, mem, ops::Range};
 use wasmtime_environ::{
     Abi, CompiledFunctionBody, CompiledFunctionsTable, CompiledFunctionsTableBuilder,
     CompiledModuleInfo, Compiler, DefinedFuncIndex, FilePos, FinishedObject, FuncKey,
-    FunctionBodyData, InliningCompiler, IntraModuleInlining, ModuleEnvironment, ModuleTranslation,
+    FunctionBodyData, Inlining, InliningCompiler, ModuleEnvironment, ModuleTranslation,
     ModuleTypes, ModuleTypesBuilder, ObjectKind, PrimaryMap, StaticModuleIndex, Tunables,
     graphs::{EntityGraph, Graph as _},
 };
@@ -560,7 +560,7 @@ the use case.
         }
 
         let mut raw_outputs = if let Some(inlining_compiler) = compiler.inlining_compiler() {
-            if engine.tunables().inlining {
+            if engine.tunables().inlining != Inlining::No {
                 self.compile_with_inlining(engine, compiler, inlining_compiler)?
             } else {
                 // Inlining compiler but inlining is disabled: compile each
@@ -803,7 +803,7 @@ the use case.
         );
 
         debug_assert!(
-            tunables.inlining,
+            tunables.inlining != Inlining::No,
             "shouldn't even call this method if we aren't configured for inlining"
         );
         debug_assert_ne!(caller_key, callee_key, "we never inline recursion");
@@ -841,29 +841,30 @@ the use case.
             (
                 FuncKey::DefinedWasmFunction(caller_module, _),
                 FuncKey::DefinedWasmFunction(callee_module, _),
-            ) => {
-                if caller_module == callee_module {
-                    match tunables.inlining_intra_module {
-                        IntraModuleInlining::Yes => {}
-
-                        IntraModuleInlining::WhenUsingGc
-                            if caller_needs_gc_heap || callee_needs_gc_heap => {}
-
-                        IntraModuleInlining::WhenUsingGc => {
-                            log::trace!(
-                                "  --> not inlining: intra-module call that does not use GC"
-                            );
-                            return false;
-                        }
+            ) => match tunables.inlining {
+                Inlining::Yes => {}
 
-                        IntraModuleInlining::No => {
-                            log::trace!("  --> not inlining: intra-module call");
-                            return false;
-                        }
+                Inlining::InterModuleAndIntraGc => {
+                    if caller_module == callee_module && !caller_needs_gc_heap {
+                        log::trace!("  --> not inlining: intra-module call where GC is not used");
+                        return false;
                     }
                 }
-            }
 
+                Inlining::InterModule => {
+                    if caller_module == callee_module {
+                        log::trace!("  --> not inlining: only inter-module calls inlined");
+                        return false;
+                    }
+                }
+
+                Inlining::Intrinsics => {
+                    log::trace!("  --> not inlining: only inlining intrinsics");
+                    return false;
+                }
+
+                Inlining::No => unreachable!(),
+            },
             _ => {}
         }
 

crates/wasmtime/src/compile/code_builder.rs

@@ -456,7 +456,7 @@ impl<'a> CodeBuilder<'a> {
     /// // Enable function inlining during compilation. If you are using unsafe intrinsics, you
     /// // almost assuredly want them inlined to avoid function call overheads.
     /// let mut config = Config::new();
-    /// config.compiler_inlining(true);
+    /// config.compiler_inlining(wasmtime::Inlining::Yes);
     ///
     /// let engine = Engine::new(&config)?;
     /// let linker = wasmtime::component::Linker::new(&engine);

crates/wasmtime/src/config.rs

@@ -31,6 +31,7 @@ pub use crate::runtime::code_memory::CustomCodeMemory;
 pub use wasmtime_cache::{Cache, CacheConfig};
 #[cfg(all(feature = "incremental-cache", feature = "cranelift"))]
 pub use wasmtime_environ::CacheStore;
+pub use wasmtime_environ::Inlining;
 
 pub(crate) const DEFAULT_WASM_BACKTRACE_MAX_FRAMES: NonZeroUsize = NonZeroUsize::new(20).unwrap();
 
@@ -2262,9 +2263,8 @@ impl Config {
     /// when using a compilation strategy that does not support inlining, like
     /// Winch.
     ///
-    /// Note that inlining is still somewhat experimental at the moment (as of
-    /// the Wasmtime version 36).
-    pub fn compiler_inlining(&mut self, inlining: bool) -> &mut Self {
+    /// The default value for this is `Inlining::No`.
+    pub fn compiler_inlining(&mut self, inlining: Inlining) -> &mut Self {
         self.tunables.inlining = Some(inlining);
         self
     }
@@ -2564,6 +2564,17 @@ impl Config {
             tunables.signals_based_traps = false;
         }
 
+        // Inlining currently falls over with the `stack_switch` instruction.
+        #[cfg(any(feature = "cranelift", feature = "winch"))]
+        if features.contains(WasmFeatures::STACK_SWITCHING) {
+            if let Some(inlining) = self.tunables.inlining
+                && inlining != Inlining::No
+            {
+                bail!("cannot enable compiler inlining when stack switching is enabled");
+            }
+            tunables.inlining = Inlining::No;
+        }
+
         self.tunables.configure(&mut tunables);
 
         // If no GC heap tunables are explicitly configured, copy the memory