Add the generated x86 code

Author: DJMcNab

fearless_simd_core/src/x86/adx/adx.rs

@@ -0,0 +1,92 @@
+// This file is automatically generated by `fearless_simd_core_gen`.
+// Its template can be found in `fearless_simd_core/gen/templates`.
+
+//! The ADX target feature.
+
+use crate::{TargetFeatureToken, trampoline};
+
+use core::fmt::Debug;
+
+/// [ADX] --- Multi-Precision Add-Carry Instruction Extensions
+///
+/// [ADX]: https://en.wikipedia.org/wiki/Intel_ADX
+///
+/// A token indicating that the current CPU has the `adx` target feature.
+///
+/// # Example
+///
+/// This can be used to [`trampoline!`] into functions like:
+///
+/// ```rust
+/// #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+/// #[target_feature(enable = "adx")]
+/// fn uses_adx() {
+///     // ...
+/// }
+/// ```
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Adx {
+    // We don't use non_exhaustive because we don't want this struct to be constructible.
+    // in different modules in this crate.
+    _private: (),
+}
+
+impl Debug for Adx {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, r#""adx" enabled."#)
+    }
+}
+
+unsafe impl TargetFeatureToken for Adx {
+    const FEATURES: &[&str] = &["adx"];
+
+    #[inline(always)]
+    fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
+        // Because we want this constant to be eagerly evaluated.
+        trampoline!([Adx = self] => "adx", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
+    }
+}
+
+impl Adx {
+    #[cfg(feature = "std")]
+    /// Create a new token if the `"adx"` target feature is detected as enabled.
+    ///
+    /// This does not do any caching internally, although note that the standard
+    /// library does internally cache the features it detects.
+    // TODO: Consider a manual override feature/env var?
+    pub fn try_new() -> Option<Self> {
+        // Feature flag required to make docs compile.
+        // TODO: Extract into a (private) crate::x86::is_x86_feature_detected?
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        if std::arch::is_x86_feature_detected!("adx") {
+            // Safety: The required CPU feature was detected.
+            unsafe { Some(Self::new()) }
+        } else {
+            None
+        }
+    }
+
+    #[target_feature(enable = "adx")]
+    /// Create a new token for the "adx" target feature.
+    ///
+    /// This method is useful to get a new token if you have an external proof that
+    /// ADX is available. This could happen if you are in a target feature
+    /// function called by an external library user.
+    ///
+    /// # Safety
+    ///
+    /// No conditions other than those inherited from the target feature attribute,
+    /// i.e. that the "adx" target feature is available.
+    ///
+    /// [implicitly enables]: https://doc.rust-lang.org/beta/reference/attributes/codegen.html?highlight=implicitly%20enabled#r-attributes.codegen.target_feature.safety-restrictions
+    pub fn new() -> Self {
+        Self { _private: () }
+    }
+}
+
+const _: () = {
+    assert!(
+        core::mem::size_of::<Adx>() == 0,
+        "Target feature tokens should be zero sized."
+    );
+};

fearless_simd_core/src/x86/adx/mod.rs

@@ -0,0 +1,8 @@
+//! The "adx" target feature.
+
+#[expect(
+    clippy::module_inception,
+    reason = "The inner module is automatically generated."
+)]
+mod adx;
+pub use adx::Adx;

fearless_simd_core/src/x86/avx/avx.rs

@@ -0,0 +1,134 @@
+// This file is automatically generated by `fearless_simd_core_gen`.
+// Its template can be found in `fearless_simd_core/gen/templates`.
+
+//! The AVX target feature.
+
+use crate::{TargetFeatureToken, trampoline};
+
+use core::fmt::Debug;
+
+/// [AVX] --- Advanced Vector Extensions
+///
+/// [AVX]: https://en.wikipedia.org/wiki/Advanced_Vector_Extensions
+///
+/// A token indicating that the current CPU has the `avx` target feature.
+///
+/// # Example
+///
+/// This can be used to [`trampoline!`] into functions like:
+///
+/// ```rust
+/// #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+/// #[target_feature(enable = "avx")]
+/// fn uses_avx() {
+///     // ...
+/// }
+/// ```
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Avx {
+    // We don't use non_exhaustive because we don't want this struct to be constructible.
+    // in different modules in this crate.
+    _private: (),
+}
+
+impl Debug for Avx {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, r#""avx" enabled."#)
+    }
+}
+
+unsafe impl TargetFeatureToken for Avx {
+    const FEATURES: &[&str] = &["avx", "sse", "sse2", "sse3", "sse4.1", "sse4.2", "ssse3"];
+
+    #[inline(always)]
+    fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
+        // Because we want this constant to be eagerly evaluated.
+        trampoline!([Avx = self] => "avx", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
+    }
+}
+
+impl Avx {
+    #[cfg(feature = "std")]
+    /// Create a new token if the `"avx"` target feature is detected as enabled.
+    ///
+    /// This does not do any caching internally, although note that the standard
+    /// library does internally cache the features it detects.
+    // TODO: Consider a manual override feature/env var?
+    pub fn try_new() -> Option<Self> {
+        // Feature flag required to make docs compile.
+        // TODO: Extract into a (private) crate::x86::is_x86_feature_detected?
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        if std::arch::is_x86_feature_detected!("avx") {
+            // Safety: The required CPU feature was detected.
+            unsafe { Some(Self::new()) }
+        } else {
+            None
+        }
+    }
+
+    #[target_feature(enable = "avx")]
+    /// Create a new token for the "avx" target feature.
+    ///
+    /// This method is useful to get a new token if you have an external proof that
+    /// AVX is available. This could happen if you are in a target feature
+    /// function called by an external library user.
+    ///
+    /// # Safety
+    ///
+    /// No conditions other than those inherited from the target feature attribute,
+    /// i.e. that the "avx" target feature is available.
+    ///
+    /// [implicitly enables]: https://doc.rust-lang.org/beta/reference/attributes/codegen.html?highlight=implicitly%20enabled#r-attributes.codegen.target_feature.safety-restrictions
+    pub fn new() -> Self {
+        Self { _private: () }
+    }
+}
+
+impl From<Avx> for crate::x86::sse::Sse {
+    fn from(value: Avx) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx = value] => "avx", fn() -> crate::x86::sse::Sse { crate::x86::sse::Sse::new() })
+    }
+}
+
+impl From<Avx> for crate::x86::sse::Sse2 {
+    fn from(value: Avx) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx = value] => "avx", fn() -> crate::x86::sse::Sse2 { crate::x86::sse::Sse2::new() })
+    }
+}
+
+impl From<Avx> for crate::x86::sse::Sse3 {
+    fn from(value: Avx) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx = value] => "avx", fn() -> crate::x86::sse::Sse3 { crate::x86::sse::Sse3::new() })
+    }
+}
+
+impl From<Avx> for crate::x86::sse::Sse4_1 {
+    fn from(value: Avx) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx = value] => "avx", fn() -> crate::x86::sse::Sse4_1 { crate::x86::sse::Sse4_1::new() })
+    }
+}
+
+impl From<Avx> for crate::x86::sse::Sse4_2 {
+    fn from(value: Avx) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx = value] => "avx", fn() -> crate::x86::sse::Sse4_2 { crate::x86::sse::Sse4_2::new() })
+    }
+}
+
+impl From<Avx> for crate::x86::sse::SupplementalSse3 {
+    fn from(value: Avx) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx = value] => "avx", fn() -> crate::x86::sse::SupplementalSse3 { crate::x86::sse::SupplementalSse3::new() })
+    }
+}
+
+const _: () = {
+    assert!(
+        core::mem::size_of::<Avx>() == 0,
+        "Target feature tokens should be zero sized."
+    );
+};

fearless_simd_core/src/x86/avx/avx2.rs

@@ -0,0 +1,143 @@
+// This file is automatically generated by `fearless_simd_core_gen`.
+// Its template can be found in `fearless_simd_core/gen/templates`.
+
+//! The AVX2 target feature.
+
+use crate::{TargetFeatureToken, trampoline};
+
+use core::fmt::Debug;
+
+/// [AVX2] --- Advanced Vector Extensions 2
+///
+/// [AVX2]: https://en.wikipedia.org/wiki/Advanced_Vector_Extensions#AVX2
+///
+/// A token indicating that the current CPU has the `avx2` target feature.
+///
+/// # Example
+///
+/// This can be used to [`trampoline!`] into functions like:
+///
+/// ```rust
+/// #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+/// #[target_feature(enable = "avx2")]
+/// fn uses_avx2() {
+///     // ...
+/// }
+/// ```
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Avx2 {
+    // We don't use non_exhaustive because we don't want this struct to be constructible.
+    // in different modules in this crate.
+    _private: (),
+}
+
+impl Debug for Avx2 {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, r#""avx2" enabled."#)
+    }
+}
+
+unsafe impl TargetFeatureToken for Avx2 {
+    const FEATURES: &[&str] = &[
+        "avx2", "avx", "sse", "sse2", "sse3", "sse4.1", "sse4.2", "ssse3",
+    ];
+
+    #[inline(always)]
+    fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
+        // Because we want this constant to be eagerly evaluated.
+        trampoline!([Avx2 = self] => "avx2", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
+    }
+}
+
+impl Avx2 {
+    #[cfg(feature = "std")]
+    /// Create a new token if the `"avx2"` target feature is detected as enabled.
+    ///
+    /// This does not do any caching internally, although note that the standard
+    /// library does internally cache the features it detects.
+    // TODO: Consider a manual override feature/env var?
+    pub fn try_new() -> Option<Self> {
+        // Feature flag required to make docs compile.
+        // TODO: Extract into a (private) crate::x86::is_x86_feature_detected?
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        if std::arch::is_x86_feature_detected!("avx2") {
+            // Safety: The required CPU feature was detected.
+            unsafe { Some(Self::new()) }
+        } else {
+            None
+        }
+    }
+
+    #[target_feature(enable = "avx2")]
+    /// Create a new token for the "avx2" target feature.
+    ///
+    /// This method is useful to get a new token if you have an external proof that
+    /// AVX2 is available. This could happen if you are in a target feature
+    /// function called by an external library user.
+    ///
+    /// # Safety
+    ///
+    /// No conditions other than those inherited from the target feature attribute,
+    /// i.e. that the "avx2" target feature is available.
+    ///
+    /// [implicitly enables]: https://doc.rust-lang.org/beta/reference/attributes/codegen.html?highlight=implicitly%20enabled#r-attributes.codegen.target_feature.safety-restrictions
+    pub fn new() -> Self {
+        Self { _private: () }
+    }
+}
+
+impl From<Avx2> for crate::x86::avx::Avx {
+    fn from(value: Avx2) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx2 = value] => "avx2", fn() -> crate::x86::avx::Avx { crate::x86::avx::Avx::new() })
+    }
+}
+
+impl From<Avx2> for crate::x86::sse::Sse {
+    fn from(value: Avx2) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx2 = value] => "avx2", fn() -> crate::x86::sse::Sse { crate::x86::sse::Sse::new() })
+    }
+}
+
+impl From<Avx2> for crate::x86::sse::Sse2 {
+    fn from(value: Avx2) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx2 = value] => "avx2", fn() -> crate::x86::sse::Sse2 { crate::x86::sse::Sse2::new() })
+    }
+}
+
+impl From<Avx2> for crate::x86::sse::Sse3 {
+    fn from(value: Avx2) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx2 = value] => "avx2", fn() -> crate::x86::sse::Sse3 { crate::x86::sse::Sse3::new() })
+    }
+}
+
+impl From<Avx2> for crate::x86::sse::Sse4_1 {
+    fn from(value: Avx2) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx2 = value] => "avx2", fn() -> crate::x86::sse::Sse4_1 { crate::x86::sse::Sse4_1::new() })
+    }
+}
+
+impl From<Avx2> for crate::x86::sse::Sse4_2 {
+    fn from(value: Avx2) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx2 = value] => "avx2", fn() -> crate::x86::sse::Sse4_2 { crate::x86::sse::Sse4_2::new() })
+    }
+}
+
+impl From<Avx2> for crate::x86::sse::SupplementalSse3 {
+    fn from(value: Avx2) -> Self {
+        // This also serves as a correctness check of the implicitly enabled features.
+        trampoline!([Avx2 = value] => "avx2", fn() -> crate::x86::sse::SupplementalSse3 { crate::x86::sse::SupplementalSse3::new() })
+    }
+}
+
+const _: () = {
+    assert!(
+        core::mem::size_of::<Avx2>() == 0,
+        "Target feature tokens should be zero sized."
+    );
+};