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)

2704IntroSort(left, length + left - 1, 2 * (BitOperations.Log2((uint)length) + 1)); 2917IntroSort(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); 288public static byte PopCount(byte value) => (byte)BitOperations.PopCount(value); 297public static byte TrailingZeroCount(byte value) => (byte)(BitOperations.TrailingZeroCount(value << 24) - 24); 415public static bool IsPow2(byte value) => BitOperations.IsPow2((uint)value); 418public 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); 1221static char IBinaryInteger<char>.PopCount(char value) => (char)BitOperations.PopCount(value); 1230static 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)

626newScale -= BitOperations.LeadingZeroCount(result[hiRes]); 2038curScale = BitOperations.LeadingZeroCount(tmp); 2311int shift = BitOperations.LeadingZeroCount(tmp);

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

456if (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 (1)

1105int shiftDist = BitOperations.LeadingZeroCount(sig) - 16 - 5;

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); 298public static short PopCount(short value) => (short)BitOperations.PopCount((ushort)value); 307public static short TrailingZeroCount(short value) => (byte)(BitOperations.TrailingZeroCount(value << 16) - 16); 509public static bool IsPow2(short value) => BitOperations.IsPow2(value); 518return (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); 316public static int PopCount(int value) => BitOperations.PopCount((uint)value); 320public static int RotateLeft(int value, int rotateAmount) => (int)BitOperations.RotateLeft((uint)value, rotateAmount); 324public static int RotateRight(int value, int rotateAmount) => (int)BitOperations.RotateRight((uint)value, rotateAmount); 328public static int TrailingZeroCount(int value) => BitOperations.TrailingZeroCount(value); 549public static bool IsPow2(int value) => BitOperations.IsPow2(value); 560return BitOperations.Log2((uint)value);

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

298public static long LeadingZeroCount(long value) => BitOperations.LeadingZeroCount((ulong)value); 313public static long PopCount(long value) => BitOperations.PopCount((ulong)value); 317public static long RotateLeft(long value, int rotateAmount) => (long)BitOperations.RotateLeft((ulong)value, rotateAmount); 321public static long RotateRight(long value, int rotateAmount) => (long)BitOperations.RotateRight((ulong)value, rotateAmount); 325public static long TrailingZeroCount(long value) => BitOperations.TrailingZeroCount(value); 501return (sizeof(long) * 8) - BitOperations.LeadingZeroCount((ulong)(value)); 505return (sizeof(long) * 8) + 1 - BitOperations.LeadingZeroCount((ulong)(~value)); 546public static bool IsPow2(long value) => BitOperations.IsPow2(value); 557return BitOperations.Log2((ulong)value);

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

321public static nint LeadingZeroCount(nint value) => BitOperations.LeadingZeroCount((nuint)value); 336public static nint PopCount(nint value) => BitOperations.PopCount((nuint)value); 340public static nint RotateLeft(nint value, int rotateAmount) => (nint)BitOperations.RotateLeft((nuint)value, rotateAmount); 344public static nint RotateRight(nint value, int rotateAmount) => (nint)BitOperations.RotateRight((nuint)value, rotateAmount); 348public static nint TrailingZeroCount(nint value) => BitOperations.TrailingZeroCount(value); 524return (sizeof(nint_t) * 8) - BitOperations.LeadingZeroCount((nuint)value); 528return (sizeof(nint_t) * 8) + 1 - BitOperations.LeadingZeroCount((nuint)(~value)); 569public static bool IsPow2(nint value) => BitOperations.IsPow2(value); 580return 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.Formatting.cs (2)

596int lz = BitOperations.LeadingZeroCount(fraction) - (63 - mantissaBits); 707int trailingZeroBits = BitOperations.TrailingZeroCount(nibbleAligned);

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

1298int lz = BitOperations.LeadingZeroCount(w);

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

1246int lz = BitOperations.LeadingZeroCount(significand);

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)

570Debug.Assert(BitOperations.IsPow2(InitialCapacity)); 593Debug.Assert(BitOperations.IsPow2(buckets.Length)); 798Debug.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)

27if (!BitOperations.IsPow2(alignment)) 90if (!BitOperations.IsPow2(alignment))

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

4556return AdvSimdFixupBitCount<T>(BitOperations.PopCount(AdvSimdExtractBitMask(vector))); 4560return BitOperations.PopCount(vector.ExtractMostSignificantBits()); 4577int result = AdvSimdFixupBitCount<T>(BitOperations.TrailingZeroCount(AdvSimdExtractBitMask(vector))); 4582int result = BitOperations.TrailingZeroCount(vector.ExtractMostSignificantBits()); 4592return (Vector128<T>.Count - 1) - AdvSimdFixupBitCount<T>(BitOperations.LeadingZeroCount(AdvSimdExtractBitMask(vector))); 4596return 31 - BitOperations.LeadingZeroCount(vector.ExtractMostSignificantBits());

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

4456return BitOperations.PopCount(vector.ExtractMostSignificantBits()); 4478int result = BitOperations.TrailingZeroCount(vector.ExtractMostSignificantBits()); 4500return 31 - BitOperations.LeadingZeroCount(vector.ExtractMostSignificantBits());

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

4426return BitOperations.PopCount(vector.ExtractMostSignificantBits()); 4448int result = BitOperations.TrailingZeroCount(vector.ExtractMostSignificantBits()); 4470return 63 - BitOperations.LeadingZeroCount(vector.ExtractMostSignificantBits());

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

4452return AdvSimdFixupBitCount<T>(BitOperations.PopCount(AdvSimdExtractBitMask(vector))); 4456return BitOperations.PopCount(vector.ExtractMostSignificantBits()); 4473int result = AdvSimdFixupBitCount<T>(BitOperations.TrailingZeroCount(AdvSimdExtractBitMask(vector))); 4478int result = BitOperations.TrailingZeroCount(vector.ExtractMostSignificantBits()); 4488return (Vector64<T>.Count - 1) - AdvSimdFixupBitCount<T>(BitOperations.LeadingZeroCount(AdvSimdExtractBitMask(vector))); 4492return 31 - BitOperations.LeadingZeroCount(vector.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); 301public static sbyte PopCount(sbyte value) => (sbyte)BitOperations.PopCount((byte)value); 310public static sbyte TrailingZeroCount(sbyte value) => (sbyte)(BitOperations.TrailingZeroCount(value << 24) - 24); 472public static bool IsPow2(sbyte value) => BitOperations.IsPow2(value); 481return (sbyte)BitOperations.Log2((byte)value);

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)

118int bitPos = BitOperations.TrailingZeroCount(mask); 195mask = BitOperations.ResetLowestSetBit(BitOperations.ResetLowestSetBit(mask)); 257mask = BitOperations.ResetLowestSetBit(BitOperations.ResetLowestSetBit(mask)); 342int bitPos = 62 - BitOperations.LeadingZeroCount(mask); 392int bitPos = 30 - BitOperations.LeadingZeroCount(mask); 442int bitPos = 30 - BitOperations.LeadingZeroCount(mask); 612return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 639return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 670return (int)(offset + (uint)BitOperations.TrailingZeroCount(matches)); 693return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 716return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 756return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 781return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 804return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 843return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 868=> 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)

38if (!BitOperations.IsPow2(sizeof(T))) 3717int index = BitOperations.TrailingZeroCount(notEqualsElements); 3725int index = BitOperations.TrailingZeroCount(notEqualsElements); 3733int index = BitOperations.TrailingZeroCount(notEqualsElements); 3741int index = 31 - BitOperations.LeadingZeroCount(notEqualsElements); // 31 = 32 (bits in Int32) - 1 (indexing from zero) 3749int index = 31 - BitOperations.LeadingZeroCount(notEqualsElements); // 31 = 32 (bits in Int32) - 1 (indexing from zero) 3757int index = 63 - BitOperations.LeadingZeroCount(notEqualsElements); // 31 = 32 (bits in Int32) - 1 (indexing from zero) 4179count += BitOperations.PopCount(Vector512.Equals(Vector512.LoadUnsafe(ref current), targetVector).ExtractMostSignificantBits()); 4186count += BitOperations.PopCount(mask); 4194count += BitOperations.PopCount(Vector256.Equals(Vector256.LoadUnsafe(ref current), targetVector).ExtractMostSignificantBits()); 4201count += BitOperations.PopCount(mask); 4209count += BitOperations.PopCount(Vector128.Equals(Vector128.LoadUnsafe(ref current), targetVector).ExtractMostSignificantBits()); 4216count += 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)

83int index = BitOperations.TrailingZeroCount(mask) >> 2; 605pBuffer += (uint)BitOperations.TrailingZeroCount(currentSseMask); 650pBuffer += (nuint)(BitOperations.TrailingZeroCount(candidateUInt64) >> 3); 1150pBuffer = (char*)((byte*)pBuffer + (uint)BitOperations.TrailingZeroCount(currentMask) - 1); 1163pBuffer += BitOperations.TrailingZeroCount(asciiCompareMask) >> 3; 1211pBuffer = (char*)((byte*)pBuffer + ((nuint)(BitOperations.TrailingZeroCount(candidateUInt64) >> 3) & ~(nuint)1)); 2195asciiData = 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)

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

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

201popcnt = (uint)BitOperations.PopCount(mask); // on x64, perform zero-extension for free 234nint 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)

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

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

140trailingZeroCount = (nuint)BitOperations.TrailingZeroCount(mask) >> 2; 158trailingZeroCount = (nuint)BitOperations.TrailingZeroCount(mask); 610thisDWord = 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); 1241int 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); 285public static ushort PopCount(ushort value) => (ushort)BitOperations.PopCount(value); 294public static ushort TrailingZeroCount(ushort value) => (ushort)(BitOperations.TrailingZeroCount(value << 16) - 16); 434public static bool IsPow2(ushort value) => BitOperations.IsPow2((uint)value); 437public static ushort Log2(ushort value) => (ushort)BitOperations.Log2(value);

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

296public static uint LeadingZeroCount(uint value) => (uint)BitOperations.LeadingZeroCount(value); 307uint log2 = (uint)BitOperations.Log2(value) + 1; 329public static uint PopCount(uint value) => (uint)BitOperations.PopCount(value); 333public static uint RotateLeft(uint value, int rotateAmount) => BitOperations.RotateLeft(value, rotateAmount); 337public static uint RotateRight(uint value, int rotateAmount) => BitOperations.RotateRight(value, rotateAmount); 341public static uint TrailingZeroCount(uint value) => (uint)BitOperations.TrailingZeroCount(value); 459int IBinaryInteger<uint>.GetShortestBitLength() => (sizeof(uint) * 8) - BitOperations.LeadingZeroCount(m_value); 498public static bool IsPow2(uint value) => BitOperations.IsPow2(value); 502public static uint Log2(uint value) => (uint)BitOperations.Log2(value);

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

295public static ulong LeadingZeroCount(ulong value) => (ulong)BitOperations.LeadingZeroCount(value); 304uint log2 = (uint)BitOperations.Log2(value) + 1; 336public static ulong PopCount(ulong value) => (ulong)BitOperations.PopCount(value); 340public static ulong RotateLeft(ulong value, int rotateAmount) => BitOperations.RotateLeft(value, rotateAmount); 344public static ulong RotateRight(ulong value, int rotateAmount) => BitOperations.RotateRight(value, rotateAmount); 348public static ulong TrailingZeroCount(ulong value) => (ulong)BitOperations.TrailingZeroCount(value); 466int IBinaryInteger<ulong>.GetShortestBitLength() => (sizeof(ulong) * 8) - BitOperations.LeadingZeroCount(m_value); 505public static bool IsPow2(ulong value) => BitOperations.IsPow2(value); 509public 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); 331public static nuint PopCount(nuint value) => (nuint)BitOperations.PopCount(value); 335public static nuint RotateLeft(nuint value, int rotateAmount) => BitOperations.RotateLeft(value, rotateAmount); 339public static nuint RotateRight(nuint value, int rotateAmount) => BitOperations.RotateRight(value, rotateAmount); 343public static nuint TrailingZeroCount(nuint value) => (nuint)BitOperations.TrailingZeroCount(value); 461int IBinaryInteger<nuint>.GetShortestBitLength() => (sizeof(nuint_t) * 8) - BitOperations.LeadingZeroCount(_value); 504public static bool IsPow2(nuint value) => BitOperations.IsPow2(value); 508public static nuint Log2(nuint value) => (nuint)BitOperations.Log2(value);

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

511if (!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)));