Fix maximum SIMD lane count, and expose it to other crates. Disallow SIMD vectors with non-power-of-two lengths.

2 files changed, 30 insertions, 97 deletions

diff --git a/src/test/ui/simd/simd-intrinsic-generic-elements.rs b/src/test/ui/simd/simd-intrinsic-generic-elements.rs
index ea3d4b18944..a85ec7c5823 100644
--- a/src/test/ui/simd/simd-intrinsic-generic-elements.rs
+++ b/src/test/ui/simd/simd-intrinsic-generic-elements.rs
@@ -10,10 +10,6 @@ struct i32x2(i32, i32);
 #[repr(simd)]
 #[derive(Copy, Clone, Debug, PartialEq)]
 #[allow(non_camel_case_types)]
-struct i32x3(i32, i32, i32);
-#[repr(simd)]
-#[derive(Copy, Clone, Debug, PartialEq)]
-#[allow(non_camel_case_types)]
 struct i32x4(i32, i32, i32, i32);
 #[repr(simd)]
 #[derive(Copy, Clone, Debug, PartialEq)]
@@ -26,7 +22,6 @@ extern "platform-intrinsic" {
     fn simd_extract<T, E>(x: T, idx: u32) -> E;
 
     fn simd_shuffle2<T, U>(x: T, y: T, idx: [u32; 2]) -> U;
-    fn simd_shuffle3<T, U>(x: T, y: T, idx: [u32; 3]) -> U;
     fn simd_shuffle4<T, U>(x: T, y: T, idx: [u32; 4]) -> U;
     fn simd_shuffle8<T, U>(x: T, y: T, idx: [u32; 8]) -> U;
 }
@@ -45,17 +40,12 @@ macro_rules! all_eq {
 
 fn main() {
     let x2 = i32x2(20, 21);
-    let x3 = i32x3(30, 31, 32);
     let x4 = i32x4(40, 41, 42, 43);
     let x8 = i32x8(80, 81, 82, 83, 84, 85, 86, 87);
     unsafe {
         all_eq!(simd_insert(x2, 0, 100), i32x2(100, 21));
         all_eq!(simd_insert(x2, 1, 100), i32x2(20, 100));
 
-        all_eq!(simd_insert(x3, 0, 100), i32x3(100, 31, 32));
-        all_eq!(simd_insert(x3, 1, 100), i32x3(30, 100, 32));
-        all_eq!(simd_insert(x3, 2, 100), i32x3(30, 31, 100));
-
         all_eq!(simd_insert(x4, 0, 100), i32x4(100, 41, 42, 43));
         all_eq!(simd_insert(x4, 1, 100), i32x4(40, 100, 42, 43));
         all_eq!(simd_insert(x4, 2, 100), i32x4(40, 41, 100, 43));
@@ -73,10 +63,6 @@ fn main() {
         all_eq!(simd_extract(x2, 0), 20);
         all_eq!(simd_extract(x2, 1), 21);
 
-        all_eq!(simd_extract(x3, 0), 30);
-        all_eq!(simd_extract(x3, 1), 31);
-        all_eq!(simd_extract(x3, 2), 32);
-
         all_eq!(simd_extract(x4, 0), 40);
         all_eq!(simd_extract(x4, 1), 41);
         all_eq!(simd_extract(x4, 2), 42);
@@ -93,30 +79,20 @@ fn main() {
     }
 
     let y2 = i32x2(120, 121);
-    let y3 = i32x3(130, 131, 132);
     let y4 = i32x4(140, 141, 142, 143);
     let y8 = i32x8(180, 181, 182, 183, 184, 185, 186, 187);
     unsafe {
         all_eq!(simd_shuffle2(x2, y2, [3, 0]), i32x2(121, 20));
-        all_eq!(simd_shuffle3(x2, y2, [3, 0, 1]), i32x3(121, 20, 21));
         all_eq!(simd_shuffle4(x2, y2, [3, 0, 1, 2]), i32x4(121, 20, 21, 120));
         all_eq!(simd_shuffle8(x2, y2, [3, 0, 1, 2, 1, 2, 3, 0]),
                 i32x8(121, 20, 21, 120, 21, 120, 121, 20));
 
-        all_eq!(simd_shuffle2(x3, y3, [4, 2]), i32x2(131, 32));
-        all_eq!(simd_shuffle3(x3, y3, [4, 2, 3]), i32x3(131, 32, 130));
-        all_eq!(simd_shuffle4(x3, y3, [4, 2, 3, 0]), i32x4(131, 32, 130, 30));
-        all_eq!(simd_shuffle8(x3, y3, [4, 2, 3, 0, 1, 5, 5, 1]),
-                i32x8(131, 32, 130, 30, 31, 132, 132, 31));
-
         all_eq!(simd_shuffle2(x4, y4, [7, 2]), i32x2(143, 42));
-        all_eq!(simd_shuffle3(x4, y4, [7, 2, 5]), i32x3(143, 42, 141));
         all_eq!(simd_shuffle4(x4, y4, [7, 2, 5, 0]), i32x4(143, 42, 141, 40));
         all_eq!(simd_shuffle8(x4, y4, [7, 2, 5, 0, 3, 6, 4, 1]),
                 i32x8(143, 42, 141, 40, 43, 142, 140, 41));
 
         all_eq!(simd_shuffle2(x8, y8, [11, 5]), i32x2(183, 85));
-        all_eq!(simd_shuffle3(x8, y8, [11, 5, 15]), i32x3(183, 85, 187));
         all_eq!(simd_shuffle4(x8, y8, [11, 5, 15, 0]), i32x4(183, 85, 187, 80));
         all_eq!(simd_shuffle8(x8, y8, [11, 5, 15, 0, 3, 8, 12, 1]),
                 i32x8(183, 85, 187, 80, 83, 180, 184, 81));
diff --git a/src/test/ui/simd/simd-size-align.rs b/src/test/ui/simd/simd-size-align.rs
index 556013788c3..0afa4947225 100644
--- a/src/test/ui/simd/simd-size-align.rs
+++ b/src/test/ui/simd/simd-size-align.rs
@@ -10,87 +10,44 @@ use std::mem;
 /// `T` should satisfy `size_of T (mod min_align_of T) === 0` to be stored at `Vec<T>` properly
 /// Please consult the issue #20460
 fn check<T>() {
-    assert_eq!(mem::size_of::<T>() % mem::min_align_of::<T>(), 0)
+    assert_eq!(mem::size_of::<T>() % mem::min_align_of::<T>(), 0);
+    assert_eq!(mem::size_of::<T>() % mem::min_align_of::<T>(), 0);
+    assert_eq!(mem::size_of::<T>() % mem::min_align_of::<T>(), 0);
 }
 
-fn main() {
-    check::<u8x2>();
-    check::<u8x3>();
-    check::<u8x4>();
-    check::<u8x5>();
-    check::<u8x6>();
-    check::<u8x7>();
-    check::<u8x8>();
+#[repr(simd)]
+struct U8<const N: usize>([u8; N]);
 
-    check::<i16x2>();
-    check::<i16x3>();
-    check::<i16x4>();
-    check::<i16x5>();
-    check::<i16x6>();
-    check::<i16x7>();
-    check::<i16x8>();
+#[repr(simd)]
+struct I16<const N: usize>([i16; N]);
 
-    check::<f32x2>();
-    check::<f32x3>();
-    check::<f32x4>();
-    check::<f32x5>();
-    check::<f32x6>();
-    check::<f32x7>();
-    check::<f32x8>();
+#[repr(simd)]
+struct F32<const N: usize>([f32; N]);
 
-    check::<usizex2>();
-    check::<usizex3>();
-    check::<usizex4>();
-    check::<usizex5>();
-    check::<usizex6>();
-    check::<usizex7>();
-    check::<usizex8>();
+#[repr(simd)]
+struct Usize<const N: usize>([usize; N]);
 
-    check::<isizex2>();
-    check::<isizex3>();
-    check::<isizex4>();
-    check::<isizex5>();
-    check::<isizex6>();
-    check::<isizex7>();
-    check::<isizex8>();
-}
+#[repr(simd)]
+struct Isize<const N: usize>([isize; N]);
 
-#[repr(simd)] struct u8x2(u8, u8);
-#[repr(simd)] struct u8x3(u8, u8, u8);
-#[repr(simd)] struct u8x4(u8, u8, u8, u8);
-#[repr(simd)] struct u8x5(u8, u8, u8, u8, u8);
-#[repr(simd)] struct u8x6(u8, u8, u8, u8, u8, u8);
-#[repr(simd)] struct u8x7(u8, u8, u8, u8, u8, u8, u8);
-#[repr(simd)] struct u8x8(u8, u8, u8, u8, u8, u8, u8, u8);
+fn main() {
+    check::<U8<2>>();
+    check::<U8<4>>();
+    check::<U8<8>>();
 
-#[repr(simd)] struct i16x2(i16, i16);
-#[repr(simd)] struct i16x3(i16, i16, i16);
-#[repr(simd)] struct i16x4(i16, i16, i16, i16);
-#[repr(simd)] struct i16x5(i16, i16, i16, i16, i16);
-#[repr(simd)] struct i16x6(i16, i16, i16, i16, i16, i16);
-#[repr(simd)] struct i16x7(i16, i16, i16, i16, i16, i16, i16);
-#[repr(simd)] struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
+    check::<I16<2>>();
+    check::<I16<4>>();
+    check::<I16<8>>();
 
-#[repr(simd)] struct f32x2(f32, f32);
-#[repr(simd)] struct f32x3(f32, f32, f32);
-#[repr(simd)] struct f32x4(f32, f32, f32, f32);
-#[repr(simd)] struct f32x5(f32, f32, f32, f32, f32);
-#[repr(simd)] struct f32x6(f32, f32, f32, f32, f32, f32);
-#[repr(simd)] struct f32x7(f32, f32, f32, f32, f32, f32, f32);
-#[repr(simd)] struct f32x8(f32, f32, f32, f32, f32, f32, f32, f32);
+    check::<F32<2>>();
+    check::<F32<4>>();
+    check::<F32<8>>();
 
-#[repr(simd)] struct usizex2(usize, usize);
-#[repr(simd)] struct usizex3(usize, usize, usize);
-#[repr(simd)] struct usizex4(usize, usize, usize, usize);
-#[repr(simd)] struct usizex5(usize, usize, usize, usize, usize);
-#[repr(simd)] struct usizex6(usize, usize, usize, usize, usize, usize);
-#[repr(simd)] struct usizex7(usize, usize, usize, usize, usize, usize, usize);
-#[repr(simd)] struct usizex8(usize, usize, usize, usize, usize, usize, usize, usize);
+    check::<Usize<2>>();
+    check::<Usize<4>>();
+    check::<Usize<8>>();
 
-#[repr(simd)] struct isizex2(isize, isize);
-#[repr(simd)] struct isizex3(isize, isize, isize);
-#[repr(simd)] struct isizex4(isize, isize, isize, isize);
-#[repr(simd)] struct isizex5(isize, isize, isize, isize, isize);
-#[repr(simd)] struct isizex6(isize, isize, isize, isize, isize, isize);
-#[repr(simd)] struct isizex7(isize, isize, isize, isize, isize, isize, isize);
-#[repr(simd)] struct isizex8(isize, isize, isize, isize, isize, isize, isize, isize);
+    check::<Isize<2>>();
+    check::<Isize<4>>();
+    check::<Isize<8>>();
+}