Upgrading SpanHelpers with Vector512

src/coreclr/jit/compiler.cpp

@@ -2298,7 +2298,7 @@ void Compiler::compSetProcessor()
 
         instructionSetFlags.AddInstructionSet(InstructionSet_Vector512);
 
-        if ((preferredVectorByteLength == 0) && jitFlags.IsSet(JitFlags::JIT_FLAG_VECTOR512_THROTTLING))
+        if ((preferredVectorByteLength == 0) && opts.Vector512Throttling())
         {
             // Some architectures can experience frequency throttling when
             // executing 512-bit width instructions. To account for this we set the

src/coreclr/jit/compiler.h

@@ -9508,6 +9508,16 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
             return jitFlags->IsSet(JitFlags::JIT_FLAG_REVERSE_PINVOKE);
         }
 
+        // true if JitFlags::JIT_FLAG_VECTOR512_THROTTLING is set to true
+        bool Vector512Throttling()
+        {
+#if defined(TARGET_XARCH)
+            return jitFlags->IsSet(JitFlags::JIT_FLAG_VECTOR512_THROTTLING);
+#else
+            return false;
+#endif
+        }
+
         bool compScopeInfo; // Generate the LocalVar info ?
         bool compDbgCode;   // Generate debugger-friendly code?
         bool compDbgInfo;   // Gather debugging info?

src/coreclr/jit/hwintrinsic.cpp

@@ -515,6 +515,11 @@ NamedIntrinsic HWIntrinsicInfo::lookupId(Compiler*         comp,
         }
         else if (strcmp(className, "Vector512") == 0)
         {
+            // If the JitFlags::JIT_FLAG_VECTOR512_THROTTLING flag is set, we do not need to do any further checks.
+            if (comp->opts.Vector512Throttling())
+            {
+                return NI_IsSupported_False;
+            }
             isa = InstructionSet_AVX512F;
         }
     }

src/libraries/System.Private.CoreLib/src/System/Numerics/BitOperations.cs

@@ -944,6 +944,17 @@ internal static uint ResetLowestSetBit(uint value)
             return value & (value - 1);
         }
 
+        /// <summary>
+        /// Reset specific bit in the given value
+        /// Reset the lowest significant bit in the given value
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static ulong ResetLowestSetBit(ulong value)
+        {
+            // It's lowered to BLSR on x86
+            return value & (value - 1);
+        }
+
         /// <summary>
         /// Flip the bit at a specific position in a given value.
         /// Similar in behavior to the x86 instruction BTC (Bit Test and Complement).
@@ -957,5 +968,19 @@ internal static uint FlipBit(uint value, int index)
         {
             return value ^ (1u << index);
         }
+
+        /// <summary>
+        /// Flip the bit at a specific position in a given value.
+        /// Similar in behavior to the x86 instruction BTC (Bit Test and Complement).
+        /// /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="index">The zero-based index of the bit to flip.
+        /// Any value outside the range [0..63] is treated as congruent mod 64.</param>
+        /// <returns>The new value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static ulong FlipBit(ulong value, int index)
+        {
+            return value ^ (1ul << index);
+        }
     }
 }

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

@@ -1791,6 +1791,21 @@ public static Vector512<T> LoadUnsafe<T>(ref T source, nuint elementOffset)
             return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref source));
         }
 
+        /// <summary>Loads a vector from the given source and reinterprets it as <see cref="ushort"/>.</summary>
+        /// <param name="source">The source from which the vector will be loaded.</param>
+        /// <returns>The vector loaded from <paramref name="source" />.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static Vector512<ushort> LoadUnsafe(ref char source) =>
+            LoadUnsafe(ref Unsafe.As<char, ushort>(ref source));
+
+        /// <summary>Loads a vector from the given source and element offset and reinterprets it as <see cref="ushort"/>.</summary>
+        /// <param name="source">The source to which <paramref name="elementOffset" /> will be added before loading the vector.</param>
+        /// <param name="elementOffset">The element offset from <paramref name="source" /> from which the vector will be loaded.</param>
+        /// <returns>The vector loaded from <paramref name="source" /> plus <paramref name="elementOffset" />.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static Vector512<ushort> LoadUnsafe(ref char source, nuint elementOffset) =>
+            LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset);
+
         /// <summary>Computes the maximum of two vectors on a per-element basis.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="left">The vector to compare with <paramref name="right" />.</param>