use simd_splat

Author: folkertdev

library/stdarch/crates/core_arch/src/macros.rs

@@ -90,17 +90,10 @@ macro_rules! types {
         pub struct $name($v [$elem_type; $len]);
 
         impl $name {
-            /// Using `my_simd([x; N])` seemingly fails tests,
-            /// so use this internal helper for it instead.
+            /// Put the same value in every lane.
             #[inline(always)]
             $v fn splat(value: $elem_type) -> $name {
-                #[derive(Copy, Clone)]
-                #[repr(simd)]
-                struct JustOne([$elem_type; 1]);
-                let one = JustOne([value]);
-                // SAFETY: 0 is always in-bounds because we're shuffling
-                // a simd type with exactly one element.
-                unsafe { simd_shuffle!(one, one, [0; $len]) }
+                unsafe { $crate::intrinsics::simd::simd_splat(value) }
             }
 
             /// Returns an array reference containing the entire SIMD vector.

library/stdarch/crates/core_arch/src/powerpc/altivec.rs

@@ -1457,15 +1457,15 @@ mod sealed {
     #[cfg_attr(test, assert_instr(vspltb, IMM4 = 15))]
     unsafe fn vspltb<const IMM4: u32>(a: vector_signed_char) -> vector_signed_char {
         static_assert_uimm_bits!(IMM4, 4);
-        simd_shuffle(a, a, const { u32x16::from_array([IMM4; 16]) })
+        simd_shuffle(a, a, const { u32x16::splat(IMM4) })
     }
 
     #[inline]
     #[target_feature(enable = "altivec")]
     #[cfg_attr(test, assert_instr(vsplth, IMM3 = 7))]
     unsafe fn vsplth<const IMM3: u32>(a: vector_signed_short) -> vector_signed_short {
         static_assert_uimm_bits!(IMM3, 3);
-        simd_shuffle(a, a, const { u32x8::from_array([IMM3; 8]) })
+        simd_shuffle(a, a, const { u32x8::splat(IMM3) })
     }
 
     #[inline]
@@ -1474,7 +1474,7 @@ mod sealed {
     #[cfg_attr(all(test, target_feature = "vsx"), assert_instr(xxspltw, IMM2 = 3))]
     unsafe fn vspltw<const IMM2: u32>(a: vector_signed_int) -> vector_signed_int {
         static_assert_uimm_bits!(IMM2, 2);
-        simd_shuffle(a, a, const { u32x4::from_array([IMM2; 4]) })
+        simd_shuffle(a, a, const { u32x4::splat(IMM2) })
     }
 
     #[unstable(feature = "stdarch_powerpc", issue = "111145")]

library/stdarch/crates/core_arch/src/simd.rs

@@ -50,14 +50,10 @@ impl<T: SimdElement, const N: usize> Simd<T, N> {
         Self(elements)
     }
 
-    // FIXME: Workaround rust@60637
-    #[inline(always)]
+    #[inline]
     #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
     pub(crate) const fn splat(value: T) -> Self {
-        let one = Simd([value]);
-        // SAFETY: 0 is always in-bounds because we're shuffling
-        // a simd type with exactly one element.
-        unsafe { simd_shuffle!(one, one, [0; N]) }
+        unsafe { crate::intrinsics::simd::simd_splat(value) }
     }
 
     /// Extract the element at position `index`. Note that `index` is not a constant so this
@@ -182,14 +178,10 @@ impl<T: SimdElement, const N: usize> SimdM<T, N> {
         [zeros, ones][x as usize]
     }
 
-    // FIXME: Workaround rust@60637
-    #[inline(always)]
+    #[inline]
     #[rustc_const_unstable(feature = "stdarch_const_helpers", issue = "none")]
     pub(crate) const fn splat(value: bool) -> Self {
-        let one = SimdM([Self::bool_to_internal(value)]);
-        // SAFETY: 0 is always in-bounds because we're shuffling
-        // a simd type with exactly one element.
-        unsafe { simd_shuffle!(one, one, [0; N]) }
+        unsafe { crate::intrinsics::simd::simd_splat(value) }
     }
 
     #[inline]