Rollup merge of #147521 - sayantn:simd-const-intrinsics, r=madsmtm

Make SIMD intrinsics available in `const`-contexts
successor to #146568, this PR actually makes the SIMD intrinsics `const`, and modifies the tests to test the const-eval implementations
r? `@tgross35` ig (although feel free to reassign, this is not anything targeted really)

Author: matthiaskrgr

library/core/src/intrinsics/simd.rs

@@ -60,7 +60,7 @@ impl<T: Copy, const N: usize> PackedSimd<T, N> {
 
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pubunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
+pubconstunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
 
 fnsimd_ops_f16(){
 use intrinsics::*;

src/tools/miri/tests/pass/intrinsics/portable-simd.rs

@@ -10,6 +10,10 @@
 
 #![allow(unused)]
 #![allow(non_camel_case_types)]
+// FIXME: `cfg(minisimd_const)` is used to toggle use of const trait impls, which require a few
+// nightly features. Remove this when `const_trait_impls`, `const_cmp` and `const_index` are
+// stablilized.
+#![allow(unexpected_cfgs)]
 
 // 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
@@ -24,39 +28,32 @@ impl<T: Copy, const N: usize> Clone for Simd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
 }
 }
 
-impl<T,constN:usize> core::ops::Index<usize>forSimd<T,N>{
-typeOutput = T;
-fnindex(&self,i:usize) -> &T{
-&self.as_array()[i]
-}
-}
-
 impl<T,constN:usize>Simd<T,N>{
 pubconstfnfrom_array(a:[T;N]) -> Self{
 Simd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
 }
 
 pubtypeu8x2 = Simd<u8,2>;
@@ -109,6 +106,14 @@ pub type i64x8 = Simd<i64, 8>;
 pubtypei128x2 = Simd<i128,2>;
 pubtypei128x4 = Simd<i128,4>;
 
+pubtypeusizex2 = Simd<usize,2>;
+pubtypeusizex4 = Simd<usize,4>;
+pubtypeusizex8 = Simd<usize,8>;
+
+pubtypeisizex2 = Simd<isize,2>;
+pubtypeisizex4 = Simd<isize,4>;
+pubtypeisizex8 = Simd<isize,8>;
+
 pubtypef32x2 = Simd<f32,2>;
 pubtypef32x4 = Simd<f32,4>;
 pubtypef32x8 = Simd<f32,8>;
@@ -122,7 +127,7 @@ pub type f64x8 = Simd<f64, 8>;
 // which attempt to just construct it directly. That still works; it's just the
 // `.0` projection that doesn't.
 #[repr(simd, packed)]
-#[derive(Copy)]
+#[derive(Copy,Eq)]
 pubstructPackedSimd<T,constN:usize>(pub[T;N]);
 
 impl<T:Copy,constN:usize>CloneforPackedSimd<T,N>{
@@ -131,12 +136,6 @@ impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforPackedSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforPackedSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
@@ -147,14 +146,81 @@ impl<T, const N: usize> PackedSimd<T, N> {
 pubconstfnfrom_array(a:[T;N]) -> Self{
 PackedSimd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
+}
+
+// As `const_trait_impl` is a language feature with specialized syntax, we have to use them in a way
+// such that it doesn't get parsed as Rust code unless `cfg(minisimd_const)` is on. The easiest way
+// for that is a macro
+
+macro_rules! impl_traits {
+($($const_:ident)?) => {
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforSimd<T,N> {
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+
+impl<T,constN:usize> $($const_)? core::ops::Index<usize> forSimd<T,N> {
+typeOutput = T;
+fn index(&self, i:usize) -> &T{
+&self.as_array()[i]
+}
+}
+
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforPackedSimd<T,N>
+{
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+};
 }
+
+#[cfg(minisimd_const)]
+impl_traits!(const);
+
+#[cfg(not(minisimd_const))]
+impl_traits!();
+
+/// Version of `assert_eq` that ignores fancy runtime printing in const context.
+/// FIXME: Remove once <https://github.com/rust-lang/rust/issues/119826> is fixed.
+#[cfg(minisimd_const)]
+#[macro_export]
+macro_rules! assert_eq {
+($left:expr, $right:expr $(,)?) => {
+ assert_eq!(
+ $left,
+ $right,
+ concat!("`", stringify!($left),"` == `", stringify!($right),"`")
+);
+};
+($left:expr, $right:expr$(, $($arg:tt)+)?) => {
+{
+let left = $left;
+let right = $right;
+// type inference works better with the concrete type on the
+// left, but humans work better with the expected on the
+// right
+ assert!(right == left, $($($arg)*),*);
+}
+};
+}
+
+#[cfg(minisimd_const)]
+use assert_eq;

tests/auxiliary/minisimd.rs

@@ -1,14 +1,15 @@
 //@ run-pass
 //@ ignore-emscripten
 //@ ignore-android
+//@ compile-flags: --cfg minisimd_const
 
 // FIXME: this test fails on arm-android because the NDK version 14 is too old.
 // It needs at least version 18. We disable it on all android build bots because
 // there is no way in compile-test to disable it for an (arch,os) pair.
 
 // Test that the simd floating-point math intrinsics produce correct results.
 
-#![feature(repr_simd,intrinsics, core_intrinsics)]
+#![feature(repr_simd,core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -20,7 +21,10 @@ use std::intrinsics::simd::*;
 macro_rules! assert_approx_eq_f32 {
 ($a:expr, $b:expr) => {{
 let(a, b) = (&$a,&$b);
- assert!((*a - *b).abs() < 1.0e-6,"{} is not approximately equal to {}",*a,*b);
+ assert!(
+(*a - *b).abs() < 1.0e-6,
+ concat!(stringify!($a)," is not approximately equal to ", stringify!($b))
+);
 }};
 }
 macro_rules! assert_approx_eq {
@@ -34,7 +38,7 @@ macro_rules! assert_approx_eq {
 }};
 }
 
-fnmain(){
+constfnsimple_math(){
 let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
 let y = f32x4::from_array([-1.0, -1.0, -1.0, -1.0]);
 let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
@@ -43,21 +47,44 @@ fn main() {
 
 unsafe{
 let r = simd_fabs(y);
-assert_approx_eq!(x, r);
+assert_eq!(x, r);
 
-let r = simd_fcos(z);
+// rounding functions
+let r = simd_floor(h);
+assert_eq!(z, r);
+
+let r = simd_ceil(h);
+assert_eq!(x, r);
+
+let r = simd_round(h);
+assert_eq!(x, r);
+
+let r = simd_round_ties_even(h);
+assert_eq!(z, r);
+
+let r = simd_trunc(h);
+assert_eq!(z, r);
+
+let r = simd_fma(x, h, h);
 assert_approx_eq!(x, r);
 
-let r = simd_fexp(z);
+let r = simd_relaxed_fma(x, h, h);
 assert_approx_eq!(x, r);
+}
+}
 
-let r = simd_fexp2(z);
+fnspecial_math(){
+let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
+let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
+
+unsafe{
+let r = simd_fcos(z);
 assert_approx_eq!(x, r);
 
-let r = simd_fma(x, h, h);
+let r = simd_fexp(z);
 assert_approx_eq!(x, r);
 
-let r = simd_relaxed_fma(x, h, h);
+let r = simd_fexp2(z);
 assert_approx_eq!(x, r);
 
 let r = simd_fsqrt(x);
@@ -74,21 +101,11 @@ fn main() {
 
 let r = simd_fsin(z);
 assert_approx_eq!(z, r);
-
-// rounding functions
-let r = simd_floor(h);
-assert_eq!(z, r);
-
-let r = simd_ceil(h);
-assert_eq!(x, r);
-
-let r = simd_round(h);
-assert_eq!(x, r);
-
-let r = simd_round_ties_even(h);
-assert_eq!(z, r);
-
-let r = simd_trunc(h);
-assert_eq!(z, r);
 }
 }
+
+fnmain(){
+const{simple_math()};
+simple_math();
+special_math();
+}

tests/ui/simd/intrinsic/float-math-pass.rs

@@ -1,9 +1,10 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 // Test that the simd_f{min,max} intrinsics produce the correct results.
 
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -12,7 +13,7 @@ use minisimd::*;
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnminmax(){
 let x = f32x4::from_array([1.0,2.0,3.0,4.0]);
 let y = f32x4::from_array([2.0,1.0,4.0,3.0]);
 
@@ -47,3 +48,8 @@ fn main() {
 assert_eq!(maxn, y);
 }
 }
+
+fnmain(){
+const{minmax()};
+minmax();
+}

tests/ui/simd/intrinsic/float-minmax-pass.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-backends: gcc
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -20,7 +21,7 @@ macro_rules! all_eq {
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnarithmetic(){
 let x1 = i32x4::from_array([1,2,3,4]);
 let y1 = U32::<4>::from_array([1,2,3,4]);
 let z1 = f32x4::from_array([1.0,2.0,3.0,4.0]);
@@ -224,3 +225,8 @@ fn main() {
 all_eq!(simd_cttz(y1),U32::<4>::from_array([0,1,0,2]));
 }
 }
+
+fnmain(){
+const{arithmetic()};
+arithmetic();
+}

tests/ui/simd/intrinsic/generic-arithmetic-pass.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -12,7 +13,7 @@ use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 typeI32<constN:usize> = Simd<i32,N>;
 
-fnmain(){
+constfnsaturating(){
 // unsigned
 {
 constM:u32 = u32::MAX;
@@ -84,3 +85,8 @@ fn main() {
 }
 }
 }
+
+fnmain(){
+const{saturating()};
+saturating();
+}

tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs

@@ -60,7 +60,7 @@ impl<T: Copy, const N: usize> PackedSimd<T, N> {
 
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pubunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
+pubconstunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
 
 fnsimd_ops_f16(){
 use intrinsics::*;

library/core/src/intrinsics/simd.rs

@@ -10,6 +10,10 @@
 
 #![allow(unused)]
 #![allow(non_camel_case_types)]
+// FIXME: `cfg(minisimd_const)` is used to toggle use of const trait impls, which require a few
+// nightly features. Remove this when `const_trait_impls`, `const_cmp` and `const_index` are
+// stablilized.
+#![allow(unexpected_cfgs)]
 
 // 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
@@ -24,39 +28,32 @@ impl<T: Copy, const N: usize> Clone for Simd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
 }
 }
 
-impl<T,constN:usize> core::ops::Index<usize>forSimd<T,N>{
-typeOutput = T;
-fnindex(&self,i:usize) -> &T{
-&self.as_array()[i]
-}
-}
-
 impl<T,constN:usize>Simd<T,N>{
 pubconstfnfrom_array(a:[T;N]) -> Self{
 Simd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
 }
 
 pubtypeu8x2 = Simd<u8,2>;
@@ -109,6 +106,14 @@ pub type i64x8 = Simd<i64, 8>;
 pubtypei128x2 = Simd<i128,2>;
 pubtypei128x4 = Simd<i128,4>;
 
+pubtypeusizex2 = Simd<usize,2>;
+pubtypeusizex4 = Simd<usize,4>;
+pubtypeusizex8 = Simd<usize,8>;
+
+pubtypeisizex2 = Simd<isize,2>;
+pubtypeisizex4 = Simd<isize,4>;
+pubtypeisizex8 = Simd<isize,8>;
+
 pubtypef32x2 = Simd<f32,2>;
 pubtypef32x4 = Simd<f32,4>;
 pubtypef32x8 = Simd<f32,8>;
@@ -122,7 +127,7 @@ pub type f64x8 = Simd<f64, 8>;
 // which attempt to just construct it directly. That still works; it's just the
 // `.0` projection that doesn't.
 #[repr(simd, packed)]
-#[derive(Copy)]
+#[derive(Copy,Eq)]
 pubstructPackedSimd<T,constN:usize>(pub[T;N]);
 
 impl<T:Copy,constN:usize>CloneforPackedSimd<T,N>{
@@ -131,12 +136,6 @@ impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforPackedSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforPackedSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
@@ -147,14 +146,81 @@ impl<T, const N: usize> PackedSimd<T, N> {
 pubconstfnfrom_array(a:[T;N]) -> Self{
 PackedSimd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
+}
+
+// As `const_trait_impl` is a language feature with specialized syntax, we have to use them in a way
+// such that it doesn't get parsed as Rust code unless `cfg(minisimd_const)` is on. The easiest way
+// for that is a macro
+
+macro_rules! impl_traits {
+($($const_:ident)?) => {
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforSimd<T,N> {
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+
+impl<T,constN:usize> $($const_)? core::ops::Index<usize> forSimd<T,N> {
+typeOutput = T;
+fn index(&self, i:usize) -> &T{
+&self.as_array()[i]
+}
+}
+
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforPackedSimd<T,N>
+{
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+};
 }
+
+#[cfg(minisimd_const)]
+impl_traits!(const);
+
+#[cfg(not(minisimd_const))]
+impl_traits!();
+
+/// Version of `assert_eq` that ignores fancy runtime printing in const context.
+/// FIXME: Remove once <https://github.com/rust-lang/rust/issues/119826> is fixed.
+#[cfg(minisimd_const)]
+#[macro_export]
+macro_rules! assert_eq {
+($left:expr, $right:expr $(,)?) => {
+ assert_eq!(
+ $left,
+ $right,
+ concat!("`", stringify!($left),"` == `", stringify!($right),"`")
+);
+};
+($left:expr, $right:expr$(, $($arg:tt)+)?) => {
+{
+let left = $left;
+let right = $right;
+// type inference works better with the concrete type on the
+// left, but humans work better with the expected on the
+// right
+ assert!(right == left, $($($arg)*),*);
+}
+};
+}
+
+#[cfg(minisimd_const)]
+use assert_eq;

src/tools/miri/tests/pass/intrinsics/portable-simd.rs

@@ -1,14 +1,15 @@
 //@ run-pass
 //@ ignore-emscripten
 //@ ignore-android
+//@ compile-flags: --cfg minisimd_const
 
 // FIXME: this test fails on arm-android because the NDK version 14 is too old.
 // It needs at least version 18. We disable it on all android build bots because
 // there is no way in compile-test to disable it for an (arch,os) pair.
 
 // Test that the simd floating-point math intrinsics produce correct results.
 
-#![feature(repr_simd,intrinsics, core_intrinsics)]
+#![feature(repr_simd,core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -20,7 +21,10 @@ use std::intrinsics::simd::*;
 macro_rules! assert_approx_eq_f32 {
 ($a:expr, $b:expr) => {{
 let(a, b) = (&$a,&$b);
- assert!((*a - *b).abs() < 1.0e-6,"{} is not approximately equal to {}",*a,*b);
+ assert!(
+(*a - *b).abs() < 1.0e-6,
+ concat!(stringify!($a)," is not approximately equal to ", stringify!($b))
+);
 }};
 }
 macro_rules! assert_approx_eq {
@@ -34,7 +38,7 @@ macro_rules! assert_approx_eq {
 }};
 }
 
-fnmain(){
+constfnsimple_math(){
 let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
 let y = f32x4::from_array([-1.0, -1.0, -1.0, -1.0]);
 let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
@@ -43,21 +47,44 @@ fn main() {
 
 unsafe{
 let r = simd_fabs(y);
-assert_approx_eq!(x, r);
+assert_eq!(x, r);
 
-let r = simd_fcos(z);
+// rounding functions
+let r = simd_floor(h);
+assert_eq!(z, r);
+
+let r = simd_ceil(h);
+assert_eq!(x, r);
+
+let r = simd_round(h);
+assert_eq!(x, r);
+
+let r = simd_round_ties_even(h);
+assert_eq!(z, r);
+
+let r = simd_trunc(h);
+assert_eq!(z, r);
+
+let r = simd_fma(x, h, h);
 assert_approx_eq!(x, r);
 
-let r = simd_fexp(z);
+let r = simd_relaxed_fma(x, h, h);
 assert_approx_eq!(x, r);
+}
+}
 
-let r = simd_fexp2(z);
+fnspecial_math(){
+let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
+let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
+
+unsafe{
+let r = simd_fcos(z);
 assert_approx_eq!(x, r);
 
-let r = simd_fma(x, h, h);
+let r = simd_fexp(z);
 assert_approx_eq!(x, r);
 
-let r = simd_relaxed_fma(x, h, h);
+let r = simd_fexp2(z);
 assert_approx_eq!(x, r);
 
 let r = simd_fsqrt(x);
@@ -74,21 +101,11 @@ fn main() {
 
 let r = simd_fsin(z);
 assert_approx_eq!(z, r);
-
-// rounding functions
-let r = simd_floor(h);
-assert_eq!(z, r);
-
-let r = simd_ceil(h);
-assert_eq!(x, r);
-
-let r = simd_round(h);
-assert_eq!(x, r);
-
-let r = simd_round_ties_even(h);
-assert_eq!(z, r);
-
-let r = simd_trunc(h);
-assert_eq!(z, r);
 }
 }
+
+fnmain(){
+const{simple_math()};
+simple_math();
+special_math();
+}

tests/auxiliary/minisimd.rs

@@ -1,9 +1,10 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 // Test that the simd_f{min,max} intrinsics produce the correct results.
 
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -12,7 +13,7 @@ use minisimd::*;
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnminmax(){
 let x = f32x4::from_array([1.0,2.0,3.0,4.0]);
 let y = f32x4::from_array([2.0,1.0,4.0,3.0]);
 
@@ -47,3 +48,8 @@ fn main() {
 assert_eq!(maxn, y);
 }
 }
+
+fnmain(){
+const{minmax()};
+minmax();
+}

tests/ui/simd/intrinsic/float-math-pass.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-backends: gcc
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -20,7 +21,7 @@ macro_rules! all_eq {
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnarithmetic(){
 let x1 = i32x4::from_array([1,2,3,4]);
 let y1 = U32::<4>::from_array([1,2,3,4]);
 let z1 = f32x4::from_array([1.0,2.0,3.0,4.0]);
@@ -224,3 +225,8 @@ fn main() {
 all_eq!(simd_cttz(y1),U32::<4>::from_array([0,1,0,2]));
 }
 }
+
+fnmain(){
+const{arithmetic()};
+arithmetic();
+}

tests/ui/simd/intrinsic/float-minmax-pass.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -12,7 +13,7 @@ use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 typeI32<constN:usize> = Simd<i32,N>;
 
-fnmain(){
+constfnsaturating(){
 // unsigned
 {
 constM:u32 = u32::MAX;
@@ -84,3 +85,8 @@ fn main() {
 }
 }
 }
+
+fnmain(){
+const{saturating()};
+saturating();
+}

tests/ui/simd/intrinsic/generic-arithmetic-pass.rs

@@ -60,7 +60,7 @@ impl<T: Copy, const N: usize> PackedSimd<T, N> {
 
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pubunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
+pubconstunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
 
 fnsimd_ops_f16(){
 use intrinsics::*;

tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs

@@ -10,6 +10,10 @@
 
 #![allow(unused)]
 #![allow(non_camel_case_types)]
+// FIXME: `cfg(minisimd_const)` is used to toggle use of const trait impls, which require a few
+// nightly features. Remove this when `const_trait_impls`, `const_cmp` and `const_index` are
+// stablilized.
+#![allow(unexpected_cfgs)]
 
 // 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
@@ -24,39 +28,32 @@ impl<T: Copy, const N: usize> Clone for Simd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
 }
 }
 
-impl<T,constN:usize> core::ops::Index<usize>forSimd<T,N>{
-typeOutput = T;
-fnindex(&self,i:usize) -> &T{
-&self.as_array()[i]
-}
-}
-
 impl<T,constN:usize>Simd<T,N>{
 pubconstfnfrom_array(a:[T;N]) -> Self{
 Simd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
 }
 
 pubtypeu8x2 = Simd<u8,2>;
@@ -109,6 +106,14 @@ pub type i64x8 = Simd<i64, 8>;
 pubtypei128x2 = Simd<i128,2>;
 pubtypei128x4 = Simd<i128,4>;
 
+pubtypeusizex2 = Simd<usize,2>;
+pubtypeusizex4 = Simd<usize,4>;
+pubtypeusizex8 = Simd<usize,8>;
+
+pubtypeisizex2 = Simd<isize,2>;
+pubtypeisizex4 = Simd<isize,4>;
+pubtypeisizex8 = Simd<isize,8>;
+
 pubtypef32x2 = Simd<f32,2>;
 pubtypef32x4 = Simd<f32,4>;
 pubtypef32x8 = Simd<f32,8>;
@@ -122,7 +127,7 @@ pub type f64x8 = Simd<f64, 8>;
 // which attempt to just construct it directly. That still works; it's just the
 // `.0` projection that doesn't.
 #[repr(simd, packed)]
-#[derive(Copy)]
+#[derive(Copy,Eq)]
 pubstructPackedSimd<T,constN:usize>(pub[T;N]);
 
 impl<T:Copy,constN:usize>CloneforPackedSimd<T,N>{
@@ -131,12 +136,6 @@ impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforPackedSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforPackedSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
@@ -147,14 +146,81 @@ impl<T, const N: usize> PackedSimd<T, N> {
 pubconstfnfrom_array(a:[T;N]) -> Self{
 PackedSimd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
+}
+
+// As `const_trait_impl` is a language feature with specialized syntax, we have to use them in a way
+// such that it doesn't get parsed as Rust code unless `cfg(minisimd_const)` is on. The easiest way
+// for that is a macro
+
+macro_rules! impl_traits {
+($($const_:ident)?) => {
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforSimd<T,N> {
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+
+impl<T,constN:usize> $($const_)? core::ops::Index<usize> forSimd<T,N> {
+typeOutput = T;
+fn index(&self, i:usize) -> &T{
+&self.as_array()[i]
+}
+}
+
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforPackedSimd<T,N>
+{
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+};
 }
+
+#[cfg(minisimd_const)]
+impl_traits!(const);
+
+#[cfg(not(minisimd_const))]
+impl_traits!();
+
+/// Version of `assert_eq` that ignores fancy runtime printing in const context.
+/// FIXME: Remove once <https://github.com/rust-lang/rust/issues/119826> is fixed.
+#[cfg(minisimd_const)]
+#[macro_export]
+macro_rules! assert_eq {
+($left:expr, $right:expr $(,)?) => {
+ assert_eq!(
+ $left,
+ $right,
+ concat!("`", stringify!($left),"` == `", stringify!($right),"`")
+);
+};
+($left:expr, $right:expr$(, $($arg:tt)+)?) => {
+{
+let left = $left;
+let right = $right;
+// type inference works better with the concrete type on the
+// left, but humans work better with the expected on the
+// right
+ assert!(right == left, $($($arg)*),*);
+}
+};
+}
+
+#[cfg(minisimd_const)]
+use assert_eq;

library/core/src/intrinsics/simd.rs

@@ -1,14 +1,15 @@
 //@ run-pass
 //@ ignore-emscripten
 //@ ignore-android
+//@ compile-flags: --cfg minisimd_const
 
 // FIXME: this test fails on arm-android because the NDK version 14 is too old.
 // It needs at least version 18. We disable it on all android build bots because
 // there is no way in compile-test to disable it for an (arch,os) pair.
 
 // Test that the simd floating-point math intrinsics produce correct results.
 
-#![feature(repr_simd,intrinsics, core_intrinsics)]
+#![feature(repr_simd,core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -20,7 +21,10 @@ use std::intrinsics::simd::*;
 macro_rules! assert_approx_eq_f32 {
 ($a:expr, $b:expr) => {{
 let(a, b) = (&$a,&$b);
- assert!((*a - *b).abs() < 1.0e-6,"{} is not approximately equal to {}",*a,*b);
+ assert!(
+(*a - *b).abs() < 1.0e-6,
+ concat!(stringify!($a)," is not approximately equal to ", stringify!($b))
+);
 }};
 }
 macro_rules! assert_approx_eq {
@@ -34,7 +38,7 @@ macro_rules! assert_approx_eq {
 }};
 }
 
-fnmain(){
+constfnsimple_math(){
 let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
 let y = f32x4::from_array([-1.0, -1.0, -1.0, -1.0]);
 let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
@@ -43,21 +47,44 @@ fn main() {
 
 unsafe{
 let r = simd_fabs(y);
-assert_approx_eq!(x, r);
+assert_eq!(x, r);
 
-let r = simd_fcos(z);
+// rounding functions
+let r = simd_floor(h);
+assert_eq!(z, r);
+
+let r = simd_ceil(h);
+assert_eq!(x, r);
+
+let r = simd_round(h);
+assert_eq!(x, r);
+
+let r = simd_round_ties_even(h);
+assert_eq!(z, r);
+
+let r = simd_trunc(h);
+assert_eq!(z, r);
+
+let r = simd_fma(x, h, h);
 assert_approx_eq!(x, r);
 
-let r = simd_fexp(z);
+let r = simd_relaxed_fma(x, h, h);
 assert_approx_eq!(x, r);
+}
+}
 
-let r = simd_fexp2(z);
+fnspecial_math(){
+let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
+let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
+
+unsafe{
+let r = simd_fcos(z);
 assert_approx_eq!(x, r);
 
-let r = simd_fma(x, h, h);
+let r = simd_fexp(z);
 assert_approx_eq!(x, r);
 
-let r = simd_relaxed_fma(x, h, h);
+let r = simd_fexp2(z);
 assert_approx_eq!(x, r);
 
 let r = simd_fsqrt(x);
@@ -74,21 +101,11 @@ fn main() {
 
 let r = simd_fsin(z);
 assert_approx_eq!(z, r);
-
-// rounding functions
-let r = simd_floor(h);
-assert_eq!(z, r);
-
-let r = simd_ceil(h);
-assert_eq!(x, r);
-
-let r = simd_round(h);
-assert_eq!(x, r);
-
-let r = simd_round_ties_even(h);
-assert_eq!(z, r);
-
-let r = simd_trunc(h);
-assert_eq!(z, r);
 }
 }
+
+fnmain(){
+const{simple_math()};
+simple_math();
+special_math();
+}

src/tools/miri/tests/pass/intrinsics/portable-simd.rs

@@ -1,9 +1,10 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 // Test that the simd_f{min,max} intrinsics produce the correct results.
 
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -12,7 +13,7 @@ use minisimd::*;
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnminmax(){
 let x = f32x4::from_array([1.0,2.0,3.0,4.0]);
 let y = f32x4::from_array([2.0,1.0,4.0,3.0]);
 
@@ -47,3 +48,8 @@ fn main() {
 assert_eq!(maxn, y);
 }
 }
+
+fnmain(){
+const{minmax()};
+minmax();
+}

tests/auxiliary/minisimd.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-backends: gcc
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -20,7 +21,7 @@ macro_rules! all_eq {
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnarithmetic(){
 let x1 = i32x4::from_array([1,2,3,4]);
 let y1 = U32::<4>::from_array([1,2,3,4]);
 let z1 = f32x4::from_array([1.0,2.0,3.0,4.0]);
@@ -224,3 +225,8 @@ fn main() {
 all_eq!(simd_cttz(y1),U32::<4>::from_array([0,1,0,2]));
 }
 }
+
+fnmain(){
+const{arithmetic()};
+arithmetic();
+}

tests/ui/simd/intrinsic/float-math-pass.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -12,7 +13,7 @@ use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 typeI32<constN:usize> = Simd<i32,N>;
 
-fnmain(){
+constfnsaturating(){
 // unsigned
 {
 constM:u32 = u32::MAX;
@@ -84,3 +85,8 @@ fn main() {
 }
 }
 }
+
+fnmain(){
+const{saturating()};
+saturating();
+}

tests/ui/simd/intrinsic/float-minmax-pass.rs

@@ -60,7 +60,7 @@ impl<T: Copy, const N: usize> PackedSimd<T, N> {
 
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pubunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
+pubconstunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
 
 fnsimd_ops_f16(){
 use intrinsics::*;

tests/ui/simd/intrinsic/generic-arithmetic-pass.rs

@@ -10,6 +10,10 @@
 
 #![allow(unused)]
 #![allow(non_camel_case_types)]
+// FIXME: `cfg(minisimd_const)` is used to toggle use of const trait impls, which require a few
+// nightly features. Remove this when `const_trait_impls`, `const_cmp` and `const_index` are
+// stablilized.
+#![allow(unexpected_cfgs)]
 
 // 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
@@ -24,39 +28,32 @@ impl<T: Copy, const N: usize> Clone for Simd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
 }
 }
 
-impl<T,constN:usize> core::ops::Index<usize>forSimd<T,N>{
-typeOutput = T;
-fnindex(&self,i:usize) -> &T{
-&self.as_array()[i]
-}
-}
-
 impl<T,constN:usize>Simd<T,N>{
 pubconstfnfrom_array(a:[T;N]) -> Self{
 Simd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
 }
 
 pubtypeu8x2 = Simd<u8,2>;
@@ -109,6 +106,14 @@ pub type i64x8 = Simd<i64, 8>;
 pubtypei128x2 = Simd<i128,2>;
 pubtypei128x4 = Simd<i128,4>;
 
+pubtypeusizex2 = Simd<usize,2>;
+pubtypeusizex4 = Simd<usize,4>;
+pubtypeusizex8 = Simd<usize,8>;
+
+pubtypeisizex2 = Simd<isize,2>;
+pubtypeisizex4 = Simd<isize,4>;
+pubtypeisizex8 = Simd<isize,8>;
+
 pubtypef32x2 = Simd<f32,2>;
 pubtypef32x4 = Simd<f32,4>;
 pubtypef32x8 = Simd<f32,8>;
@@ -122,7 +127,7 @@ pub type f64x8 = Simd<f64, 8>;
 // which attempt to just construct it directly. That still works; it's just the
 // `.0` projection that doesn't.
 #[repr(simd, packed)]
-#[derive(Copy)]
+#[derive(Copy,Eq)]
 pubstructPackedSimd<T,constN:usize>(pub[T;N]);
 
 impl<T:Copy,constN:usize>CloneforPackedSimd<T,N>{
@@ -131,12 +136,6 @@ impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforPackedSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforPackedSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
@@ -147,14 +146,81 @@ impl<T, const N: usize> PackedSimd<T, N> {
 pubconstfnfrom_array(a:[T;N]) -> Self{
 PackedSimd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
+}
+
+// As `const_trait_impl` is a language feature with specialized syntax, we have to use them in a way
+// such that it doesn't get parsed as Rust code unless `cfg(minisimd_const)` is on. The easiest way
+// for that is a macro
+
+macro_rules! impl_traits {
+($($const_:ident)?) => {
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforSimd<T,N> {
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+
+impl<T,constN:usize> $($const_)? core::ops::Index<usize> forSimd<T,N> {
+typeOutput = T;
+fn index(&self, i:usize) -> &T{
+&self.as_array()[i]
+}
+}
+
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforPackedSimd<T,N>
+{
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+};
 }
+
+#[cfg(minisimd_const)]
+impl_traits!(const);
+
+#[cfg(not(minisimd_const))]
+impl_traits!();
+
+/// Version of `assert_eq` that ignores fancy runtime printing in const context.
+/// FIXME: Remove once <https://github.com/rust-lang/rust/issues/119826> is fixed.
+#[cfg(minisimd_const)]
+#[macro_export]
+macro_rules! assert_eq {
+($left:expr, $right:expr $(,)?) => {
+ assert_eq!(
+ $left,
+ $right,
+ concat!("`", stringify!($left),"` == `", stringify!($right),"`")
+);
+};
+($left:expr, $right:expr$(, $($arg:tt)+)?) => {
+{
+let left = $left;
+let right = $right;
+// type inference works better with the concrete type on the
+// left, but humans work better with the expected on the
+// right
+ assert!(right == left, $($($arg)*),*);
+}
+};
+}
+
+#[cfg(minisimd_const)]
+use assert_eq;

tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs

@@ -1,14 +1,15 @@
 //@ run-pass
 //@ ignore-emscripten
 //@ ignore-android
+//@ compile-flags: --cfg minisimd_const
 
 // FIXME: this test fails on arm-android because the NDK version 14 is too old.
 // It needs at least version 18. We disable it on all android build bots because
 // there is no way in compile-test to disable it for an (arch,os) pair.
 
 // Test that the simd floating-point math intrinsics produce correct results.
 
-#![feature(repr_simd,intrinsics, core_intrinsics)]
+#![feature(repr_simd,core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -20,7 +21,10 @@ use std::intrinsics::simd::*;
 macro_rules! assert_approx_eq_f32 {
 ($a:expr, $b:expr) => {{
 let(a, b) = (&$a,&$b);
- assert!((*a - *b).abs() < 1.0e-6,"{} is not approximately equal to {}",*a,*b);
+ assert!(
+(*a - *b).abs() < 1.0e-6,
+ concat!(stringify!($a)," is not approximately equal to ", stringify!($b))
+);
 }};
 }
 macro_rules! assert_approx_eq {
@@ -34,7 +38,7 @@ macro_rules! assert_approx_eq {
 }};
 }
 
-fnmain(){
+constfnsimple_math(){
 let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
 let y = f32x4::from_array([-1.0, -1.0, -1.0, -1.0]);
 let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
@@ -43,21 +47,44 @@ fn main() {
 
 unsafe{
 let r = simd_fabs(y);
-assert_approx_eq!(x, r);
+assert_eq!(x, r);
 
-let r = simd_fcos(z);
+// rounding functions
+let r = simd_floor(h);
+assert_eq!(z, r);
+
+let r = simd_ceil(h);
+assert_eq!(x, r);
+
+let r = simd_round(h);
+assert_eq!(x, r);
+
+let r = simd_round_ties_even(h);
+assert_eq!(z, r);
+
+let r = simd_trunc(h);
+assert_eq!(z, r);
+
+let r = simd_fma(x, h, h);
 assert_approx_eq!(x, r);
 
-let r = simd_fexp(z);
+let r = simd_relaxed_fma(x, h, h);
 assert_approx_eq!(x, r);
+}
+}
 
-let r = simd_fexp2(z);
+fnspecial_math(){
+let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
+let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
+
+unsafe{
+let r = simd_fcos(z);
 assert_approx_eq!(x, r);
 
-let r = simd_fma(x, h, h);
+let r = simd_fexp(z);
 assert_approx_eq!(x, r);
 
-let r = simd_relaxed_fma(x, h, h);
+let r = simd_fexp2(z);
 assert_approx_eq!(x, r);
 
 let r = simd_fsqrt(x);
@@ -74,21 +101,11 @@ fn main() {
 
 let r = simd_fsin(z);
 assert_approx_eq!(z, r);
-
-// rounding functions
-let r = simd_floor(h);
-assert_eq!(z, r);
-
-let r = simd_ceil(h);
-assert_eq!(x, r);
-
-let r = simd_round(h);
-assert_eq!(x, r);
-
-let r = simd_round_ties_even(h);
-assert_eq!(z, r);
-
-let r = simd_trunc(h);
-assert_eq!(z, r);
 }
 }
+
+fnmain(){
+const{simple_math()};
+simple_math();
+special_math();
+}

library/core/src/intrinsics/simd.rs

@@ -1,9 +1,10 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 // Test that the simd_f{min,max} intrinsics produce the correct results.
 
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -12,7 +13,7 @@ use minisimd::*;
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnminmax(){
 let x = f32x4::from_array([1.0,2.0,3.0,4.0]);
 let y = f32x4::from_array([2.0,1.0,4.0,3.0]);
 
@@ -47,3 +48,8 @@ fn main() {
 assert_eq!(maxn, y);
 }
 }
+
+fnmain(){
+const{minmax()};
+minmax();
+}

src/tools/miri/tests/pass/intrinsics/portable-simd.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-backends: gcc
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -20,7 +21,7 @@ macro_rules! all_eq {
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnarithmetic(){
 let x1 = i32x4::from_array([1,2,3,4]);
 let y1 = U32::<4>::from_array([1,2,3,4]);
 let z1 = f32x4::from_array([1.0,2.0,3.0,4.0]);
@@ -224,3 +225,8 @@ fn main() {
 all_eq!(simd_cttz(y1),U32::<4>::from_array([0,1,0,2]));
 }
 }
+
+fnmain(){
+const{arithmetic()};
+arithmetic();
+}

tests/auxiliary/minisimd.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -12,7 +13,7 @@ use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 typeI32<constN:usize> = Simd<i32,N>;
 
-fnmain(){
+constfnsaturating(){
 // unsigned
 {
 constM:u32 = u32::MAX;
@@ -84,3 +85,8 @@ fn main() {
 }
 }
 }
+
+fnmain(){
+const{saturating()};
+saturating();
+}

tests/ui/simd/intrinsic/float-math-pass.rs

@@ -60,7 +60,7 @@ impl<T: Copy, const N: usize> PackedSimd<T, N> {
 
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pubunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
+pubconstunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
 
 fnsimd_ops_f16(){
 use intrinsics::*;

tests/ui/simd/intrinsic/float-minmax-pass.rs

@@ -10,6 +10,10 @@
 
 #![allow(unused)]
 #![allow(non_camel_case_types)]
+// FIXME: `cfg(minisimd_const)` is used to toggle use of const trait impls, which require a few
+// nightly features. Remove this when `const_trait_impls`, `const_cmp` and `const_index` are
+// stablilized.
+#![allow(unexpected_cfgs)]
 
 // 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
@@ -24,39 +28,32 @@ impl<T: Copy, const N: usize> Clone for Simd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
 }
 }
 
-impl<T,constN:usize> core::ops::Index<usize>forSimd<T,N>{
-typeOutput = T;
-fnindex(&self,i:usize) -> &T{
-&self.as_array()[i]
-}
-}
-
 impl<T,constN:usize>Simd<T,N>{
 pubconstfnfrom_array(a:[T;N]) -> Self{
 Simd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
 }
 
 pubtypeu8x2 = Simd<u8,2>;
@@ -109,6 +106,14 @@ pub type i64x8 = Simd<i64, 8>;
 pubtypei128x2 = Simd<i128,2>;
 pubtypei128x4 = Simd<i128,4>;
 
+pubtypeusizex2 = Simd<usize,2>;
+pubtypeusizex4 = Simd<usize,4>;
+pubtypeusizex8 = Simd<usize,8>;
+
+pubtypeisizex2 = Simd<isize,2>;
+pubtypeisizex4 = Simd<isize,4>;
+pubtypeisizex8 = Simd<isize,8>;
+
 pubtypef32x2 = Simd<f32,2>;
 pubtypef32x4 = Simd<f32,4>;
 pubtypef32x8 = Simd<f32,8>;
@@ -122,7 +127,7 @@ pub type f64x8 = Simd<f64, 8>;
 // which attempt to just construct it directly. That still works; it's just the
 // `.0` projection that doesn't.
 #[repr(simd, packed)]
-#[derive(Copy)]
+#[derive(Copy,Eq)]
 pubstructPackedSimd<T,constN:usize>(pub[T;N]);
 
 impl<T:Copy,constN:usize>CloneforPackedSimd<T,N>{
@@ -131,12 +136,6 @@ impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforPackedSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforPackedSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
@@ -147,14 +146,81 @@ impl<T, const N: usize> PackedSimd<T, N> {
 pubconstfnfrom_array(a:[T;N]) -> Self{
 PackedSimd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
+}
+
+// As `const_trait_impl` is a language feature with specialized syntax, we have to use them in a way
+// such that it doesn't get parsed as Rust code unless `cfg(minisimd_const)` is on. The easiest way
+// for that is a macro
+
+macro_rules! impl_traits {
+($($const_:ident)?) => {
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforSimd<T,N> {
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+
+impl<T,constN:usize> $($const_)? core::ops::Index<usize> forSimd<T,N> {
+typeOutput = T;
+fn index(&self, i:usize) -> &T{
+&self.as_array()[i]
+}
+}
+
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforPackedSimd<T,N>
+{
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+};
 }
+
+#[cfg(minisimd_const)]
+impl_traits!(const);
+
+#[cfg(not(minisimd_const))]
+impl_traits!();
+
+/// Version of `assert_eq` that ignores fancy runtime printing in const context.
+/// FIXME: Remove once <https://github.com/rust-lang/rust/issues/119826> is fixed.
+#[cfg(minisimd_const)]
+#[macro_export]
+macro_rules! assert_eq {
+($left:expr, $right:expr $(,)?) => {
+ assert_eq!(
+ $left,
+ $right,
+ concat!("`", stringify!($left),"` == `", stringify!($right),"`")
+);
+};
+($left:expr, $right:expr$(, $($arg:tt)+)?) => {
+{
+let left = $left;
+let right = $right;
+// type inference works better with the concrete type on the
+// left, but humans work better with the expected on the
+// right
+ assert!(right == left, $($($arg)*),*);
+}
+};
+}
+
+#[cfg(minisimd_const)]
+use assert_eq;

tests/ui/simd/intrinsic/generic-arithmetic-pass.rs

@@ -1,14 +1,15 @@
 //@ run-pass
 //@ ignore-emscripten
 //@ ignore-android
+//@ compile-flags: --cfg minisimd_const
 
 // FIXME: this test fails on arm-android because the NDK version 14 is too old.
 // It needs at least version 18. We disable it on all android build bots because
 // there is no way in compile-test to disable it for an (arch,os) pair.
 
 // Test that the simd floating-point math intrinsics produce correct results.
 
-#![feature(repr_simd,intrinsics, core_intrinsics)]
+#![feature(repr_simd,core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -20,7 +21,10 @@ use std::intrinsics::simd::*;
 macro_rules! assert_approx_eq_f32 {
 ($a:expr, $b:expr) => {{
 let(a, b) = (&$a,&$b);
- assert!((*a - *b).abs() < 1.0e-6,"{} is not approximately equal to {}",*a,*b);
+ assert!(
+(*a - *b).abs() < 1.0e-6,
+ concat!(stringify!($a)," is not approximately equal to ", stringify!($b))
+);
 }};
 }
 macro_rules! assert_approx_eq {
@@ -34,7 +38,7 @@ macro_rules! assert_approx_eq {
 }};
 }
 
-fnmain(){
+constfnsimple_math(){
 let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
 let y = f32x4::from_array([-1.0, -1.0, -1.0, -1.0]);
 let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
@@ -43,21 +47,44 @@ fn main() {
 
 unsafe{
 let r = simd_fabs(y);
-assert_approx_eq!(x, r);
+assert_eq!(x, r);
 
-let r = simd_fcos(z);
+// rounding functions
+let r = simd_floor(h);
+assert_eq!(z, r);
+
+let r = simd_ceil(h);
+assert_eq!(x, r);
+
+let r = simd_round(h);
+assert_eq!(x, r);
+
+let r = simd_round_ties_even(h);
+assert_eq!(z, r);
+
+let r = simd_trunc(h);
+assert_eq!(z, r);
+
+let r = simd_fma(x, h, h);
 assert_approx_eq!(x, r);
 
-let r = simd_fexp(z);
+let r = simd_relaxed_fma(x, h, h);
 assert_approx_eq!(x, r);
+}
+}
 
-let r = simd_fexp2(z);
+fnspecial_math(){
+let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
+let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
+
+unsafe{
+let r = simd_fcos(z);
 assert_approx_eq!(x, r);
 
-let r = simd_fma(x, h, h);
+let r = simd_fexp(z);
 assert_approx_eq!(x, r);
 
-let r = simd_relaxed_fma(x, h, h);
+let r = simd_fexp2(z);
 assert_approx_eq!(x, r);
 
 let r = simd_fsqrt(x);
@@ -74,21 +101,11 @@ fn main() {
 
 let r = simd_fsin(z);
 assert_approx_eq!(z, r);
-
-// rounding functions
-let r = simd_floor(h);
-assert_eq!(z, r);
-
-let r = simd_ceil(h);
-assert_eq!(x, r);
-
-let r = simd_round(h);
-assert_eq!(x, r);
-
-let r = simd_round_ties_even(h);
-assert_eq!(z, r);
-
-let r = simd_trunc(h);
-assert_eq!(z, r);
 }
 }
+
+fnmain(){
+const{simple_math()};
+simple_math();
+special_math();
+}

tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs

@@ -1,9 +1,10 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 // Test that the simd_f{min,max} intrinsics produce the correct results.
 
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -12,7 +13,7 @@ use minisimd::*;
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnminmax(){
 let x = f32x4::from_array([1.0,2.0,3.0,4.0]);
 let y = f32x4::from_array([2.0,1.0,4.0,3.0]);
 
@@ -47,3 +48,8 @@ fn main() {
 assert_eq!(maxn, y);
 }
 }
+
+fnmain(){
+const{minmax()};
+minmax();
+}

library/core/src/intrinsics/simd.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-backends: gcc
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -20,7 +21,7 @@ macro_rules! all_eq {
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnarithmetic(){
 let x1 = i32x4::from_array([1,2,3,4]);
 let y1 = U32::<4>::from_array([1,2,3,4]);
 let z1 = f32x4::from_array([1.0,2.0,3.0,4.0]);
@@ -224,3 +225,8 @@ fn main() {
 all_eq!(simd_cttz(y1),U32::<4>::from_array([0,1,0,2]));
 }
 }
+
+fnmain(){
+const{arithmetic()};
+arithmetic();
+}

src/tools/miri/tests/pass/intrinsics/portable-simd.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -12,7 +13,7 @@ use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 typeI32<constN:usize> = Simd<i32,N>;
 
-fnmain(){
+constfnsaturating(){
 // unsigned
 {
 constM:u32 = u32::MAX;
@@ -84,3 +85,8 @@ fn main() {
 }
 }
 }
+
+fnmain(){
+const{saturating()};
+saturating();
+}

tests/auxiliary/minisimd.rs

@@ -60,7 +60,7 @@ impl<T: Copy, const N: usize> PackedSimd<T, N> {
 
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pubunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
+pubconstunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
 
 fnsimd_ops_f16(){
 use intrinsics::*;

tests/ui/simd/intrinsic/float-math-pass.rs

@@ -10,6 +10,10 @@
 
 #![allow(unused)]
 #![allow(non_camel_case_types)]
+// FIXME: `cfg(minisimd_const)` is used to toggle use of const trait impls, which require a few
+// nightly features. Remove this when `const_trait_impls`, `const_cmp` and `const_index` are
+// stablilized.
+#![allow(unexpected_cfgs)]
 
 // 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
@@ -24,39 +28,32 @@ impl<T: Copy, const N: usize> Clone for Simd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
 }
 }
 
-impl<T,constN:usize> core::ops::Index<usize>forSimd<T,N>{
-typeOutput = T;
-fnindex(&self,i:usize) -> &T{
-&self.as_array()[i]
-}
-}
-
 impl<T,constN:usize>Simd<T,N>{
 pubconstfnfrom_array(a:[T;N]) -> Self{
 Simd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
 }
 
 pubtypeu8x2 = Simd<u8,2>;
@@ -109,6 +106,14 @@ pub type i64x8 = Simd<i64, 8>;
 pubtypei128x2 = Simd<i128,2>;
 pubtypei128x4 = Simd<i128,4>;
 
+pubtypeusizex2 = Simd<usize,2>;
+pubtypeusizex4 = Simd<usize,4>;
+pubtypeusizex8 = Simd<usize,8>;
+
+pubtypeisizex2 = Simd<isize,2>;
+pubtypeisizex4 = Simd<isize,4>;
+pubtypeisizex8 = Simd<isize,8>;
+
 pubtypef32x2 = Simd<f32,2>;
 pubtypef32x4 = Simd<f32,4>;
 pubtypef32x8 = Simd<f32,8>;
@@ -122,7 +127,7 @@ pub type f64x8 = Simd<f64, 8>;
 // which attempt to just construct it directly. That still works; it's just the
 // `.0` projection that doesn't.
 #[repr(simd, packed)]
-#[derive(Copy)]
+#[derive(Copy,Eq)]
 pubstructPackedSimd<T,constN:usize>(pub[T;N]);
 
 impl<T:Copy,constN:usize>CloneforPackedSimd<T,N>{
@@ -131,12 +136,6 @@ impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforPackedSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforPackedSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
@@ -147,14 +146,81 @@ impl<T, const N: usize> PackedSimd<T, N> {
 pubconstfnfrom_array(a:[T;N]) -> Self{
 PackedSimd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
+}
+
+// As `const_trait_impl` is a language feature with specialized syntax, we have to use them in a way
+// such that it doesn't get parsed as Rust code unless `cfg(minisimd_const)` is on. The easiest way
+// for that is a macro
+
+macro_rules! impl_traits {
+($($const_:ident)?) => {
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforSimd<T,N> {
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+
+impl<T,constN:usize> $($const_)? core::ops::Index<usize> forSimd<T,N> {
+typeOutput = T;
+fn index(&self, i:usize) -> &T{
+&self.as_array()[i]
+}
+}
+
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforPackedSimd<T,N>
+{
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+};
 }
+
+#[cfg(minisimd_const)]
+impl_traits!(const);
+
+#[cfg(not(minisimd_const))]
+impl_traits!();
+
+/// Version of `assert_eq` that ignores fancy runtime printing in const context.
+/// FIXME: Remove once <https://github.com/rust-lang/rust/issues/119826> is fixed.
+#[cfg(minisimd_const)]
+#[macro_export]
+macro_rules! assert_eq {
+($left:expr, $right:expr $(,)?) => {
+ assert_eq!(
+ $left,
+ $right,
+ concat!("`", stringify!($left),"` == `", stringify!($right),"`")
+);
+};
+($left:expr, $right:expr$(, $($arg:tt)+)?) => {
+{
+let left = $left;
+let right = $right;
+// type inference works better with the concrete type on the
+// left, but humans work better with the expected on the
+// right
+ assert!(right == left, $($($arg)*),*);
+}
+};
+}
+
+#[cfg(minisimd_const)]
+use assert_eq;

tests/ui/simd/intrinsic/float-minmax-pass.rs

@@ -1,14 +1,15 @@
 //@ run-pass
 //@ ignore-emscripten
 //@ ignore-android
+//@ compile-flags: --cfg minisimd_const
 
 // FIXME: this test fails on arm-android because the NDK version 14 is too old.
 // It needs at least version 18. We disable it on all android build bots because
 // there is no way in compile-test to disable it for an (arch,os) pair.
 
 // Test that the simd floating-point math intrinsics produce correct results.
 
-#![feature(repr_simd,intrinsics, core_intrinsics)]
+#![feature(repr_simd,core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -20,7 +21,10 @@ use std::intrinsics::simd::*;
 macro_rules! assert_approx_eq_f32 {
 ($a:expr, $b:expr) => {{
 let(a, b) = (&$a,&$b);
- assert!((*a - *b).abs() < 1.0e-6,"{} is not approximately equal to {}",*a,*b);
+ assert!(
+(*a - *b).abs() < 1.0e-6,
+ concat!(stringify!($a)," is not approximately equal to ", stringify!($b))
+);
 }};
 }
 macro_rules! assert_approx_eq {
@@ -34,7 +38,7 @@ macro_rules! assert_approx_eq {
 }};
 }
 
-fnmain(){
+constfnsimple_math(){
 let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
 let y = f32x4::from_array([-1.0, -1.0, -1.0, -1.0]);
 let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
@@ -43,21 +47,44 @@ fn main() {
 
 unsafe{
 let r = simd_fabs(y);
-assert_approx_eq!(x, r);
+assert_eq!(x, r);
 
-let r = simd_fcos(z);
+// rounding functions
+let r = simd_floor(h);
+assert_eq!(z, r);
+
+let r = simd_ceil(h);
+assert_eq!(x, r);
+
+let r = simd_round(h);
+assert_eq!(x, r);
+
+let r = simd_round_ties_even(h);
+assert_eq!(z, r);
+
+let r = simd_trunc(h);
+assert_eq!(z, r);
+
+let r = simd_fma(x, h, h);
 assert_approx_eq!(x, r);
 
-let r = simd_fexp(z);
+let r = simd_relaxed_fma(x, h, h);
 assert_approx_eq!(x, r);
+}
+}
 
-let r = simd_fexp2(z);
+fnspecial_math(){
+let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
+let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
+
+unsafe{
+let r = simd_fcos(z);
 assert_approx_eq!(x, r);
 
-let r = simd_fma(x, h, h);
+let r = simd_fexp(z);
 assert_approx_eq!(x, r);
 
-let r = simd_relaxed_fma(x, h, h);
+let r = simd_fexp2(z);
 assert_approx_eq!(x, r);
 
 let r = simd_fsqrt(x);
@@ -74,21 +101,11 @@ fn main() {
 
 let r = simd_fsin(z);
 assert_approx_eq!(z, r);
-
-// rounding functions
-let r = simd_floor(h);
-assert_eq!(z, r);
-
-let r = simd_ceil(h);
-assert_eq!(x, r);
-
-let r = simd_round(h);
-assert_eq!(x, r);
-
-let r = simd_round_ties_even(h);
-assert_eq!(z, r);
-
-let r = simd_trunc(h);
-assert_eq!(z, r);
 }
 }
+
+fnmain(){
+const{simple_math()};
+simple_math();
+special_math();
+}

tests/ui/simd/intrinsic/generic-arithmetic-pass.rs

@@ -1,9 +1,10 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 // Test that the simd_f{min,max} intrinsics produce the correct results.
 
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -12,7 +13,7 @@ use minisimd::*;
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnminmax(){
 let x = f32x4::from_array([1.0,2.0,3.0,4.0]);
 let y = f32x4::from_array([2.0,1.0,4.0,3.0]);
 
@@ -47,3 +48,8 @@ fn main() {
 assert_eq!(maxn, y);
 }
 }
+
+fnmain(){
+const{minmax()};
+minmax();
+}

tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-backends: gcc
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -20,7 +21,7 @@ macro_rules! all_eq {
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnarithmetic(){
 let x1 = i32x4::from_array([1,2,3,4]);
 let y1 = U32::<4>::from_array([1,2,3,4]);
 let z1 = f32x4::from_array([1.0,2.0,3.0,4.0]);
@@ -224,3 +225,8 @@ fn main() {
 all_eq!(simd_cttz(y1),U32::<4>::from_array([0,1,0,2]));
 }
 }
+
+fnmain(){
+const{arithmetic()};
+arithmetic();
+}

library/core/src/intrinsics/simd.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -12,7 +13,7 @@ use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 typeI32<constN:usize> = Simd<i32,N>;
 
-fnmain(){
+constfnsaturating(){
 // unsigned
 {
 constM:u32 = u32::MAX;
@@ -84,3 +85,8 @@ fn main() {
 }
 }
 }
+
+fnmain(){
+const{saturating()};
+saturating();
+}

src/tools/miri/tests/pass/intrinsics/portable-simd.rs

@@ -60,7 +60,7 @@ impl<T: Copy, const N: usize> PackedSimd<T, N> {
 
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pubunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
+pubconstunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
 
 fnsimd_ops_f16(){
 use intrinsics::*;

tests/auxiliary/minisimd.rs

@@ -10,6 +10,10 @@
 
 #![allow(unused)]
 #![allow(non_camel_case_types)]
+// FIXME: `cfg(minisimd_const)` is used to toggle use of const trait impls, which require a few
+// nightly features. Remove this when `const_trait_impls`, `const_cmp` and `const_index` are
+// stablilized.
+#![allow(unexpected_cfgs)]
 
 // 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
@@ -24,39 +28,32 @@ impl<T: Copy, const N: usize> Clone for Simd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
 }
 }
 
-impl<T,constN:usize> core::ops::Index<usize>forSimd<T,N>{
-typeOutput = T;
-fnindex(&self,i:usize) -> &T{
-&self.as_array()[i]
-}
-}
-
 impl<T,constN:usize>Simd<T,N>{
 pubconstfnfrom_array(a:[T;N]) -> Self{
 Simd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
 }
 
 pubtypeu8x2 = Simd<u8,2>;
@@ -109,6 +106,14 @@ pub type i64x8 = Simd<i64, 8>;
 pubtypei128x2 = Simd<i128,2>;
 pubtypei128x4 = Simd<i128,4>;
 
+pubtypeusizex2 = Simd<usize,2>;
+pubtypeusizex4 = Simd<usize,4>;
+pubtypeusizex8 = Simd<usize,8>;
+
+pubtypeisizex2 = Simd<isize,2>;
+pubtypeisizex4 = Simd<isize,4>;
+pubtypeisizex8 = Simd<isize,8>;
+
 pubtypef32x2 = Simd<f32,2>;
 pubtypef32x4 = Simd<f32,4>;
 pubtypef32x8 = Simd<f32,8>;
@@ -122,7 +127,7 @@ pub type f64x8 = Simd<f64, 8>;
 // which attempt to just construct it directly. That still works; it's just the
 // `.0` projection that doesn't.
 #[repr(simd, packed)]
-#[derive(Copy)]
+#[derive(Copy,Eq)]
 pubstructPackedSimd<T,constN:usize>(pub[T;N]);
 
 impl<T:Copy,constN:usize>CloneforPackedSimd<T,N>{
@@ -131,12 +136,6 @@ impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforPackedSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforPackedSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
@@ -147,14 +146,81 @@ impl<T, const N: usize> PackedSimd<T, N> {
 pubconstfnfrom_array(a:[T;N]) -> Self{
 PackedSimd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
+}
+
+// As `const_trait_impl` is a language feature with specialized syntax, we have to use them in a way
+// such that it doesn't get parsed as Rust code unless `cfg(minisimd_const)` is on. The easiest way
+// for that is a macro
+
+macro_rules! impl_traits {
+($($const_:ident)?) => {
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforSimd<T,N> {
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+
+impl<T,constN:usize> $($const_)? core::ops::Index<usize> forSimd<T,N> {
+typeOutput = T;
+fn index(&self, i:usize) -> &T{
+&self.as_array()[i]
+}
+}
+
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforPackedSimd<T,N>
+{
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+};
 }
+
+#[cfg(minisimd_const)]
+impl_traits!(const);
+
+#[cfg(not(minisimd_const))]
+impl_traits!();
+
+/// Version of `assert_eq` that ignores fancy runtime printing in const context.
+/// FIXME: Remove once <https://github.com/rust-lang/rust/issues/119826> is fixed.
+#[cfg(minisimd_const)]
+#[macro_export]
+macro_rules! assert_eq {
+($left:expr, $right:expr $(,)?) => {
+ assert_eq!(
+ $left,
+ $right,
+ concat!("`", stringify!($left),"` == `", stringify!($right),"`")
+);
+};
+($left:expr, $right:expr$(, $($arg:tt)+)?) => {
+{
+let left = $left;
+let right = $right;
+// type inference works better with the concrete type on the
+// left, but humans work better with the expected on the
+// right
+ assert!(right == left, $($($arg)*),*);
+}
+};
+}
+
+#[cfg(minisimd_const)]
+use assert_eq;

tests/ui/simd/intrinsic/float-math-pass.rs

@@ -1,14 +1,15 @@
 //@ run-pass
 //@ ignore-emscripten
 //@ ignore-android
+//@ compile-flags: --cfg minisimd_const
 
 // FIXME: this test fails on arm-android because the NDK version 14 is too old.
 // It needs at least version 18. We disable it on all android build bots because
 // there is no way in compile-test to disable it for an (arch,os) pair.
 
 // Test that the simd floating-point math intrinsics produce correct results.
 
-#![feature(repr_simd,intrinsics, core_intrinsics)]
+#![feature(repr_simd,core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -20,7 +21,10 @@ use std::intrinsics::simd::*;
 macro_rules! assert_approx_eq_f32 {
 ($a:expr, $b:expr) => {{
 let(a, b) = (&$a,&$b);
- assert!((*a - *b).abs() < 1.0e-6,"{} is not approximately equal to {}",*a,*b);
+ assert!(
+(*a - *b).abs() < 1.0e-6,
+ concat!(stringify!($a)," is not approximately equal to ", stringify!($b))
+);
 }};
 }
 macro_rules! assert_approx_eq {
@@ -34,7 +38,7 @@ macro_rules! assert_approx_eq {
 }};
 }
 
-fnmain(){
+constfnsimple_math(){
 let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
 let y = f32x4::from_array([-1.0, -1.0, -1.0, -1.0]);
 let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
@@ -43,21 +47,44 @@ fn main() {
 
 unsafe{
 let r = simd_fabs(y);
-assert_approx_eq!(x, r);
+assert_eq!(x, r);
 
-let r = simd_fcos(z);
+// rounding functions
+let r = simd_floor(h);
+assert_eq!(z, r);
+
+let r = simd_ceil(h);
+assert_eq!(x, r);
+
+let r = simd_round(h);
+assert_eq!(x, r);
+
+let r = simd_round_ties_even(h);
+assert_eq!(z, r);
+
+let r = simd_trunc(h);
+assert_eq!(z, r);
+
+let r = simd_fma(x, h, h);
 assert_approx_eq!(x, r);
 
-let r = simd_fexp(z);
+let r = simd_relaxed_fma(x, h, h);
 assert_approx_eq!(x, r);
+}
+}
 
-let r = simd_fexp2(z);
+fnspecial_math(){
+let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
+let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
+
+unsafe{
+let r = simd_fcos(z);
 assert_approx_eq!(x, r);
 
-let r = simd_fma(x, h, h);
+let r = simd_fexp(z);
 assert_approx_eq!(x, r);
 
-let r = simd_relaxed_fma(x, h, h);
+let r = simd_fexp2(z);
 assert_approx_eq!(x, r);
 
 let r = simd_fsqrt(x);
@@ -74,21 +101,11 @@ fn main() {
 
 let r = simd_fsin(z);
 assert_approx_eq!(z, r);
-
-// rounding functions
-let r = simd_floor(h);
-assert_eq!(z, r);
-
-let r = simd_ceil(h);
-assert_eq!(x, r);
-
-let r = simd_round(h);
-assert_eq!(x, r);
-
-let r = simd_round_ties_even(h);
-assert_eq!(z, r);
-
-let r = simd_trunc(h);
-assert_eq!(z, r);
 }
 }
+
+fnmain(){
+const{simple_math()};
+simple_math();
+special_math();
+}

tests/ui/simd/intrinsic/float-minmax-pass.rs

@@ -1,9 +1,10 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 // Test that the simd_f{min,max} intrinsics produce the correct results.
 
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -12,7 +13,7 @@ use minisimd::*;
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnminmax(){
 let x = f32x4::from_array([1.0,2.0,3.0,4.0]);
 let y = f32x4::from_array([2.0,1.0,4.0,3.0]);
 
@@ -47,3 +48,8 @@ fn main() {
 assert_eq!(maxn, y);
 }
 }
+
+fnmain(){
+const{minmax()};
+minmax();
+}

tests/ui/simd/intrinsic/generic-arithmetic-pass.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-backends: gcc
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -20,7 +21,7 @@ macro_rules! all_eq {
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnarithmetic(){
 let x1 = i32x4::from_array([1,2,3,4]);
 let y1 = U32::<4>::from_array([1,2,3,4]);
 let z1 = f32x4::from_array([1.0,2.0,3.0,4.0]);
@@ -224,3 +225,8 @@ fn main() {
 all_eq!(simd_cttz(y1),U32::<4>::from_array([0,1,0,2]));
 }
 }
+
+fnmain(){
+const{arithmetic()};
+arithmetic();
+}

tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -12,7 +13,7 @@ use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 typeI32<constN:usize> = Simd<i32,N>;
 
-fnmain(){
+constfnsaturating(){
 // unsigned
 {
 constM:u32 = u32::MAX;
@@ -84,3 +85,8 @@ fn main() {
 }
 }
 }
+
+fnmain(){
+const{saturating()};
+saturating();
+}

library/core/src/intrinsics/simd.rs

@@ -60,7 +60,7 @@ impl<T: Copy, const N: usize> PackedSimd<T, N> {
 
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pubunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
+pubconstunsafefnsimd_shuffle_const_generic<T,U,constIDX:&'static[u32]>(x:T,y:T) -> U;
 
 fnsimd_ops_f16(){
 use intrinsics::*;

src/tools/miri/tests/pass/intrinsics/portable-simd.rs

@@ -10,6 +10,10 @@
 
 #![allow(unused)]
 #![allow(non_camel_case_types)]
+// FIXME: `cfg(minisimd_const)` is used to toggle use of const trait impls, which require a few
+// nightly features. Remove this when `const_trait_impls`, `const_cmp` and `const_index` are
+// stablilized.
+#![allow(unexpected_cfgs)]
 
 // 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
@@ -24,39 +28,32 @@ impl<T: Copy, const N: usize> Clone for Simd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
 }
 }
 
-impl<T,constN:usize> core::ops::Index<usize>forSimd<T,N>{
-typeOutput = T;
-fnindex(&self,i:usize) -> &T{
-&self.as_array()[i]
-}
-}
-
 impl<T,constN:usize>Simd<T,N>{
 pubconstfnfrom_array(a:[T;N]) -> Self{
 Simd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
 }
 
 pubtypeu8x2 = Simd<u8,2>;
@@ -109,6 +106,14 @@ pub type i64x8 = Simd<i64, 8>;
 pubtypei128x2 = Simd<i128,2>;
 pubtypei128x4 = Simd<i128,4>;
 
+pubtypeusizex2 = Simd<usize,2>;
+pubtypeusizex4 = Simd<usize,4>;
+pubtypeusizex8 = Simd<usize,8>;
+
+pubtypeisizex2 = Simd<isize,2>;
+pubtypeisizex4 = Simd<isize,4>;
+pubtypeisizex8 = Simd<isize,8>;
+
 pubtypef32x2 = Simd<f32,2>;
 pubtypef32x4 = Simd<f32,4>;
 pubtypef32x8 = Simd<f32,8>;
@@ -122,7 +127,7 @@ pub type f64x8 = Simd<f64, 8>;
 // which attempt to just construct it directly. That still works; it's just the
 // `.0` projection that doesn't.
 #[repr(simd, packed)]
-#[derive(Copy)]
+#[derive(Copy,Eq)]
 pubstructPackedSimd<T,constN:usize>(pub[T;N]);
 
 impl<T:Copy,constN:usize>CloneforPackedSimd<T,N>{
@@ -131,12 +136,6 @@ impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
 }
 }
 
-impl<T:PartialEq,constN:usize>PartialEqforPackedSimd<T,N>{
-fneq(&self,other:&Self) -> bool{
-self.as_array() == other.as_array()
-}
-}
-
 impl<T: core::fmt::Debug,constN:usize> core::fmt::DebugforPackedSimd<T,N>{
 fnfmt(&self,f:&mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error>{
  <[T;N]as core::fmt::Debug>::fmt(self.as_array(), f)
@@ -147,14 +146,81 @@ impl<T, const N: usize> PackedSimd<T, N> {
 pubconstfnfrom_array(a:[T;N]) -> Self{
 PackedSimd(a)
 }
-pubfnas_array(&self) -> &[T;N]{
+pubconstfnas_array(&self) -> &[T;N]{
 let p:*constSelf = self;
 unsafe{&*p.cast::<[T;N]>()}
 }
-pubfninto_array(self) -> [T;N]
+pubconstfninto_array(self) -> [T;N]
 where
 T:Copy,
 {
 *self.as_array()
 }
+pubconstfnsplat(a:T) -> Self
+where
+T:Copy,
+{
+Self([a;N])
+}
+}
+
+// As `const_trait_impl` is a language feature with specialized syntax, we have to use them in a way
+// such that it doesn't get parsed as Rust code unless `cfg(minisimd_const)` is on. The easiest way
+// for that is a macro
+
+macro_rules! impl_traits {
+($($const_:ident)?) => {
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforSimd<T,N> {
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+
+impl<T,constN:usize> $($const_)? core::ops::Index<usize> forSimd<T,N> {
+typeOutput = T;
+fn index(&self, i:usize) -> &T{
+&self.as_array()[i]
+}
+}
+
+impl<T: $([$const_])? PartialEq,constN:usize> $($const_)? PartialEqforPackedSimd<T,N>
+{
+fn eq(&self, other:&Self) -> bool{
+self.as_array() == other.as_array()
+}
+}
+};
 }
+
+#[cfg(minisimd_const)]
+impl_traits!(const);
+
+#[cfg(not(minisimd_const))]
+impl_traits!();
+
+/// Version of `assert_eq` that ignores fancy runtime printing in const context.
+/// FIXME: Remove once <https://github.com/rust-lang/rust/issues/119826> is fixed.
+#[cfg(minisimd_const)]
+#[macro_export]
+macro_rules! assert_eq {
+($left:expr, $right:expr $(,)?) => {
+ assert_eq!(
+ $left,
+ $right,
+ concat!("`", stringify!($left),"` == `", stringify!($right),"`")
+);
+};
+($left:expr, $right:expr$(, $($arg:tt)+)?) => {
+{
+let left = $left;
+let right = $right;
+// type inference works better with the concrete type on the
+// left, but humans work better with the expected on the
+// right
+ assert!(right == left, $($($arg)*),*);
+}
+};
+}
+
+#[cfg(minisimd_const)]
+use assert_eq;

tests/auxiliary/minisimd.rs

@@ -1,14 +1,15 @@
 //@ run-pass
 //@ ignore-emscripten
 //@ ignore-android
+//@ compile-flags: --cfg minisimd_const
 
 // FIXME: this test fails on arm-android because the NDK version 14 is too old.
 // It needs at least version 18. We disable it on all android build bots because
 // there is no way in compile-test to disable it for an (arch,os) pair.
 
 // Test that the simd floating-point math intrinsics produce correct results.
 
-#![feature(repr_simd,intrinsics, core_intrinsics)]
+#![feature(repr_simd,core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -20,7 +21,10 @@ use std::intrinsics::simd::*;
 macro_rules! assert_approx_eq_f32 {
 ($a:expr, $b:expr) => {{
 let(a, b) = (&$a,&$b);
- assert!((*a - *b).abs() < 1.0e-6,"{} is not approximately equal to {}",*a,*b);
+ assert!(
+(*a - *b).abs() < 1.0e-6,
+ concat!(stringify!($a)," is not approximately equal to ", stringify!($b))
+);
 }};
 }
 macro_rules! assert_approx_eq {
@@ -34,7 +38,7 @@ macro_rules! assert_approx_eq {
 }};
 }
 
-fnmain(){
+constfnsimple_math(){
 let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
 let y = f32x4::from_array([-1.0, -1.0, -1.0, -1.0]);
 let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
@@ -43,21 +47,44 @@ fn main() {
 
 unsafe{
 let r = simd_fabs(y);
-assert_approx_eq!(x, r);
+assert_eq!(x, r);
 
-let r = simd_fcos(z);
+// rounding functions
+let r = simd_floor(h);
+assert_eq!(z, r);
+
+let r = simd_ceil(h);
+assert_eq!(x, r);
+
+let r = simd_round(h);
+assert_eq!(x, r);
+
+let r = simd_round_ties_even(h);
+assert_eq!(z, r);
+
+let r = simd_trunc(h);
+assert_eq!(z, r);
+
+let r = simd_fma(x, h, h);
 assert_approx_eq!(x, r);
 
-let r = simd_fexp(z);
+let r = simd_relaxed_fma(x, h, h);
 assert_approx_eq!(x, r);
+}
+}
 
-let r = simd_fexp2(z);
+fnspecial_math(){
+let x = f32x4::from_array([1.0,1.0,1.0,1.0]);
+let z = f32x4::from_array([0.0,0.0,0.0,0.0]);
+
+unsafe{
+let r = simd_fcos(z);
 assert_approx_eq!(x, r);
 
-let r = simd_fma(x, h, h);
+let r = simd_fexp(z);
 assert_approx_eq!(x, r);
 
-let r = simd_relaxed_fma(x, h, h);
+let r = simd_fexp2(z);
 assert_approx_eq!(x, r);
 
 let r = simd_fsqrt(x);
@@ -74,21 +101,11 @@ fn main() {
 
 let r = simd_fsin(z);
 assert_approx_eq!(z, r);
-
-// rounding functions
-let r = simd_floor(h);
-assert_eq!(z, r);
-
-let r = simd_ceil(h);
-assert_eq!(x, r);
-
-let r = simd_round(h);
-assert_eq!(x, r);
-
-let r = simd_round_ties_even(h);
-assert_eq!(z, r);
-
-let r = simd_trunc(h);
-assert_eq!(z, r);
 }
 }
+
+fnmain(){
+const{simple_math()};
+simple_math();
+special_math();
+}

tests/ui/simd/intrinsic/float-math-pass.rs

@@ -1,9 +1,10 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 // Test that the simd_f{min,max} intrinsics produce the correct results.
 
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 #![allow(non_camel_case_types)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
@@ -12,7 +13,7 @@ use minisimd::*;
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnminmax(){
 let x = f32x4::from_array([1.0,2.0,3.0,4.0]);
 let y = f32x4::from_array([2.0,1.0,4.0,3.0]);
 
@@ -47,3 +48,8 @@ fn main() {
 assert_eq!(maxn, y);
 }
 }
+
+fnmain(){
+const{minmax()};
+minmax();
+}

tests/ui/simd/intrinsic/float-minmax-pass.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-backends: gcc
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -20,7 +21,7 @@ macro_rules! all_eq {
 
 use std::intrinsics::simd::*;
 
-fnmain(){
+constfnarithmetic(){
 let x1 = i32x4::from_array([1,2,3,4]);
 let y1 = U32::<4>::from_array([1,2,3,4]);
 let z1 = f32x4::from_array([1.0,2.0,3.0,4.0]);
@@ -224,3 +225,8 @@ fn main() {
 all_eq!(simd_cttz(y1),U32::<4>::from_array([0,1,0,2]));
 }
 }
+
+fnmain(){
+const{arithmetic()};
+arithmetic();
+}

tests/ui/simd/intrinsic/generic-arithmetic-pass.rs

@@ -1,8 +1,9 @@
 //@ run-pass
 //@ ignore-emscripten
+//@ compile-flags: --cfg minisimd_const
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, core_intrinsics)]
+#![feature(repr_simd, core_intrinsics, const_trait_impl, const_cmp, const_index)]
 
 #[path = "../../../auxiliary/minisimd.rs"]
 mod minisimd;
@@ -12,7 +13,7 @@ use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 typeI32<constN:usize> = Simd<i32,N>;
 
-fnmain(){
+constfnsaturating(){
 // unsigned
 {
 constM:u32 = u32::MAX;
@@ -84,3 +85,8 @@ fn main() {
 }
 }
 }
+
+fnmain(){
+const{saturating()};
+saturating();
+}