More run-time detection improvements (rust-lang#242)

* [core/runtime] use getauxval on non-x86 platforms

* test coresimd::auxv against auxv crate

* add test files from auxv crate

* [arm] use simd_test macro

* formatting

* missing docs

* improve docs

* reading /proc/self/auxv succeeds only if reading all fields succeeds

* remove cc-crate build dependency

* getauxval succeeds only if hwcap/hwcap2 are non-zero

* fix formatting

* move getauxval to stdsimd

* delete getauxval-wrapper.c

* remove auxv crate dev-dependency from coresimd

Author: gnzlbg

Cargo.toml

@@ -24,6 +24,9 @@ maintenance = { status = "experimental" }
 [dependencies]
 coresimd = { version = "0.0.3", path = "coresimd/" }
 
+[dev-dependencies]
+auxv = "0.3.3"
+
 [profile.release]
 debug = true
 opt-level = 3

coresimd/src/aarch64/neon.rs

@@ -1,4 +1,6 @@
-//! ARMv8 NEON intrinsics
+//! ARMv8 ASIMD intrinsics
+
+// FIXME: replace neon with asimd
 
 #[cfg(test)]
 use stdsimd_test::assert_instr;
@@ -39,41 +41,43 @@ pub unsafe fn vaddd_u64(a: u64, b: u64) -> u64 {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use super::f64x2;
+    use aarch64::neon;
+    use stdsimd_test::simd_test;
 
-    #[test]
-    fn vadd_f64_() {
+    #[simd_test = "neon"]
+    unsafe fn vadd_f64() {
         let a = 1.;
         let b = 8.;
         let e = 9.;
-        let r = unsafe { vadd_f64(a, b) };
+        let r = neon::vadd_f64(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddq_f64_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddq_f64() {
         let a = f64x2::new(1., 2.);
         let b = f64x2::new(8., 7.);
         let e = f64x2::new(9., 9.);
-        let r = unsafe { vaddq_f64(a, b) };
+        let r = neon::vaddq_f64(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddd_s64_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddd_s64() {
         let a = 1;
         let b = 8;
         let e = 9;
-        let r = unsafe { vaddd_s64(a, b) };
+        let r = neon::vaddd_s64(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddd_u64_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddd_u64() {
         let a = 1;
         let b = 8;
         let e = 9;
-        let r = unsafe { vaddd_u64(a, b) };
+        let r = neon::vaddd_u64(a, b);
         assert_eq!(r, e);
     }
 }

coresimd/src/arm/neon.rs

@@ -214,199 +214,201 @@ pub unsafe fn vrsqrte_f32(a: f32x2) -> f32x2 {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use stdsimd_test::simd_test;
+    use simd::*;
+    use arm::neon;
 
-    #[test]
-    fn vadd_s8_() {
+    #[simd_test = "neon"]
+    unsafe fn vadd_s8() {
         let a = i8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
         let b = i8x8::new(8, 7, 6, 5, 4, 3, 2, 1);
         let e = i8x8::new(9, 9, 9, 9, 9, 9, 9, 9);
-        let r = unsafe { vadd_s8(a, b) };
+        let r = neon::vadd_s8(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddq_s8_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddq_s8() {
         let a = i8x16::new(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
         let b = i8x16::new(8, 7, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1);
         let e = i8x16::new(9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
-        let r = unsafe { vaddq_s8(a, b) };
+        let r = neon::vaddq_s8(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vadd_s16_() {
+    #[simd_test = "neon"]
+    unsafe fn vadd_s16() {
         let a = i16x4::new(1, 2, 3, 4);
         let b = i16x4::new(8, 7, 6, 5);
         let e = i16x4::new(9, 9, 9, 9);
-        let r = unsafe { vadd_s16(a, b) };
+        let r = neon::vadd_s16(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddq_s16_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddq_s16() {
         let a = i16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
         let b = i16x8::new(8, 7, 6, 5, 4, 3, 2, 1);
         let e = i16x8::new(9, 9, 9, 9, 9, 9, 9, 9);
-        let r = unsafe { vaddq_s16(a, b) };
+        let r = neon::vaddq_s16(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vadd_s32_() {
+    #[simd_test = "neon"]
+    unsafe fn vadd_s32() {
         let a = i32x2::new(1, 2);
         let b = i32x2::new(8, 7);
         let e = i32x2::new(9, 9);
-        let r = unsafe { vadd_s32(a, b) };
+        let r = neon::vadd_s32(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddq_s32_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddq_s32() {
         let a = i32x4::new(1, 2, 3, 4);
         let b = i32x4::new(8, 7, 6, 5);
         let e = i32x4::new(9, 9, 9, 9);
-        let r = unsafe { vaddq_s32(a, b) };
+        let r = neon::vaddq_s32(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vadd_u8_() {
+    #[simd_test = "neon"]
+    unsafe fn vadd_u8() {
         let a = u8x8::new(1, 2, 3, 4, 5, 6, 7, 8);
         let b = u8x8::new(8, 7, 6, 5, 4, 3, 2, 1);
         let e = u8x8::new(9, 9, 9, 9, 9, 9, 9, 9);
-        let r = unsafe { vadd_u8(a, b) };
+        let r = neon::vadd_u8(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddq_u8_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddq_u8() {
         let a = u8x16::new(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
         let b = u8x16::new(8, 7, 6, 5, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1);
         let e = u8x16::new(9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9);
-        let r = unsafe { vaddq_u8(a, b) };
+        let r = neon::vaddq_u8(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vadd_u16_() {
+    #[simd_test = "neon"]
+    unsafe fn vadd_u16() {
         let a = u16x4::new(1, 2, 3, 4);
         let b = u16x4::new(8, 7, 6, 5);
         let e = u16x4::new(9, 9, 9, 9);
-        let r = unsafe { vadd_u16(a, b) };
+        let r = neon::vadd_u16(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddq_u16_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddq_u16() {
         let a = u16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
         let b = u16x8::new(8, 7, 6, 5, 4, 3, 2, 1);
         let e = u16x8::new(9, 9, 9, 9, 9, 9, 9, 9);
-        let r = unsafe { vaddq_u16(a, b) };
+        let r = neon::vaddq_u16(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vadd_u32_() {
+    #[simd_test = "neon"]
+    unsafe fn vadd_u32() {
         let a = u32x2::new(1, 2);
         let b = u32x2::new(8, 7);
         let e = u32x2::new(9, 9);
-        let r = unsafe { vadd_u32(a, b) };
+        let r = neon::vadd_u32(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddq_u32_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddq_u32() {
         let a = u32x4::new(1, 2, 3, 4);
         let b = u32x4::new(8, 7, 6, 5);
         let e = u32x4::new(9, 9, 9, 9);
-        let r = unsafe { vaddq_u32(a, b) };
+        let r = neon::vaddq_u32(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vadd_f32_() {
+    #[simd_test = "neon"]
+    unsafe fn vadd_f32() {
         let a = f32x2::new(1., 2.);
         let b = f32x2::new(8., 7.);
         let e = f32x2::new(9., 9.);
-        let r = unsafe { vadd_f32(a, b) };
+        let r = neon::vadd_f32(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddq_f32_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddq_f32() {
         let a = f32x4::new(1., 2., 3., 4.);
         let b = f32x4::new(8., 7., 6., 5.);
         let e = f32x4::new(9., 9., 9., 9.);
-        let r = unsafe { vaddq_f32(a, b) };
+        let r = neon::vaddq_f32(a, b);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddl_s8_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddl_s8() {
         let v = ::std::i8::MAX;
         let a = i8x8::new(v, v, v, v, v, v, v, v);
         let v = 2 * (v as i16);
         let e = i16x8::new(v, v, v, v, v, v, v, v);
-        let r = unsafe { vaddl_s8(a, a) };
+        let r = neon::vaddl_s8(a, a);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddl_s16_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddl_s16() {
         let v = ::std::i16::MAX;
         let a = i16x4::new(v, v, v, v);
         let v = 2 * (v as i32);
         let e = i32x4::new(v, v, v, v);
-        let r = unsafe { vaddl_s16(a, a) };
+        let r = neon::vaddl_s16(a, a);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddl_s32_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddl_s32() {
         let v = ::std::i32::MAX;
         let a = i32x2::new(v, v);
         let v = 2 * (v as i64);
         let e = i64x2::new(v, v);
-        let r = unsafe { vaddl_s32(a, a) };
+        let r = neon::vaddl_s32(a, a);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddl_u8_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddl_u8() {
         let v = ::std::u8::MAX;
         let a = u8x8::new(v, v, v, v, v, v, v, v);
         let v = 2 * (v as u16);
         let e = u16x8::new(v, v, v, v, v, v, v, v);
-        let r = unsafe { vaddl_u8(a, a) };
+        let r = neon::vaddl_u8(a, a);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddl_u16_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddl_u16() {
         let v = ::std::u16::MAX;
         let a = u16x4::new(v, v, v, v);
         let v = 2 * (v as u32);
         let e = u32x4::new(v, v, v, v);
-        let r = unsafe { vaddl_u16(a, a) };
+        let r = neon::vaddl_u16(a, a);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vaddl_u32_() {
+    #[simd_test = "neon"]
+    unsafe fn vaddl_u32() {
         let v = ::std::u32::MAX;
         let a = u32x2::new(v, v);
         let v = 2 * (v as u64);
         let e = u64x2::new(v, v);
-        let r = unsafe { vaddl_u32(a, a) };
+        let r = neon::vaddl_u32(a, a);
         assert_eq!(r, e);
     }
 
-    #[test]
-    fn vrsqrt_f32_() {
+    #[simd_test = "neon"]
+    unsafe fn vrsqrt_f32() {
         let a = f32x2::new(1.0, 2.0);
         let e = f32x2::new(0.9980469, 0.7050781);
-        let r = unsafe { vrsqrte_f32(a) };
+        let r = neon::vrsqrte_f32(a);
         assert_eq!(r, e);
     }
 }

coresimd/src/lib.rs

@@ -13,7 +13,8 @@
 #![allow(unused_features)]
 #![feature(const_fn, link_llvm_intrinsics, platform_intrinsics, repr_simd,
            simd_ffi, target_feature, cfg_target_feature, i128_type, asm,
-           const_atomic_usize_new, stmt_expr_attributes, core_intrinsics)]
+           const_atomic_usize_new, stmt_expr_attributes, core_intrinsics,
+           crate_in_paths)]
 #![cfg_attr(test, feature(proc_macro, test, repr_align, attr_literals))]
 #![cfg_attr(feature = "cargo-clippy",
             allow(inline_always, too_many_arguments, cast_sign_loss,
@@ -56,18 +57,32 @@ pub mod vendor {
     #[cfg(not(any(target_arch = "x86", target_arch = "x86_64",
                   target_arch = "arm", target_arch = "aarch64")))]
     pub use nvptx::*;
+}
 
-    #[cfg(
-        // x86/x86_64:
-        any(target_arch = "x86", target_arch = "x86_64")
-    )]
-    pub use runtime::{__unstable_detect_feature, __Feature};
+/// Run-time feature detection.
+#[doc(hidden)]
+pub mod __vendor_runtime {
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64",
+              all(target_os = "linux",
+                  any(target_arch = "arm", target_arch = "aarch64",
+                      target_arch = "powerpc64"))))]
+    pub use runtime::core::*;
+
+    // Re-exports `coresimd` run-time building blocks for usage in the
+    // `stdsimd` run-time.
+    #[cfg(all(target_os = "linux",
+              any(target_arch = "arm", target_arch = "aarch64",
+                  target_arch = "powerpc64")))]
+    #[doc(hidden)]
+    pub mod __runtime {
+        pub use runtime::*;
+    }
 }
 
-#[cfg(
-    // x86/x86_64:
-    any(target_arch = "x86", target_arch = "x86_64")
-)]
+#[cfg(any(target_arch = "x86", target_arch = "x86_64",
+          all(target_os = "linux",
+              any(target_arch = "arm", target_arch = "aarch64",
+                  target_arch = "powerpc64"))))]
 #[macro_use]
 mod runtime;