So many test updates x_x

Author: scottmcm

tests/auxiliary/minisimd.rs

@@ -0,0 +1,160 @@
+//! Auxiliary crate for tests that need SIMD types.
+//!
+//! Historically the tests just made their own, but projections into simd types
+//! was banned by <https://github.com/rust-lang/compiler-team/issues/838>, which
+//! breaks `derive(Clone)`, so this exists to give easily-usable types that can
+//! be used without copy-pasting the definitions of the helpers everywhere.
+//!
+//! This makes no attempt to guard against ICEs.  Using it with proper types
+//! and such is your responsibility in the tests you write.
+
+#![allow(unused)]
+#![allow(non_camel_case_types)]
+
+// The field is currently left `pub` for convenience in porting tests, many of
+// which attempt to just construct it directly. That still works; it's just the
+// `.0` projection that doesn't.
+#[repr(simd)]
+#[derive(Copy, Eq)]
+pub struct Simd<T, const N: usize>(pub [T; N]);
+
+impl<T: Copy, const N: usize> Clone for Simd<T, N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: PartialEq, const N: usize> PartialEq for Simd<T, N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_array() == other.as_array()
+    }
+}
+
+impl<T: core::fmt::Debug, const N: usize> core::fmt::Debug for Simd<T, N> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
+        <[T; N] as core::fmt::Debug>::fmt(self.as_array(), f)
+    }
+}
+
+impl<T, const N: usize> core::ops::Index<usize> for Simd<T, N> {
+    type Output = T;
+    fn index(&self, i: usize) -> &T {
+        &self.as_array()[i]
+    }
+}
+
+impl<T, const N: usize> Simd<T, N> {
+    pub const fn from_array(a: [T; N]) -> Self {
+        Simd(a)
+    }
+    pub fn as_array(&self) -> &[T; N] {
+        let p: *const Self = self;
+        unsafe { &*p.cast::<[T; N]>() }
+    }
+    pub fn into_array(self) -> [T; N]
+    where
+        T: Copy,
+    {
+        *self.as_array()
+    }
+}
+
+pub type u8x2 = Simd<u8, 2>;
+pub type u8x4 = Simd<u8, 4>;
+pub type u8x8 = Simd<u8, 8>;
+pub type u8x16 = Simd<u8, 16>;
+pub type u8x32 = Simd<u8, 32>;
+pub type u8x64 = Simd<u8, 64>;
+
+pub type u16x2 = Simd<u16, 2>;
+pub type u16x4 = Simd<u16, 4>;
+pub type u16x8 = Simd<u16, 8>;
+pub type u16x16 = Simd<u16, 16>;
+pub type u16x32 = Simd<u16, 32>;
+
+pub type u32x2 = Simd<u32, 2>;
+pub type u32x4 = Simd<u32, 4>;
+pub type u32x8 = Simd<u32, 8>;
+pub type u32x16 = Simd<u32, 16>;
+
+pub type u64x2 = Simd<u64, 2>;
+pub type u64x4 = Simd<u64, 4>;
+pub type u64x8 = Simd<u64, 8>;
+
+pub type u128x2 = Simd<u128, 2>;
+pub type u128x4 = Simd<u128, 4>;
+
+pub type i8x2 = Simd<i8, 2>;
+pub type i8x4 = Simd<i8, 4>;
+pub type i8x8 = Simd<i8, 8>;
+pub type i8x16 = Simd<i8, 16>;
+pub type i8x32 = Simd<i8, 32>;
+pub type i8x64 = Simd<i8, 64>;
+
+pub type i16x2 = Simd<i16, 2>;
+pub type i16x4 = Simd<i16, 4>;
+pub type i16x8 = Simd<i16, 8>;
+pub type i16x16 = Simd<i16, 16>;
+pub type i16x32 = Simd<i16, 32>;
+
+pub type i32x2 = Simd<i32, 2>;
+pub type i32x4 = Simd<i32, 4>;
+pub type i32x8 = Simd<i32, 8>;
+pub type i32x16 = Simd<i32, 16>;
+
+pub type i64x2 = Simd<i64, 2>;
+pub type i64x4 = Simd<i64, 4>;
+pub type i64x8 = Simd<i64, 8>;
+
+pub type i128x2 = Simd<i128, 2>;
+pub type i128x4 = Simd<i128, 4>;
+
+pub type f32x2 = Simd<f32, 2>;
+pub type f32x4 = Simd<f32, 4>;
+pub type f32x8 = Simd<f32, 8>;
+pub type f32x16 = Simd<f32, 16>;
+
+pub type f64x2 = Simd<f64, 2>;
+pub type f64x4 = Simd<f64, 4>;
+pub type f64x8 = Simd<f64, 8>;
+
+// The field is currently left `pub` for convenience in porting tests, many of
+// which attempt to just construct it directly. That still works; it's just the
+// `.0` projection that doesn't.
+#[repr(simd, packed)]
+#[derive(Copy)]
+pub struct PackedSimd<T, const N: usize>(pub [T; N]);
+
+impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: PartialEq, const N: usize> PartialEq for PackedSimd<T, N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_array() == other.as_array()
+    }
+}
+
+impl<T: core::fmt::Debug, const N: usize> core::fmt::Debug for PackedSimd<T, N> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
+        <[T; N] as core::fmt::Debug>::fmt(self.as_array(), f)
+    }
+}
+
+impl<T, const N: usize> PackedSimd<T, N> {
+    pub const fn from_array(a: [T; N]) -> Self {
+        PackedSimd(a)
+    }
+    pub fn as_array(&self) -> &[T; N] {
+        let p: *const Self = self;
+        unsafe { &*p.cast::<[T; N]>() }
+    }
+    pub fn into_array(self) -> [T; N]
+    where
+        T: Copy,
+    {
+        *self.as_array()
+    }
+}

tests/codegen/const-vector.rs

@@ -16,18 +16,9 @@
 #![feature(mips_target_feature)]
 #![allow(non_camel_case_types)]
 
-// Setting up structs that can be used as const vectors
-#[repr(simd)]
-#[derive(Clone)]
-pub struct i8x2([i8; 2]);
-
-#[repr(simd)]
-#[derive(Clone)]
-pub struct f32x2([f32; 2]);
-
-#[repr(simd, packed)]
-#[derive(Copy, Clone)]
-pub struct Simd<T, const N: usize>([T; N]);
+#[path = "../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::{PackedSimd as Simd, f32x2, i8x2};
 
 // The following functions are required for the tests to ensure
 // that they are called with a const vector
@@ -45,7 +36,7 @@ extern "unadjusted" {
 
 // Ensure the packed variant of the simd struct does not become a const vector
 // if the size is not a power of 2
-// CHECK: %"Simd<i32, 3>" = type { [3 x i32] }
+// CHECK: %"minisimd::PackedSimd<i32, 3>" = type { [3 x i32] }
 
 #[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
@@ -74,7 +65,7 @@ pub fn do_call() {
         // CHECK: call void @test_simd(<4 x i32> <i32 2, i32 4, i32 6, i32 8>
         test_simd(const { Simd::<i32, 4>([2, 4, 6, 8]) });
 
-        // CHECK: call void @test_simd_unaligned(%"Simd<i32, 3>" %1
+        // CHECK: call void @test_simd_unaligned(%"minisimd::PackedSimd<i32, 3>" %1
         test_simd_unaligned(const { Simd::<i32, 3>([2, 4, 6]) });
     }
 }

tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs

@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_fabs;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_fabs;
 
 // CHECK-LABEL: @fabs_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn fabs_32x16(a: f32x16) -> f32x16 {
     simd_fabs(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @fabs_64x4
 #[no_mangle]
 pub unsafe fn fabs_64x4(a: f64x4) -> f64x4 {

tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs

@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_ceil;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_ceil;
 
 // CHECK-LABEL: @ceil_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn ceil_32x16(a: f32x16) -> f32x16 {
     simd_ceil(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @ceil_64x4
 #[no_mangle]
 pub unsafe fn ceil_64x4(a: f64x4) -> f64x4 {

tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs

@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_fcos;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_fcos;
 
 // CHECK-LABEL: @fcos_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn fcos_32x16(a: f32x16) -> f32x16 {
     simd_fcos(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @fcos_64x4
 #[no_mangle]
 pub unsafe fn fcos_64x4(a: f64x4) -> f64x4 {

tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs

@@ -4,23 +4,11 @@
 #![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
-use std::intrinsics::simd::simd_fexp;
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
+#[path = "../../auxiliary/minisimd.rs"]
+mod minisimd;
+use minisimd::*;
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
+use std::intrinsics::simd::simd_fexp;
 
 // CHECK-LABEL: @exp_32x2
 #[no_mangle]
@@ -50,18 +38,6 @@ pub unsafe fn exp_32x16(a: f32x16) -> f32x16 {
     simd_fexp(a)
 }
 
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
 // CHECK-LABEL: @exp_64x4
 #[no_mangle]
 pub unsafe fn exp_64x4(a: f64x4) -> f64x4 {