Consolidate implementation of ExtractBit

src/System.Private.CoreLib/shared/System/BitOps.cs

@@ -355,5 +355,210 @@ int SoftwareFallback(ulong v)
             }
 #endif
         }
+
+        /// <summary>
+        /// Reads whether the specified bit in a mask is set.
+        /// Similar in behavior to the x86 instruction BT.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to read.
+        /// Any value outside the range [0..7] is treated as congruent mod 8.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ExtractBit(byte value, int bitOffset)
+            // For bit-length N, it is conventional to treat N as congruent modulo-N under the shift operation.
+            // So for uint, 1 << 33 == 1 << 1, and likewise 1 << -46 == 1 << +18.
+            // Note -46 % 32 == -14. But -46 & 31 (0011_1111) == +18. 
+            // So we use & not %.
+            => ExtractBit((uint)value, bitOffset & 7);
+
+        /// <summary>
+        /// Reads whether the specified bit in a mask is set.
+        /// Similar in behavior to the x86 instruction BT.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to read.
+        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ExtractBit(uint value, int bitOffset)
+            => (value & (1u << bitOffset)) != 0;
+
+        /// <summary>
+        /// Reads whether the specified bit in a mask is set.
+        /// Similar in behavior to the x86 instruction BT.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to read.
+        /// Any value outside the range [0..7] is treated as congruent mod 8.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ExtractBit(int value, int bitOffset)
+            => (value & (1 << bitOffset)) != 0;
+
+        /// <summary>
+        /// Clears the specified bit in a mask and returns whether it was originally set.
+        /// Similar in behavior to the x86 instruction BTR.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to clear.
+        /// Any value outside the range [0..7] is treated as congruent mod 8.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ClearBit(ref byte value, int bitOffset)
+        {
+            uint mask = 1u << (bitOffset & 7);
+
+            bool btr = (value & mask) != 0;
+            value = (byte)(value & ~mask);
+
+            return btr;
+        }
+
+        /// <summary>
+        /// Clears the specified bit in a mask and returns whether it was originally set.
+        /// Similar in behavior to the x86 instruction BTR.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to clear.
+        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ClearBit(ref uint value, int bitOffset)
+        {
+            uint mask = 1u << bitOffset;
+
+            bool btr = (value & mask) != 0;
+            value &= ~mask;
+
+            return btr;
+        }
+
+        /// <summary>
+        /// Clears the specified bit in a mask and returns whether it was originally set.
+        /// Similar in behavior to the x86 instruction BTR.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to clear.
+        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool ClearBit(ref int value, int bitOffset)
+        {
+            int mask = 1 << bitOffset;
+
+            bool btr = (value & mask) != 0;
+            value &= ~mask;
+
+            return btr;
+        }
+
+        /// <summary>
+        /// Clears the specified bit in a mask and returns the new value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to clear.
+        /// Any value outside the range [0..7] is treated as congruent mod 8.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static byte ClearBit(byte value, int bitOffset)
+            => (byte)ClearBit((uint)value, bitOffset & 7);
+
+        /// <summary>
+        /// Clears the specified bit in a mask and returns the new value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to clear.
+        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint ClearBit(uint value, int bitOffset)
+            => value & ~(1u << bitOffset);
+
+        /// <summary>
+        /// Clears the specified bit in a mask and returns the new value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to clear.
+        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ClearBit(int value, int bitOffset)
+            => value & ~(1 << bitOffset);
+
+        /// <summary>
+        /// Sets the specified bit in a mask and returns whether it was originally set.
+        /// Similar in behavior to the x86 instruction BTS.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to write.
+        /// Any value outside the range [0..7] is treated as congruent mod 8.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool InsertBit(ref byte value, int bitOffset) // TODO: offset should maybe be uint
+        {
+            uint mask = 1u << (bitOffset & 7);
+
+            bool bts = (value & mask) != 0;
+            value = (byte)(value | mask);
+
+            return bts;
+        }
+
+        /// <summary>
+        /// Sets the specified bit in a mask and returns whether it was originally set.
+        /// Similar in behavior to the x86 instruction BTS.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to write.
+        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool InsertBit(ref uint value, int bitOffset)
+        {
+            uint mask = 1u << bitOffset;
+
+            bool bts = (value & mask) != 0;
+            value |= mask;
+
+            return bts;
+        }
+
+        /// <summary>
+        /// Sets the specified bit in a mask and returns whether it was originally set.
+        /// Similar in behavior to the x86 instruction BTS.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to write.
+        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool InsertBit(ref int value, int bitOffset)
+        {
+            int mask = 1 << bitOffset;
+
+            bool bts = (value & mask) != 0;
+            value |= mask;
+
+            return bts;
+        }
+
+        /// <summary>
+        /// Sets the specified bit in a mask and returns the new value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to write.
+        /// Any value outside the range [0..7] is treated as congruent mod 8.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static byte InsertBit(byte value, int bitOffset)
+            => (byte)InsertBit((uint)value, bitOffset & 7);
+
+        /// <summary>
+        /// Sets the specified bit in a mask and returns the new value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to write.
+        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint InsertBit(uint value, int bitOffset)
+            => value | (1u << bitOffset);
+
+        /// <summary>
+        /// Sets the specified bit in a mask and returns the new value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        /// <param name="bitOffset">The ordinal position of the bit to write.
+        /// Any value outside the range [0..7] is treated as congruent mod 8.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int InsertBit(int value, int bitOffset)
+            => value | (1 << bitOffset);
     }
 }

src/System.Private.CoreLib/shared/System/Number.BigInteger.cs

@@ -460,14 +460,7 @@ public static uint CountSignificantBits(uint value)
 
             public static uint CountSignificantBits(ulong value)
             {
-                uint upper = (uint)(value >> 32);
-
-                if (upper != 0)
-                {
-                    return 32 + CountSignificantBits(upper);
-                }
-
-                return CountSignificantBits((uint)value);
+                return 64 - (uint)BitOps.LeadingZeroCount(value);
             }
 
             public static uint CountSignificantBits(ref BigInteger value)

src/System.Private.CoreLib/shared/System/SpanHelpers.Char.cs

@@ -146,7 +146,7 @@ public static unsafe bool Contains(ref char searchSpace, char value, int length)
                     length = (Vector<ushort>.Count - unaligned) & (Vector<ushort>.Count - 1);
                 }
 
-        SequentialScan:
+            SequentialScan:
                 while (length >= 4)
                 {
                     length -= 4;
@@ -208,7 +208,7 @@ public static unsafe bool Contains(ref char searchSpace, char value, int length)
 
                 return false;
 
-        Found:
+            Found:
                 return true;
             }
         }