Implement ShuffleUnsafe methods

src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs

@@ -2314,23 +2314,22 @@
         /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>
         /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
         [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector128<byte> Shuffle(Vector128<byte> vector, Vector128<byte> indices)
         {
-            Unsafe.SkipInit(out Vector128<byte> result);
-
-            for (int index = 0; index < Vector128<byte>.Count; index++)
+            if (ShuffleUnsafeIntrinsicSupported)
             {
-                byte selectedIndex = indices.GetElementUnsafe(index);
-                byte selectedValue = 0;
-
-                if (selectedIndex < Vector128<byte>.Count)
+                if (ShuffleUnsafeIntrinsicIsSafe)
                 {
-                    selectedValue = vector.GetElementUnsafe(selectedIndex);
+                    return ShuffleUnsafeIntrinsic(vector, indices);
+                }
+                else
+                {
+                    Vector128<byte> mask = Vector512.LessThan(indices, Vector128.Create(16));
+                    return ShuffleUnsafeIntrinsic(vector, indices) & mask;
                 }
-                result.SetElementUnsafe(index, selectedValue);
             }
-
-            return result;
+            return ShuffleSoftwareFallback(vector, indices);
         }
 
         /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.</summary>
@@ -2339,16 +2338,41 @@
         /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
         [Intrinsic]
         [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector128<sbyte> Shuffle(Vector128<sbyte> vector, Vector128<sbyte> indices)
         {
-            Unsafe.SkipInit(out Vector128<sbyte> result);
+            return Shuffle(vector.AsByte(), indices.AsByte()).AsSByte();
+        }
 
-            for (int index = 0; index < Vector128<sbyte>.Count; index++)
+        /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.
+        /// Behavior is platform-dependent for out-of-range indices.</summary>
+        /// <param name="vector">The input vector from which values are selected.</param>
+        /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>
+        /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
+        /// <remarks>Unlike Shuffle, this method delegates to the underlying hardware intrinsic without ensuring that <paramref name="indices"/> are normalized to [0, 15].
+        /// On hardware with <see cref="Ssse3"/> support, indices are treated as modulo 16, and if the high bit is set, the result will be set to 0 for that element.
+        /// On hardware with <see cref="AdvSimd.Arm64"/> or <see cref="PackedSimd"/> support, this method behaves the same as Shuffle.</remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [CompExactlyDependsOn(typeof(Ssse3))]
+        [CompExactlyDependsOn(typeof(AdvSimd))]
+        [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
+        [CompExactlyDependsOn(typeof(PackedSimd))]
+        public static Vector128<byte> ShuffleUnsafe(Vector128<byte> vector, Vector128<byte> indices)
+        {
+            if (ShuffleUnsafeIntrinsicSupported) return ShuffleUnsafeIntrinsic(vector, indices);
+            return Shuffle(vector, indices);
+        }
+
+        private static Vector128<byte> ShuffleSoftwareFallback(Vector128<byte> vector, Vector128<byte> indices)
+        {
+            Unsafe.SkipInit(out Vector128<byte> result);
+
+            for (int index = 0; index < Vector128<byte>.Count; index++)
             {
-                byte selectedIndex = (byte)indices.GetElementUnsafe(index);
-                sbyte selectedValue = 0;
+                byte selectedIndex = indices.GetElementUnsafe(index);
+                byte selectedValue = 0;
 
-                if (selectedIndex < Vector128<sbyte>.Count)
+                if (selectedIndex < Vector128<byte>.Count)
                 {
                     selectedValue = vector.GetElementUnsafe(selectedIndex);
                 }
@@ -2358,20 +2382,12 @@
             return result;
         }
 
-        /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.
-        /// Behavior is platform-dependent for out-of-range indices.</summary>
-        /// <param name="vector">The input vector from which values are selected.</param>
-        /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>
-        /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
-        /// <remarks>Unlike Shuffle, this method delegates to the underlying hardware intrinsic without ensuring that <paramref name="indices"/> are normalized to [0, 15].
-        /// On hardware with <see cref="Ssse3"/> support, indices are treated as modulo 16, and if the high bit is set, the result will be set to 0 for that element.
-        /// On hardware with <see cref="AdvSimd.Arm64"/> or <see cref="PackedSimd"/> support, this method behaves the same as Shuffle.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [CompExactlyDependsOn(typeof(Ssse3))]
         [CompExactlyDependsOn(typeof(AdvSimd))]
         [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
         [CompExactlyDependsOn(typeof(PackedSimd))]
-        public static Vector128<byte> ShuffleUnsafe(Vector128<byte> vector, Vector128<byte> indices)
+        private static Vector128<byte> ShuffleUnsafeIntrinsic(Vector128<byte> vector, Vector128<byte> indices)
         {
             if (Ssse3.IsSupported)
             {
@@ -2388,9 +2404,12 @@
                 return PackedSimd.Swizzle(vector, indices);
             }
 
-            return Shuffle(vector, indices);
+            Debug.Fail("Expected an intrinsic to be supported");
         }
 
+        private static bool ShuffleUnsafeIntrinsicIsSafe => AdvSimd.Arm64.IsSupported || PackedSimd.IsSupported; // only the arm64 and wasm implementations are safe
+        private static bool ShuffleUnsafeIntrinsicSupported => Ssse3.IsSupported || AdvSimd.Arm64.IsSupported || PackedSimd.IsSupported;
+
         /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.</summary>
         /// <param name="vector">The input vector from which values are selected.</param>
         /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>

src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs

@@ -2294,23 +2294,22 @@
         /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>
         /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
         [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector256<byte> Shuffle(Vector256<byte> vector, Vector256<byte> indices)
         {
-            Unsafe.SkipInit(out Vector256<byte> result);
-
-            for (int index = 0; index < Vector256<byte>.Count; index++)
+            if (ShuffleUnsafeIntrinsicSupported)
             {
-                byte selectedIndex = indices.GetElementUnsafe(index);
-                byte selectedValue = 0;
-
-                if (selectedIndex < Vector256<byte>.Count)
+                if (ShuffleUnsafeIntrinsicIsSafe)
                 {
-                    selectedValue = vector.GetElementUnsafe(selectedIndex);
+                    return ShuffleUnsafeIntrinsic(vector, indices);
+                }
+                else
+                {
+                    Vector256<byte> mask = Vector512.LessThan(indices, Vector256.Create(32));
+                    return ShuffleUnsafeIntrinsic(vector, indices) & mask;
                 }
-                result.SetElementUnsafe(index, selectedValue);
             }
-
-            return result;
+            return ShuffleSoftwareFallback(vector, indices);
         }
 
         /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.</summary>
@@ -2319,16 +2318,37 @@
         /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
         [Intrinsic]
         [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector256<sbyte> Shuffle(Vector256<sbyte> vector, Vector256<sbyte> indices)
         {
-            Unsafe.SkipInit(out Vector256<sbyte> result);
+            return Shuffle(vector.AsByte(), indices.AsByte()).AsSByte();
+        }
 
-            for (int index = 0; index < Vector256<sbyte>.Count; index++)
+        /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.
+        /// Behavior is platform-dependent for out-of-range indices.</summary>
+        /// <param name="vector">The input vector from which values are selected.</param>
+        /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>
+        /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
+        /// <remarks>Unlike Shuffle, this method delegates to the underlying hardware intrinsic without ensuring that <paramref name="indices"/> are normalized to [0, 31].</remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [CompExactlyDependsOn(typeof(Avx2))]
+        [CompExactlyDependsOn(typeof(Avx512Vbmi.VL))]
+        public static Vector256<byte> ShuffleUnsafe(Vector256<byte> vector, Vector256<byte> indices)
+        {
+            if (ShuffleUnsafeIntrinsicSupported) return ShuffleUnsafeIntrinsic(vector, indices);
+            return Shuffle(vector, indices);
+        }
+
+        private static Vector256<byte> ShuffleSoftwareFallback(Vector256<byte> vector, Vector256<byte> indices)
+        {
+            Unsafe.SkipInit(out Vector256<byte> result);
+
+            for (int index = 0; index < Vector256<byte>.Count; index++)
             {
-                byte selectedIndex = (byte)indices.GetElementUnsafe(index);
-                sbyte selectedValue = 0;
+                byte selectedIndex = indices.GetElementUnsafe(index);
+                byte selectedValue = 0;
 
-                if (selectedIndex < Vector256<sbyte>.Count)
+                if (selectedIndex < Vector256<byte>.Count)
                 {
                     selectedValue = vector.GetElementUnsafe(selectedIndex);
                 }
@@ -2338,19 +2358,13 @@
             return result;
         }
 
-        /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.
-        /// Behavior is platform-dependent for out-of-range indices.</summary>
-        /// <param name="vector">The input vector from which values are selected.</param>
-        /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>
-        /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
-        /// <remarks>Unlike Shuffle, this method delegates to the underlying hardware intrinsic without ensuring that <paramref name="indices"/> are normalized to [0, 31].</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [CompExactlyDependsOn(typeof(Avx2))]
         [CompExactlyDependsOn(typeof(Avx512Vbmi.VL))]
-        public static Vector256<byte> ShuffleUnsafe(Vector256<byte> vector, Vector256<byte> indices)
+        private static Vector256<byte> ShuffleUnsafeIntrinsic(Vector256<byte> vector, Vector256<byte> indices)
         {
             if (Avx512Vbmi.VL.IsSupported)
             {
                 return Avx512Vbmi.VL.PermuteVar32x8(vector, indices);
             }
 
@@ -2394,9 +2408,12 @@
                 return Avx2.BlendVariable(shuf1, shuf2, selection);
             }
 
-            return Shuffle(vector, indices);
+            Debug.Fail("Expected an intrinsic to be supported");
         }
 
+        private static bool ShuffleUnsafeIntrinsicIsSafe => false; // none are safe
+        private static bool ShuffleUnsafeIntrinsicSupported => Avx512Vbmi.VL.IsSupported || Avx2.IsSupported;
+
         /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.</summary>
         /// <param name="vector">The input vector from which values are selected.</param>
         /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>

src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs

@@ -2341,23 +2341,22 @@
         /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>
         /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
         [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector512<byte> Shuffle(Vector512<byte> vector, Vector512<byte> indices)
         {
-            Unsafe.SkipInit(out Vector512<byte> result);
-
-            for (int index = 0; index < Vector512<byte>.Count; index++)
+            if (ShuffleUnsafeIntrinsicSupported)
             {
-                byte selectedIndex = indices.GetElementUnsafe(index);
-                byte selectedValue = 0;
-
-                if (selectedIndex < Vector512<byte>.Count)
+                if (ShuffleUnsafeIntrinsicIsSafe)
                 {
-                    selectedValue = vector.GetElementUnsafe(selectedIndex);
+                    return ShuffleUnsafeIntrinsic(vector, indices);
+                }
+                else
+                {
+                    Vector512<byte> mask = Vector512.LessThan(indices, Vector512.Create(64));
+                    return ShuffleUnsafeIntrinsic(vector, indices) & mask;
                 }
-                result.SetElementUnsafe(index, selectedValue);
             }
-
-            return result;
+            return ShuffleSoftwareFallback(vector, indices);
         }
 
         /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.</summary>
@@ -2366,16 +2365,36 @@
         /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
         [Intrinsic]
         [CLSCompliant(false)]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector512<sbyte> Shuffle(Vector512<sbyte> vector, Vector512<sbyte> indices)
         {
-            Unsafe.SkipInit(out Vector512<sbyte> result);
+            return Shuffle(vector.AsByte(), indices.AsByte()).AsSByte();
+        }
 
-            for (int index = 0; index < Vector512<sbyte>.Count; index++)
+        /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.
+        /// Behavior is platform-dependent for out-of-range indices.</summary>
+        /// <param name="vector">The input vector from which values are selected.</param>
+        /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>
+        /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
+        /// <remarks>Unlike Shuffle, this method delegates to the underlying hardware intrinsic without ensuring that <paramref name="indices"/> are normalized to [0, 63].</remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [CompExactlyDependsOn(typeof(Avx512Vbmi))]
+        public static Vector512<byte> ShuffleUnsafe(Vector512<byte> vector, Vector512<byte> indices)
+        {
+            if (ShuffleUnsafeIntrinsicSupported) return ShuffleUnsafeIntrinsic(vector, indices);
+            return Shuffle(vector, indices);
+        }
+
+        private static Vector512<byte> ShuffleSoftwareFallback(Vector512<byte> vector, Vector512<byte> indices)
+        {
+            Unsafe.SkipInit(out Vector512<byte> result);
+
+            for (int index = 0; index < Vector512<byte>.Count; index++)
             {
-                byte selectedIndex = (byte)indices.GetElementUnsafe(index);
-                sbyte selectedValue = 0;
+                byte selectedIndex = indices.GetElementUnsafe(index);
+                byte selectedValue = 0;
 
-                if (selectedIndex < Vector512<sbyte>.Count)
+                if (selectedIndex < Vector512<byte>.Count)
                 {
                     selectedValue = vector.GetElementUnsafe(selectedIndex);
                 }
@@ -2385,24 +2404,21 @@
             return result;
         }
 
-        /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.
-        /// Behavior is platform-dependent for out-of-range indices.</summary>
-        /// <param name="vector">The input vector from which values are selected.</param>
-        /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>
-        /// <returns>A new vector containing the values from <paramref name="vector" /> selected by the given <paramref name="indices" />.</returns>
-        /// <remarks>Unlike Shuffle, this method delegates to the underlying hardware intrinsic without ensuring that <paramref name="indices"/> are normalized to [0, 63].</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [CompExactlyDependsOn(typeof(Avx512Vbmi))]
-        public static Vector512<byte> ShuffleUnsafe(Vector512<byte> vector, Vector512<byte> indices)
+        private static Vector512<byte> ShuffleUnsafeIntrinsic(Vector512<byte> vector, Vector512<byte> indices)
         {
             if (Avx512Vbmi.IsSupported)
             {
                 return Avx512Vbmi.PermuteVar64x8(vector, indices);
             }
 
-            return Shuffle(vector, indices);
+            Debug.Fail("Expected an intrinsic to be supported");
         }
 
+        private static bool ShuffleUnsafeIntrinsicIsSafe => false; // none are safe
+        private static bool ShuffleUnsafeIntrinsicSupported => Avx512Vbmi.IsSupported;
+
         /// <summary>Creates a new vector by selecting values from an input vector using a set of indices.</summary>
         /// <param name="vector">The input vector from which values are selected.</param>
         /// <param name="indices">The per-element indices used to select a value from <paramref name="vector" />.</param>