Rip out core::arch wrappers

Author: Shnatsel

fearless_simd/Cargo.toml

@@ -26,10 +26,6 @@ std = []
 # Use floating point implementations from libm
 libm = ["dep:libm"]
 
-# Include safe wrappers for (some) target feature specific intrinsics,
-# beyond the basic SIMD operations abstracted on all platforms
-safe_wrappers = []
-
 # Force the "fallback" SIMD level to be supported
 # This is primarily used for tests
 force_support_fallback = []

fearless_simd/README.md

@@ -151,8 +151,6 @@ The following crate [feature flags](https://doc.rust-lang.org/cargo/reference/fe
 - `std` (enabled by default): Get floating point functions from the standard library (likely using your target's libc).
   Also allows using [`Level::new`] on all platforms, to detect which target features are enabled.
 - `libm`: Use floating point implementations from [libm].
-- `safe_wrappers`: Include safe wrappers for (some) target feature specific intrinsics,
-  beyond the basic SIMD operations abstracted on all platforms.
 - `force_support_fallback`: Force scalar fallback, to be supported, even if your compilation target has a better baseline.
 
 At least one of `std` and `libm` is required; `std` overrides `libm`.

fearless_simd/examples/play.rs

@@ -30,26 +30,10 @@ fn foo<S: Simd>(simd: S, x: f32) -> f32 {
     simd.splat_f32x4(x).sqrt()[0]
 }
 
-// currently requires `safe_wrappers` feature
-fn do_something_on_neon(_level: Level) -> f32 {
-    #[cfg(all(feature = "safe_wrappers", target_arch = "aarch64"))]
-    if let Some(neon) = _level.as_neon() {
-        return neon.vectorize(
-            #[inline(always)]
-            || {
-                let v = neon.neon.vdupq_n_f32(42.0);
-                neon.neon.vgetq_lane_f32::<0>(v)
-            },
-        );
-    }
-    0.0
-}
-
 fn main() {
     let level = Level::new();
     let x = level.dispatch(Foo);
     let y = dispatch!(level, simd => foo(simd, 42.0));
-    let z = do_something_on_neon(level);
 
-    println!("level = {level:?}, x = {x}, y = {y}, z = {z}");
+    println!("level = {level:?}, x = {x}, y = {y}");
 }

fearless_simd/examples/srgb.rs

@@ -8,32 +8,6 @@
 
 use fearless_simd::{Level, dispatch, f32x4, prelude::*};
 
-// This block shows how to use safe wrappers for compile-time enforcement
-// of using valid SIMD intrinsics.
-#[cfg(feature = "safe_wrappers")]
-#[inline(always)]
-fn copy_alpha<S: Simd>(a: f32x4<S>, b: f32x4<S>) -> f32x4<S> {
-    // #[cfg(target_arch = "x86_64")]
-    // if let Some(avx2) = a.simd.level().as_avx2() {
-    //     return avx2
-    //         .sse4_1
-    //         ._mm_blend_ps::<8>(a.into(), b.into())
-    //         .simd_into(a.simd);
-    // }
-    #[cfg(target_arch = "aarch64")]
-    if let Some(neon) = a.simd.level().as_neon() {
-        return neon
-            .neon
-            .vcopyq_laneq_f32::<3, 3>(a.into(), b.into())
-            .simd_into(a.simd);
-    }
-    let mut result = a;
-    result[3] = b[3];
-    result
-}
-
-// This block lets the example compile without safe wrappers.
-#[cfg(not(feature = "safe_wrappers"))]
 #[inline(always)]
 fn copy_alpha<S: Simd>(a: f32x4<S>, b: f32x4<S>) -> f32x4<S> {
     #[cfg(target_arch = "aarch64")]

fearless_simd/src/core_arch/aarch64/mod.rs

@@ -1,7 +1,7 @@
 // Copyright 2024 the Fearless_SIMD Authors
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 
-//! Access to architecture-specific intrinsics.
+//! Architecture-specific SIMD proof tokens.
 
 #![expect(
     missing_docs,