BitOperations

src\libraries\Common\src\Internal\VersionResilientHashCode.cs (2)

171return (int)BitOperations.RotateLeft((uint)value, bitCount); 183return (BitOperations.RotateLeft((hash + queuedValue * 3266489917U/*Prime3*/), 17)) * 668265263U/*Prime4*/;

src\libraries\Common\src\System\Sha1ForNonSecretPurposes.cs (9)

src\libraries\System.Private.CoreLib\src\System\Array.cs (2)

2687IntroSort(left, length + left - 1, 2 * (BitOperations.Log2((uint)length) + 1)); 2900IntroSort(left, length + left - 1, 2 * (BitOperations.Log2((uint)length) + 1));

src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.ReverseEndianness.cs (2)

150return BitOperations.RotateRight(value & 0x00FF00FFu, 8) // xx zz 151+ BitOperations.RotateLeft(value & 0xFF00FF00u, 8); // ww yy

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\FormattingHelpers.CountDigits.cs (1)

112return (BitOperations.Log2(value) >> 2) + 1;

src\libraries\System.Private.CoreLib\src\System\Buffers\Utilities.cs (1)

20return BitOperations.Log2((uint)bufferSize - 1 | 15) - 3;

src\libraries\System.Private.CoreLib\src\System\Byte.cs (5)

282public static byte LeadingZeroCount(byte value) => (byte)(BitOperations.LeadingZeroCount(value) - 24); 285public static byte PopCount(byte value) => (byte)BitOperations.PopCount(value); 294public static byte TrailingZeroCount(byte value) => (byte)(BitOperations.TrailingZeroCount(value << 24) - 24); 412public static bool IsPow2(byte value) => BitOperations.IsPow2((uint)value); 415public static byte Log2(byte value) => (byte)BitOperations.Log2(value);

src\libraries\System.Private.CoreLib\src\System\Char.cs (3)

1215static char IBinaryInteger<char>.LeadingZeroCount(char value) => (char)(BitOperations.LeadingZeroCount(value) - 16); 1218static char IBinaryInteger<char>.PopCount(char value) => (char)BitOperations.PopCount(value); 1227static char IBinaryInteger<char>.TrailingZeroCount(char value) => (char)(BitOperations.TrailingZeroCount(value << 16) - 16);

src\libraries\System.Private.CoreLib\src\System\Collections\Concurrent\ConcurrentQueue.cs (1)

97length = (int)Math.Min(BitOperations.RoundUpToPowerOf2((uint)count), MaxSegmentLength);

src\libraries\System.Private.CoreLib\src\System\Collections\Concurrent\ConcurrentQueueSegment.cs (1)

49Debug.Assert(BitOperations.IsPow2(boundedLength), $"Must be a power of 2, got {boundedLength}");

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ArraySortHelper.cs (6)

127IntroSort(keys, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer); 306IntroSort(keys, 2 * (BitOperations.Log2((uint)keys.Length) + 1)); 673IntroSort(keys, values, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer); 858IntroSort(keys, values, 2 * (BitOperations.Log2((uint)keys.Length) + 1)); 1196IntroSort(keys, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer); 1411IntroSort(keys, values, 2 * (BitOperations.Log2((uint)keys.Length) + 1), comparer);

src\libraries\System.Private.CoreLib\src\System\Decimal.DecCalc.cs (3)

623newScale -= BitOperations.LeadingZeroCount(result[hiRes]); 2034curScale = BitOperations.LeadingZeroCount(tmp); 2307int shift = BitOperations.LeadingZeroCount(tmp);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (1)

5757if (isbitmap && !BitOperations.IsPow2(hexValue))

src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.cs (4)

515mask = BitOperations.ResetLowestSetBit(BitOperations.ResetLowestSetBit(mask)); 581mask = BitOperations.ResetLowestSetBit(BitOperations.ResetLowestSetBit(mask));

src\libraries\System.Private.CoreLib\src\System\Half.cs (2)

1105int shiftDist = BitOperations.LeadingZeroCount(sig) - 16 - 5; 1535return MinExponent - (BitOperations.LeadingZeroCount(x.TrailingSignificand) - BiasedExponentLength);

src\libraries\System.Private.CoreLib\src\System\HashCode.cs (6)

271return BitOperations.RotateLeft(hash + input * Prime2, 13) * Prime1; 277return BitOperations.RotateLeft(hash + queuedValue * Prime3, 17) * Prime4; 283return BitOperations.RotateLeft(v1, 1) + BitOperations.RotateLeft(v2, 7) + BitOperations.RotateLeft(v3, 12) + BitOperations.RotateLeft(v4, 18);

src\libraries\System.Private.CoreLib\src\System\Int128.cs (2)

724return 64 + BitOperations.LeadingZeroCount(value._lower); 726return BitOperations.LeadingZeroCount(value._upper);

src\libraries\System.Private.CoreLib\src\System\Int16.cs (5)

285public static short LeadingZeroCount(short value) => (short)(BitOperations.LeadingZeroCount((ushort)value) - 16); 288public static short PopCount(short value) => (short)BitOperations.PopCount((ushort)value); 297public static short TrailingZeroCount(short value) => (byte)(BitOperations.TrailingZeroCount(value << 16) - 16); 499public static bool IsPow2(short value) => BitOperations.IsPow2(value); 508return (short)BitOperations.Log2((ushort)value);

src\libraries\System.Private.CoreLib\src\System\Int32.cs (7)

301public static int LeadingZeroCount(int value) => BitOperations.LeadingZeroCount((uint)value); 305public static int PopCount(int value) => BitOperations.PopCount((uint)value); 309public static int RotateLeft(int value, int rotateAmount) => (int)BitOperations.RotateLeft((uint)value, rotateAmount); 313public static int RotateRight(int value, int rotateAmount) => (int)BitOperations.RotateRight((uint)value, rotateAmount); 317public static int TrailingZeroCount(int value) => BitOperations.TrailingZeroCount(value); 538public static bool IsPow2(int value) => BitOperations.IsPow2(value); 549return BitOperations.Log2((uint)value);

src\libraries\System.Private.CoreLib\src\System\Int64.cs (9)

298public static long LeadingZeroCount(long value) => BitOperations.LeadingZeroCount((ulong)value); 302public static long PopCount(long value) => BitOperations.PopCount((ulong)value); 306public static long RotateLeft(long value, int rotateAmount) => (long)BitOperations.RotateLeft((ulong)value, rotateAmount); 310public static long RotateRight(long value, int rotateAmount) => (long)BitOperations.RotateRight((ulong)value, rotateAmount); 314public static long TrailingZeroCount(long value) => BitOperations.TrailingZeroCount(value); 490return (sizeof(long) * 8) - BitOperations.LeadingZeroCount((ulong)(value)); 494return (sizeof(long) * 8) + 1 - BitOperations.LeadingZeroCount((ulong)(~value)); 535public static bool IsPow2(long value) => BitOperations.IsPow2(value); 546return BitOperations.Log2((ulong)value);

src\libraries\System.Private.CoreLib\src\System\IntPtr.cs (9)

321public static nint LeadingZeroCount(nint value) => BitOperations.LeadingZeroCount((nuint)value); 325public static nint PopCount(nint value) => BitOperations.PopCount((nuint)value); 329public static nint RotateLeft(nint value, int rotateAmount) => (nint)BitOperations.RotateLeft((nuint)value, rotateAmount); 333public static nint RotateRight(nint value, int rotateAmount) => (nint)BitOperations.RotateRight((nuint)value, rotateAmount); 337public static nint TrailingZeroCount(nint value) => BitOperations.TrailingZeroCount(value); 513return (sizeof(nint_t) * 8) - BitOperations.LeadingZeroCount((nuint)value); 517return (sizeof(nint_t) * 8) + 1 - BitOperations.LeadingZeroCount((nuint)(~value)); 558public static bool IsPow2(nint value) => BitOperations.IsPow2(value); 569return BitOperations.Log2((nuint)value);

src\libraries\System.Private.CoreLib\src\System\Marvin.cs (1)

10using static System.Numerics.BitOperations;

src\libraries\System.Private.CoreLib\src\System\Math.cs (1)

898return double.MinExponent - (BitOperations.LeadingZeroCount(x.TrailingSignificand) - double.BiasedExponentLength);

src\libraries\System.Private.CoreLib\src\System\MathF.cs (1)

213return float.MinExponent - (BitOperations.LeadingZeroCount(x.TrailingSignificand) - float.BiasedExponentLength);

src\libraries\System.Private.CoreLib\src\System\Number.BigInteger.cs (3)

426return 32 - BitOperations.LeadingZeroCount(value); 431return 64 - BitOperations.LeadingZeroCount(value); 527int shiftLeft = BitOperations.LeadingZeroCount(divHi);

src\libraries\System.Private.CoreLib\src\System\Number.DiyFp.cs (1)

93int lzcnt = BitOperations.LeadingZeroCount(f);

src\libraries\System.Private.CoreLib\src\System\Number.Dragon4.cs (2)

35mantissaHighBitIdx = (uint)BitOperations.Log2(mantissa); 287int hiBlockLog2 = BitOperations.Log2(hiBlock);

src\libraries\System.Private.CoreLib\src\System\Number.NumberToFloatingPointBits.cs (1)

1294int lz = BitOperations.LeadingZeroCount(w);

src\libraries\System.Private.CoreLib\src\System\Numerics\BFloat16.cs (1)

1192return MinExponent - (BitOperations.LeadingZeroCount(x.TrailingSignificand) - BiasedExponentLength);

src\libraries\System.Private.CoreLib\src\System\Random.CompatImpl.cs (2)

72int bits = BitOperations.Log2Ceiling(exclusiveRange); 195int bits = BitOperations.Log2Ceiling(exclusiveRange);

src\libraries\System.Private.CoreLib\src\System\Random.cs (2)

215if (BitOperations.IsPow2(choices.Length)) 247int mask = (int)BitOperations.RoundUpToPowerOf2((uint)choices.Length) - 1;

src\libraries\System.Private.CoreLib\src\System\Random.Xoshiro256StarStarImpl.cs (6)

57ulong result = BitOperations.RotateLeft(s1 * 5, 7) * 9; 66s3 = BitOperations.RotateLeft(s3, 45); 142MemoryMarshal.Write(buffer, BitOperations.RotateLeft(s1 * 5, 7) * 9); 151s3 = BitOperations.RotateLeft(s3, 45); 158ulong next = BitOperations.RotateLeft(s1 * 5, 7) * 9; 173s3 = BitOperations.RotateLeft(s3, 45);

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\CastCache.cs (4)

39Debug.Assert(BitOperations.PopCount((uint)initialCacheSize) == 1 && initialCacheSize > 1); 40Debug.Assert(BitOperations.PopCount((uint)maxCacheSize) == 1 && maxCacheSize >= initialCacheSize); 95nuint hash = BitOperations.RotateLeft(source, (nuint.Size * 8) / 2) ^ target; 253byte shift = (byte)BitOperations.LeadingZeroCount((nuint)(size - 1));

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\ConditionalWeakTable.cs (3)

569Debug.Assert(BitOperations.IsPow2(InitialCapacity)); 592Debug.Assert(BitOperations.IsPow2(buckets.Length)); 797Debug.Assert(BitOperations.IsPow2(newSize));

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\GenericCache.cs (3)

77Debug.Assert(BitOperations.PopCount((uint)initialCacheSize) == 1 && initialCacheSize > 1); 78Debug.Assert(BitOperations.PopCount((uint)maxCacheSize) == 1 && maxCacheSize >= initialCacheSize); 234byte shift = (byte)BitOperations.LeadingZeroCount((nuint)(size - 1));

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\NativeMemory.Unix.cs (2)

26if (!BitOperations.IsPow2(alignment)) 87if (!BitOperations.IsPow2(alignment))

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128.cs (3)

853public static int Count<T>(Vector128<T> vector, T value) => BitOperations.PopCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 1935int result = BitOperations.TrailingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 2168public static int LastIndexOf<T>(Vector128<T> vector, T value) => 31 - BitOperations.LeadingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits());

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128.Numerics.cs (12)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256.cs (3)

860public static int Count<T>(Vector256<T> vector, T value) => BitOperations.PopCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 2019int result = BitOperations.TrailingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 2252public static int LastIndexOf<T>(Vector256<T> vector, T value) => 31 - BitOperations.LeadingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits());

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512.cs (3)

763public static int Count<T>(Vector512<T> vector, T value) => BitOperations.PopCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 2045int result = BitOperations.TrailingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 2278public static int LastIndexOf<T>(Vector512<T> vector, T value) => 63 - BitOperations.LeadingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits());

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector64.cs (3)

827public static int Count<T>(Vector64<T> vector, T value) => BitOperations.PopCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 1851int result = BitOperations.TrailingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits()); 2093public static int LastIndexOf<T>(Vector64<T> vector, T value) => 31 - BitOperations.LeadingZeroCount(Equals(vector, Create(value)).ExtractMostSignificantBits());

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\X86\X86Base.cs (4)

41/// <para>Its functionality is exposed in the public <see cref="Numerics.BitOperations" /> class.</para> 52/// <para>Its functionality is exposed in the public <see cref="Numerics.BitOperations" /> class.</para> 78/// <para>Its functionality is exposed in the public <see cref="Numerics.BitOperations" /> class.</para> 89/// <para>Its functionality is exposed in the public <see cref="Numerics.BitOperations" /> class.</para>

src\libraries\System.Private.CoreLib\src\System\SByte.cs (5)

288public static sbyte LeadingZeroCount(sbyte value) => (sbyte)(BitOperations.LeadingZeroCount((byte)value) - 24); 291public static sbyte PopCount(sbyte value) => (sbyte)BitOperations.PopCount((byte)value); 300public static sbyte TrailingZeroCount(sbyte value) => (sbyte)(BitOperations.TrailingZeroCount(value << 24) - 24); 462public static bool IsPow2(sbyte value) => BitOperations.IsPow2(value); 471return (sbyte)BitOperations.Log2((byte)value);

src\libraries\System.Private.CoreLib\src\System\SearchValues\IndexOfAnyAsciiSearcher.cs (8)

1256int offsetInVector = 31 - BitOperations.LeadingZeroCount(mask); 1265int offsetInVector = 31 - BitOperations.LeadingZeroCount(mask); 1287int offsetInVector = 31 - BitOperations.LeadingZeroCount(mask); 1303int offsetInVector = 31 - BitOperations.LeadingZeroCount(mask); 1471int offsetInVector = BitOperations.TrailingZeroCount(mask); 1486int offsetInVector = BitOperations.TrailingZeroCount(mask); 1494int offsetInVector = BitOperations.TrailingZeroCount(mask); 1515int offsetInVector = BitOperations.TrailingZeroCount(mask);

src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticMap.cs (16)

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\AsciiStringSearchValuesTeddyBase.cs (12)

543int matchOffset = BitOperations.TrailingZeroCount(resultMask); 558int candidateOffset = BitOperations.TrailingZeroCount(candidateMask); 570candidateMask = BitOperations.ResetLowestSetBit(candidateMask); 574resultMask = BitOperations.ResetLowestSetBit(resultMask); 591int matchOffset = BitOperations.TrailingZeroCount(resultMask); 603int candidateOffset = BitOperations.TrailingZeroCount(candidateMask); 615candidateMask = BitOperations.ResetLowestSetBit(candidateMask); 619resultMask = BitOperations.ResetLowestSetBit(resultMask); 636int matchOffset = BitOperations.TrailingZeroCount(resultMask); 648int candidateOffset = BitOperations.TrailingZeroCount(candidateMask); 660candidateMask = BitOperations.ResetLowestSetBit(candidateMask); 664resultMask = BitOperations.ResetLowestSetBit(resultMask);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesPackedThreeChars.cs (4)

335int bitPos = BitOperations.TrailingZeroCount(mask); 347mask = BitOperations.ResetLowestSetBit(mask); 362int bitPos = BitOperations.TrailingZeroCount(mask); 374mask = BitOperations.ResetLowestSetBit(mask);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesThreeChars.cs (6)

332int bitPos = BitOperations.TrailingZeroCount(mask); 345mask = BitOperations.ResetLowestSetBit(BitOperations.ResetLowestSetBit(mask)); 360int bitPos = BitOperations.TrailingZeroCount(mask); 373mask = BitOperations.ResetLowestSetBit(BitOperations.ResetLowestSetBit(mask));

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Byte.cs (26)

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Char.cs (18)

117int bitPos = BitOperations.TrailingZeroCount(mask); 194mask = BitOperations.ResetLowestSetBit(BitOperations.ResetLowestSetBit(mask)); 256mask = BitOperations.ResetLowestSetBit(BitOperations.ResetLowestSetBit(mask)); 341int bitPos = 62 - BitOperations.LeadingZeroCount(mask); 391int bitPos = 30 - BitOperations.LeadingZeroCount(mask); 441int bitPos = 30 - BitOperations.LeadingZeroCount(mask); 610return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 637return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 668return (int)(offset + (uint)BitOperations.TrailingZeroCount(matches)); 691return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 714return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 754return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 779return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 802return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 841return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 866=> BitOperations.TrailingZeroCount(match) >> 4;

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Packed.cs (6)

1233int index = BitOperations.TrailingZeroCount(notEqualsElements); 1242int index = BitOperations.TrailingZeroCount(notEqualsElements); 1251int index = BitOperations.TrailingZeroCount(notEqualsElements); 1259int offsetInVector = BitOperations.TrailingZeroCount(notEqualsElements); 1274int offsetInVector = BitOperations.TrailingZeroCount(notEqualsElements); 1289int offsetInVector = BitOperations.TrailingZeroCount(notEqualsElements);

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.T.cs (13)

26if (!BitOperations.IsPow2(sizeof(T))) { goto CannotVectorize; } 3337int index = BitOperations.TrailingZeroCount(notEqualsElements); 3345int index = BitOperations.TrailingZeroCount(notEqualsElements); 3353int index = BitOperations.TrailingZeroCount(notEqualsElements); 3361int index = 31 - BitOperations.LeadingZeroCount(notEqualsElements); // 31 = 32 (bits in Int32) - 1 (indexing from zero) 3369int index = 31 - BitOperations.LeadingZeroCount(notEqualsElements); // 31 = 32 (bits in Int32) - 1 (indexing from zero) 3377int index = 63 - BitOperations.LeadingZeroCount(notEqualsElements); // 31 = 32 (bits in Int32) - 1 (indexing from zero) 3799count += BitOperations.PopCount(Vector512.Equals(Vector512.LoadUnsafe(ref current), targetVector).ExtractMostSignificantBits()); 3806count += BitOperations.PopCount(mask); 3814count += BitOperations.PopCount(Vector256.Equals(Vector256.LoadUnsafe(ref current), targetVector).ExtractMostSignificantBits()); 3821count += BitOperations.PopCount(mask); 3829count += BitOperations.PopCount(Vector128.Equals(Vector128.LoadUnsafe(ref current), targetVector).ExtractMostSignificantBits()); 3836count += BitOperations.PopCount(mask);

src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (21)

src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (6)

2120uint bitPos = (uint)BitOperations.TrailingZeroCount(mask) / sizeof(char); 2122mask = BitOperations.ResetLowestSetBit(mask); 2149uint bitPos = (uint)BitOperations.TrailingZeroCount(mask) / sizeof(char); 2151mask = BitOperations.ResetLowestSetBit(mask); 2178uint bitPos = (uint)BitOperations.TrailingZeroCount(mask) / sizeof(char); 2180mask = BitOperations.ResetLowestSetBit(mask);

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Utility.cs (7)

82int index = BitOperations.TrailingZeroCount(mask) >> 2; 601pBuffer += (uint)BitOperations.TrailingZeroCount(currentSseMask); 646pBuffer += (nuint)(BitOperations.TrailingZeroCount(candidateUInt64) >> 3); 1143pBuffer = (char*)((byte*)pBuffer + (uint)BitOperations.TrailingZeroCount(currentMask) - 1); 1156pBuffer += BitOperations.TrailingZeroCount(asciiCompareMask) >> 3; 1204pBuffer = (char*)((byte*)pBuffer + ((nuint)(BitOperations.TrailingZeroCount(candidateUInt64) >> 3) & ~(nuint)1)); 2182asciiData = BitOperations.RotateLeft(asciiData, 8);

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Utility.Helpers.cs (4)

53return (uint)BitOperations.TrailingZeroCount(value & UInt32HighBitsOnlyMask) >> 3; 69value = BitOperations.RotateLeft(value, 1); 74value = BitOperations.RotateLeft(value, 8); 79value = BitOperations.RotateLeft(value, 8);

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Utility.cs (1)

426pBuffer = (char*)((byte*)pBuffer + (uint)BitOperations.TrailingZeroCount(currentMask) - 1);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf16Utility.Validation.cs (2)

199popcnt = (uint)BitOperations.PopCount(mask); // on x64, perform zero-extension for free 232nint surrogatePairsCountNint = (nint)BitOperations.PopCount(maskLow);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Helpers.cs (1)

118tempA = BitOperations.RotateLeft(tempA, 16); // = [ 00xxxxxx 00000000 00000000 00000uuu ]

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Transcoding.cs (1)

603toCheck = BitOperations.RotateRight(toCheck, 8);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Validation.cs (3)

138trailingZeroCount = (nuint)BitOperations.TrailingZeroCount(mask) >> 2; 156trailingZeroCount = (nuint)BitOperations.TrailingZeroCount(mask); 608thisDWord = BitOperations.RotateRight(thisDWord, 8);

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadLocal.cs (1)

556uint newSize = BitOperations.RoundUpToPowerOf2((uint)minSize);

src\libraries\System.Private.CoreLib\src\System\UInt128.cs (3)

795return 64 + BitOperations.LeadingZeroCount(value._lower); 797return BitOperations.LeadingZeroCount(value._upper); 1181int shift = BitOperations.LeadingZeroCount(divHi);

src\libraries\System.Private.CoreLib\src\System\UInt16.cs (5)

279public static ushort LeadingZeroCount(ushort value) => (ushort)(BitOperations.LeadingZeroCount(value) - 16); 282public static ushort PopCount(ushort value) => (ushort)BitOperations.PopCount(value); 291public static ushort TrailingZeroCount(ushort value) => (ushort)(BitOperations.TrailingZeroCount(value << 16) - 16); 431public static bool IsPow2(ushort value) => BitOperations.IsPow2((uint)value); 434public static ushort Log2(ushort value) => (ushort)BitOperations.Log2(value);

src\libraries\System.Private.CoreLib\src\System\UInt32.cs (8)

296public static uint LeadingZeroCount(uint value) => (uint)BitOperations.LeadingZeroCount(value); 300public static uint PopCount(uint value) => (uint)BitOperations.PopCount(value); 304public static uint RotateLeft(uint value, int rotateAmount) => BitOperations.RotateLeft(value, rotateAmount); 308public static uint RotateRight(uint value, int rotateAmount) => BitOperations.RotateRight(value, rotateAmount); 312public static uint TrailingZeroCount(uint value) => (uint)BitOperations.TrailingZeroCount(value); 430int IBinaryInteger<uint>.GetShortestBitLength() => (sizeof(uint) * 8) - BitOperations.LeadingZeroCount(m_value); 469public static bool IsPow2(uint value) => BitOperations.IsPow2(value); 473public static uint Log2(uint value) => (uint)BitOperations.Log2(value);

src\libraries\System.Private.CoreLib\src\System\UInt64.cs (8)

295public static ulong LeadingZeroCount(ulong value) => (ulong)BitOperations.LeadingZeroCount(value); 299public static ulong PopCount(ulong value) => (ulong)BitOperations.PopCount(value); 303public static ulong RotateLeft(ulong value, int rotateAmount) => BitOperations.RotateLeft(value, rotateAmount); 307public static ulong RotateRight(ulong value, int rotateAmount) => BitOperations.RotateRight(value, rotateAmount); 311public static ulong TrailingZeroCount(ulong value) => (ulong)BitOperations.TrailingZeroCount(value); 429int IBinaryInteger<ulong>.GetShortestBitLength() => (sizeof(ulong) * 8) - BitOperations.LeadingZeroCount(m_value); 468public static bool IsPow2(ulong value) => BitOperations.IsPow2(value); 472public static ulong Log2(ulong value) => (ulong)BitOperations.Log2(value);

src\libraries\System.Private.CoreLib\src\System\UIntPtr.cs (8)

317public static nuint LeadingZeroCount(nuint value) => (nuint)BitOperations.LeadingZeroCount(value); 321public static nuint PopCount(nuint value) => (nuint)BitOperations.PopCount(value); 325public static nuint RotateLeft(nuint value, int rotateAmount) => BitOperations.RotateLeft(value, rotateAmount); 329public static nuint RotateRight(nuint value, int rotateAmount) => BitOperations.RotateRight(value, rotateAmount); 333public static nuint TrailingZeroCount(nuint value) => (nuint)BitOperations.TrailingZeroCount(value); 451int IBinaryInteger<nuint>.GetShortestBitLength() => (sizeof(nuint_t) * 8) - BitOperations.LeadingZeroCount(_value); 494public static bool IsPow2(nuint value) => BitOperations.IsPow2(value); 498public static nuint Log2(nuint value) => (nuint)BitOperations.Log2(value);

src\System\Runtime\CompilerServices\AsyncHelpers.CoreCLR.cs (3)

125uint contIndex = (uint)BitOperations.PopCount((uint)Flags & ((uint)ContinuationFlags.HasContinuationContext - 1)); 133uint contIndex = (uint)BitOperations.PopCount((uint)Flags & ((uint)ContinuationFlags.HasException - 1)); 143uint contIndex = (uint)BitOperations.PopCount((uint)Flags & ((uint)ContinuationFlags.HasResult - 1));

src\System\Runtime\CompilerServices\RuntimeHelpers.CoreCLR.cs (1)

506if (!BitOperations.IsPow2(alignment))

src\System\Runtime\CompilerServices\VirtualDispatchHelpers.cs (2)

25_hashCode = (int) ((uint)objectMethodTable + (BitOperations.RotateLeft((uint)classHandle, 5)) + (BitOperations.RotateRight((uint)methodHandle, 5)));