Add Config::without_compiler (#12089)

* Add `Config::without_compiler`

This provides us an allocation-free path for constructing a `Config`.

Why not rely on builds when `cfg(not(any(feature = "cranelift", feature =
"winch")))`? Because we need to test our various OOM-handling and
allocation-free code paths in this workspace, and without some way to create a
config without a compiler otherwise, cargo's feature resolver will enable those
features in the workspace, enabling the compiler in the config, but we don't
intend to make compiler configurations handle OOM.

* Quiet unused mut warnings

* Move default compiler flags into builder

Author: fitzgen

crates/cranelift/src/builder.rs

@@ -39,15 +39,28 @@ pub struct LinkOptions {
 }
 
 pub fn builder(triple: Option<Triple>) -> Result<Box<dyn CompilerBuilder>> {
-    Ok(Box::new(Builder {
+    let mut builder = Builder {
         tunables: None,
         inner: IsaBuilder::new(triple, |triple| isa::lookup(triple).map_err(|e| e.into()))?,
         linkopts: LinkOptions::default(),
         cache_store: None,
         clif_dir: None,
         wmemcheck: false,
         emit_debug_checks: false,
-    }))
+    };
+
+    builder.set("enable_verifier", "false").unwrap();
+    builder.set("opt_level", "speed").unwrap();
+
+    // When running under MIRI try to optimize for compile time of Wasm code
+    // itself as much as possible. Disable optimizations by default and use the
+    // fastest regalloc available to us.
+    if cfg!(miri) {
+        builder.set("opt_level", "none").unwrap();
+        builder.set("regalloc_algorithm", "single_pass").unwrap();
+    }
+
+    Ok(Box::new(builder))
 }
 
 impl CompilerBuilder for Builder {

crates/fuzzing/tests/oom.rs

@@ -1,5 +1,5 @@
 use std::alloc::{Layout, alloc};
-use wasmtime::Result;
+use wasmtime::{Config, Result};
 use wasmtime_fuzzing::oom::{OomTest, OomTestAllocator};
 
 #[global_allocator]
@@ -25,3 +25,12 @@ fn smoke_test_missed_oom() -> Result<()> {
     );
     Ok(())
 }
+
+#[test]
+fn config_new() -> Result<()> {
+    OomTest::new().test(|| {
+        let mut config = Config::new();
+        config.enable_compiler(false);
+        Ok(())
+    })
+}

crates/wasmtime/src/compile.rs

@@ -70,6 +70,7 @@ pub(crate) fn build_module_artifacts<T: FinishedObject>(
     T,
     Option<(CompiledModuleInfo, CompiledFunctionsTable, ModuleTypes)>,
 )> {
+    let compiler = engine.try_compiler()?;
     let tunables = engine.tunables();
 
     // First a `ModuleEnvironment` is created which records type information
@@ -101,7 +102,7 @@ pub(crate) fn build_module_artifacts<T: FinishedObject>(
 
     // Emplace all compiled functions into the object file with any other
     // sections associated with code as well.
-    let mut object = engine.compiler().object(ObjectKind::Module)?;
+    let mut object = compiler.object(ObjectKind::Module)?;
     // Insert `Engine` and type-level information into the compiled
     // artifact so if this module is deserialized later it contains all
     // information necessary.
@@ -111,7 +112,7 @@ pub(crate) fn build_module_artifacts<T: FinishedObject>(
     // They're only used during deserialization and not during runtime for
     // the module itself. Currently there's no need for that, however, so
     // it's left as an exercise for later.
-    engine.append_compiler_info(&mut object);
+    engine.append_compiler_info(&mut object)?;
     engine.append_bti(&mut object);
 
     let (mut object, compilation_artifacts) = indices.link_and_append_code(
@@ -150,8 +151,8 @@ pub(crate) fn build_component_artifacts<T: FinishedObject>(
         CompiledComponentInfo, ComponentArtifacts, ComponentTypesBuilder,
     };
 
+    let compiler = engine.try_compiler()?;
     let tunables = engine.tunables();
-    let compiler = engine.compiler();
 
     let scope = ScopeVec::new();
     let mut validator = wasmparser::Validator::new_with_features(engine.features());
@@ -185,7 +186,7 @@ pub(crate) fn build_component_artifacts<T: FinishedObject>(
     }
 
     let mut object = compiler.object(ObjectKind::Component)?;
-    engine.append_compiler_info(&mut object);
+    engine.append_compiler_info(&mut object)?;
     engine.append_bti(&mut object);
 
     let (mut object, compilation_artifacts) = indices.link_and_append_code(
@@ -520,7 +521,7 @@ impl<'a> CompileInputs<'a> {
     /// Compile these `CompileInput`s (maybe in parallel) and return the
     /// resulting `UnlinkedCompileOutput`s.
     fn compile(self, engine: &Engine) -> Result<UnlinkedCompileOutputs<'a>> {
-        let compiler = engine.compiler();
+        let compiler = engine.try_compiler()?;
 
         if self.inputs.len() > 0 && cfg!(miri) {
             bail!(
@@ -912,7 +913,7 @@ the use case.
 }
 
 fn compile_required_builtins(engine: &Engine, raw_outputs: &mut Vec<CompileOutput>) -> Result<()> {
-    let compiler = engine.compiler();
+    let compiler = engine.try_compiler()?;
     let mut builtins = HashSet::new();
     let mut new_inputs: Vec<CompileInput<'_>> = Vec::new();
 
@@ -1040,7 +1041,7 @@ impl FunctionIndices {
         // The result is a vector parallel to `compiled_funcs` where
         // `symbol_ids_and_locs[i]` is the symbol ID and function location of
         // `compiled_funcs[i]`.
-        let compiler = engine.compiler();
+        let compiler = engine.try_compiler()?;
         let tunables = engine.tunables();
         let symbol_ids_and_locs = compiler.append_code(
             &mut obj,

crates/wasmtime/src/compile/code_builder.rs

@@ -808,10 +808,11 @@ pub struct HashedEngineCompileEnv<'a>(pub &'a Engine);
 impl std::hash::Hash for HashedEngineCompileEnv<'_> {
     fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
         // Hash the compiler's state based on its target and configuration.
-        let compiler = self.0.compiler();
-        compiler.triple().hash(hasher);
-        compiler.flags().hash(hasher);
-        compiler.isa_flags().hash(hasher);
+        if let Some(compiler) = self.0.compiler() {
+            compiler.triple().hash(hasher);
+            compiler.flags().hash(hasher);
+            compiler.isa_flags().hash(hasher);
+        }
 
         // Hash configuration state read for compilation
         let config = self.0.config();