winch: Refactoring wasmtime compiler integration pieces to share more between Cranelift and Winch

Cargo.toml

@@ -118,6 +118,7 @@ wasmtime = { path = "crates/wasmtime", version = "8.0.0", default-features = fal
 wasmtime-cache = { path = "crates/cache", version = "=8.0.0" }
 wasmtime-cli-flags = { path = "crates/cli-flags", version = "=8.0.0" }
 wasmtime-cranelift = { path = "crates/cranelift", version = "=8.0.0" }
+wasmtime-cranelift-shared = { path = "crates/cranelift-shared", version = "=8.0.0" }
 wasmtime-environ = { path = "crates/environ", version = "=8.0.0" }
 wasmtime-fiber = { path = "crates/fiber", version = "=8.0.0" }
 wasmtime-types = { path = "crates/types", version = "8.0.0" }

cranelift/codegen/meta/src/gen_settings.rs

@@ -21,7 +21,7 @@ pub(crate) enum ParentGroup {
 fn gen_constructor(group: &SettingGroup, parent: ParentGroup, fmt: &mut Formatter) {
     let args = match parent {
         ParentGroup::None => "builder: Builder",
-        ParentGroup::Shared => "shared: &settings::Flags, builder: Builder",
+        ParentGroup::Shared => "shared: &settings::Flags, builder: &Builder",
     };
     fmtln!(fmt, "impl Flags {");
     fmt.indent(|fmt| {

cranelift/codegen/src/isa/mod.rs

@@ -146,16 +146,34 @@ impl fmt::Display for LookupError {
 /// The type of a polymorphic TargetISA object which is 'static.
 pub type OwnedTargetIsa = Arc<dyn TargetIsa>;
 
+/// Type alias of `IsaBuilder` used for building Cranelift's ISAs.
+pub type Builder = IsaBuilder<CodegenResult<OwnedTargetIsa>>;
+
 /// Builder for a `TargetIsa`.
 /// Modify the ISA-specific settings before creating the `TargetIsa` trait object with `finish`.
 #[derive(Clone)]
-pub struct Builder {
+pub struct IsaBuilder<T> {
     triple: Triple,
     setup: settings::Builder,
-    constructor: fn(Triple, settings::Flags, settings::Builder) -> CodegenResult<OwnedTargetIsa>,
+    constructor: fn(Triple, settings::Flags, &settings::Builder) -> T,
 }
 
-impl Builder {
+impl<T> IsaBuilder<T> {
+    /// Creates a new ISA-builder from its components, namely the `triple` for
+    /// the ISA, the ISA-specific settings builder, and a final constructor
+    /// function to generate the ISA from its components.
+    pub fn new(
+        triple: Triple,
+        setup: settings::Builder,
+        constructor: fn(Triple, settings::Flags, &settings::Builder) -> T,
+    ) -> Self {
+        IsaBuilder {
+            triple,
+            setup,
+            constructor,
+        }
+    }
+
     /// Gets the triple for the builder.
     pub fn triple(&self) -> &Triple {
         &self.triple
@@ -172,12 +190,12 @@ impl Builder {
     /// flags are inconsistent or incompatible: for example, some
     /// platform-independent features, like general SIMD support, may
     /// need certain ISA extensions to be enabled.
-    pub fn finish(self, shared_flags: settings::Flags) -> CodegenResult<OwnedTargetIsa> {
-        (self.constructor)(self.triple, shared_flags, self.setup)
+    pub fn finish(&self, shared_flags: settings::Flags) -> T {
+        (self.constructor)(self.triple.clone(), shared_flags, &self.setup)
     }
 }
 
-impl settings::Configurable for Builder {
+impl<T> settings::Configurable for IsaBuilder<T> {
     fn set(&mut self, name: &str, value: &str) -> SetResult<()> {
         self.setup.set(name, value)
     }
@@ -339,24 +357,6 @@ impl<'a> dyn TargetIsa + 'a {
         }
     }
 
-    /// Returns the code (text) section alignment for this ISA.
-    pub fn code_section_alignment(&self) -> u64 {
-        use target_lexicon::*;
-        match (self.triple().operating_system, self.triple().architecture) {
-            (
-                OperatingSystem::MacOSX { .. }
-                | OperatingSystem::Darwin
-                | OperatingSystem::Ios
-                | OperatingSystem::Tvos,
-                Architecture::Aarch64(..),
-            ) => 0x4000,
-            // 64 KB is the maximal page size (i.e. memory translation granule size)
-            // supported by the architecture and is used on some platforms.
-            (_, Architecture::Aarch64(..)) => 0x10000,
-            _ => 0x1000,
-        }
-    }
-
     /// Returns the minimum symbol alignment for this ISA.
     pub fn symbol_alignment(&self) -> u64 {
         match self.triple().architecture {

cranelift/codegen/src/isa/riscv64/inst/emit_tests.rs

@@ -2095,7 +2095,7 @@ fn make_test_flags() -> (settings::Flags, super::super::riscv_settings::Flags) {
     let b = settings::builder();
     let flags = settings::Flags::new(b.clone());
     let b2 = super::super::riscv_settings::builder();
-    let isa_flags = super::super::riscv_settings::Flags::new(&flags, b2);
+    let isa_flags = super::super::riscv_settings::Flags::new(&flags, &b2);
     (flags, isa_flags)
 }
 

cranelift/codegen/src/isa/s390x/inst/emit_tests.rs

@@ -13362,7 +13362,7 @@ fn test_s390x_binemit() {
     use crate::settings::Configurable;
     let mut isa_flag_builder = s390x_settings::builder();
     isa_flag_builder.enable("arch13").unwrap();
-    let isa_flags = s390x_settings::Flags::new(&flags, isa_flag_builder);
+    let isa_flags = s390x_settings::Flags::new(&flags, &isa_flag_builder);
 
     let emit_info = EmitInfo::new(isa_flags);
     for (insn, expected_encoding, expected_printing) in insns {

cranelift/codegen/src/isa/x64/inst/emit_tests.rs

@@ -5155,7 +5155,7 @@ fn test_x64_emit() {
     isa_flag_builder.enable("has_avx512f").unwrap();
     isa_flag_builder.enable("has_avx512vbmi").unwrap();
     isa_flag_builder.enable("has_avx512vl").unwrap();
-    let isa_flags = x64::settings::Flags::new(&flags, isa_flag_builder);
+    let isa_flags = x64::settings::Flags::new(&flags, &isa_flag_builder);
 
     let emit_info = EmitInfo::new(flags, isa_flags);
     for (insn, expected_encoding, expected_printing) in insns {

cranelift/codegen/src/isa/x64/mod.rs

@@ -212,7 +212,7 @@ pub(crate) fn isa_builder(triple: Triple) -> IsaBuilder {
 fn isa_constructor(
     triple: Triple,
     shared_flags: Flags,
-    builder: shared_settings::Builder,
+    builder: &shared_settings::Builder,
 ) -> CodegenResult<OwnedTargetIsa> {
     let isa_flags = x64_settings::Flags::new(&shared_flags, builder);
 

cranelift/codegen/src/lib.rs

@@ -88,7 +88,9 @@ pub mod verifier;
 pub mod write;
 
 pub use crate::entity::packed_option;
-pub use crate::machinst::buffer::{MachCallSite, MachReloc, MachSrcLoc, MachStackMap, MachTrap};
+pub use crate::machinst::buffer::{
+    MachCallSite, MachReloc, MachSrcLoc, MachStackMap, MachTextSectionBuilder, MachTrap,
+};
 pub use crate::machinst::{
     CompiledCode, Final, MachBuffer, MachBufferFinalized, MachInst, MachInstEmit, Reg,
     TextSectionBuilder, Writable,

cranelift/codegen/src/machinst/buffer.rs

@@ -1610,6 +1610,8 @@ pub struct MachTextSectionBuilder<I: VCodeInst> {
 }
 
 impl<I: VCodeInst> MachTextSectionBuilder<I> {
+    /// Creates a new text section builder which will have `num_funcs` functions
+    /// pushed into it.
     pub fn new(num_funcs: usize) -> MachTextSectionBuilder<I> {
         let mut buf = MachBuffer::new();
         buf.reserve_labels_for_blocks(num_funcs);

cranelift/codegen/src/settings.rs

@@ -161,9 +161,9 @@ impl Builder {
     }
 
     /// Extract contents of builder once everything is configured.
-    pub fn state_for(self, name: &str) -> Box<[u8]> {
+    pub fn state_for(&self, name: &str) -> &[u8] {
         assert_eq!(name, self.template.name);
-        self.bytes
+        &self.bytes
     }
 
     /// Iterates the available settings in the builder.

cranelift/native/src/lib.rs

@@ -24,6 +24,7 @@
 )]
 
 use cranelift_codegen::isa;
+use cranelift_codegen::settings::Configurable;
 use target_lexicon::Triple;
 
 /// Return an `isa` builder configured for the current host
@@ -45,19 +46,26 @@ pub fn builder_with_options(infer_native_flags: bool) -> Result<isa::Builder, &'
         isa::LookupError::SupportDisabled => "support for architecture disabled at compile time",
         isa::LookupError::Unsupported => "unsupported architecture",
     })?;
+    if infer_native_flags {
+        self::infer_native_flags(&mut isa_builder)?;
+    }
+    Ok(isa_builder)
+}
 
+/// Return an `isa` builder configured for the current host
+/// machine, or `Err(())` if the host machine is not supported
+/// in the current configuration.
+///
+/// Selects the given backend variant specifically; this is
+/// useful when more than oen backend exists for a given target
+/// (e.g., on x86-64).
+pub fn infer_native_flags(isa_builder: &mut dyn Configurable) -> Result<(), &'static str> {
     #[cfg(target_arch = "x86_64")]
     {
-        use cranelift_codegen::settings::Configurable;
-
         if !std::is_x86_feature_detected!("sse2") {
             return Err("x86 support requires SSE2");
         }
 
-        if !infer_native_flags {
-            return Ok(isa_builder);
-        }
-
         // These are temporarily enabled by default (see #3810 for
         // more) so that a default-constructed `Flags` can work with
         // default Wasmtime features. Otherwise, the user must
@@ -123,12 +131,6 @@ pub fn builder_with_options(infer_native_flags: bool) -> Result<isa::Builder, &'
 
     #[cfg(target_arch = "aarch64")]
     {
-        use cranelift_codegen::settings::Configurable;
-
-        if !infer_native_flags {
-            return Ok(isa_builder);
-        }
-
         if std::arch::is_aarch64_feature_detected!("lse") {
             isa_builder.enable("has_lse").unwrap();
         }
@@ -149,12 +151,6 @@ pub fn builder_with_options(infer_native_flags: bool) -> Result<isa::Builder, &'
     // we use getauxval from the libc crate directly.
     #[cfg(all(target_arch = "s390x", target_os = "linux"))]
     {
-        use cranelift_codegen::settings::Configurable;
-
-        if !infer_native_flags {
-            return Ok(isa_builder);
-        }
-
         let v = unsafe { libc::getauxval(libc::AT_HWCAP) };
         const HWCAP_S390X_VXRS_EXT2: libc::c_ulong = 32768;
         if (v & HWCAP_S390X_VXRS_EXT2) != 0 {
@@ -169,12 +165,6 @@ pub fn builder_with_options(infer_native_flags: bool) -> Result<isa::Builder, &'
     // getauxval from the libc crate directly as a temporary measure.
     #[cfg(all(target_arch = "riscv64", target_os = "linux"))]
     {
-        use cranelift_codegen::settings::Configurable;
-
-        if !infer_native_flags {
-            return Ok(isa_builder);
-        }
-
         let v = unsafe { libc::getauxval(libc::AT_HWCAP) };
 
         const HWCAP_RISCV_EXT_A: libc::c_ulong = 1 << (b'a' - b'a');
@@ -217,12 +207,7 @@ pub fn builder_with_options(infer_native_flags: bool) -> Result<isa::Builder, &'
         // won't have a bit associated with them. The Linux kernel
         // is currently working on a new way to query the extensions.
     }
-
-    // squelch warnings about unused mut/variables on some platforms.
-    drop(&mut isa_builder);
-    drop(infer_native_flags);
-
-    Ok(isa_builder)
+    Ok(())
 }
 
 #[cfg(test)]

crates/cranelift-shared/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "wasmtime-cranelift-shared"
+version.workspace = true
+authors.workspace = true
+description = "Base-level integration with Wasmtime and Cranelift"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+documentation = "https://docs.rs/wasmtime-cranelift-shared/"
+edition.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+wasmtime-environ = { workspace = true }
+cranelift-codegen = { workspace = true }
+cranelift-native = { workspace = true }
+target-lexicon = { workspace = true }
+gimli = { workspace = true }
+object = { workspace = true }