BitOperations

src\runtime\src\coreclr\nativeaot\Runtime.Base\src\System\Runtime\CachedInterfaceDispatch.cs (1)

54IntPtr context = (IntPtr)System.Numerics.BitOperations.RotateLeft((nuint)_dispatchCell, 16);

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

src\runtime\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\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\FormattingHelpers.CountDigits.cs (1)

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

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

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

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

276public static byte LeadingZeroCount(byte value) => (byte)(BitOperations.LeadingZeroCount(value) - 24); 282public static byte PopCount(byte value) => (byte)BitOperations.PopCount(value); 291public static byte TrailingZeroCount(byte value) => (byte)(BitOperations.TrailingZeroCount(value << 24) - 24); 407public static bool IsPow2(byte value) => BitOperations.IsPow2((uint)value); 410public static byte Log2(byte value) => (byte)BitOperations.Log2(value);

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

1230static char IBinaryInteger<char>.LeadingZeroCount(char value) => (char)(BitOperations.LeadingZeroCount(value) - 16); 1236static char IBinaryInteger<char>.PopCount(char value) => (char)BitOperations.PopCount(value); 1245static char IBinaryInteger<char>.TrailingZeroCount(char value) => (char)(BitOperations.TrailingZeroCount(value << 16) - 16);

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

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

src\runtime\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\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Decimal.DecCalc.cs (5)

613newScale -= BitOperations.LeadingZeroCount(result[hiRes]); 1647int trailingZeros = BitOperations.TrailingZeroCount(significand); 1660int significandBits = 64 - BitOperations.LeadingZeroCount(significand); 2010curScale = BitOperations.LeadingZeroCount(tmp); 2298int shift = BitOperations.LeadingZeroCount(tmp);

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

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

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

516mask = BitOperations.ResetLowestSetBit(BitOperations.ResetLowestSetBit(mask)); 582mask = BitOperations.ResetLowestSetBit(BitOperations.ResetLowestSetBit(mask));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Half.cs (1)

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

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

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

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

718return 64 + BitOperations.LeadingZeroCount(value._lower); 720return BitOperations.LeadingZeroCount(value._upper);

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

279public static short LeadingZeroCount(short value) => (short)(BitOperations.LeadingZeroCount((ushort)value) - 16); 292public static short PopCount(short value) => (short)BitOperations.PopCount((ushort)value); 301public static short TrailingZeroCount(short value) => (byte)(BitOperations.TrailingZeroCount(value << 16) - 16); 487public static bool IsPow2(short value) => BitOperations.IsPow2(value); 496return (short)BitOperations.Log2((ushort)value);

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

295public static int LeadingZeroCount(int value) => BitOperations.LeadingZeroCount((uint)value); 310public static int PopCount(int value) => BitOperations.PopCount((uint)value); 314public static int RotateLeft(int value, int rotateAmount) => (int)BitOperations.RotateLeft((uint)value, rotateAmount); 318public static int RotateRight(int value, int rotateAmount) => (int)BitOperations.RotateRight((uint)value, rotateAmount); 322public static int TrailingZeroCount(int value) => BitOperations.TrailingZeroCount(value); 527public static bool IsPow2(int value) => BitOperations.IsPow2(value); 538return BitOperations.Log2((uint)value);

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

292public static long LeadingZeroCount(long value) => BitOperations.LeadingZeroCount((ulong)value); 307public static long PopCount(long value) => BitOperations.PopCount((ulong)value); 311public static long RotateLeft(long value, int rotateAmount) => (long)BitOperations.RotateLeft((ulong)value, rotateAmount); 315public static long RotateRight(long value, int rotateAmount) => (long)BitOperations.RotateRight((ulong)value, rotateAmount); 319public static long TrailingZeroCount(long value) => BitOperations.TrailingZeroCount(value); 479return (sizeof(long) * 8) - BitOperations.LeadingZeroCount((ulong)(value)); 483return (sizeof(long) * 8) + 1 - BitOperations.LeadingZeroCount((ulong)(~value)); 524public static bool IsPow2(long value) => BitOperations.IsPow2(value); 535return BitOperations.Log2((ulong)value);

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

325public static nint LeadingZeroCount(nint value) => BitOperations.LeadingZeroCount((nuint)value); 340public static nint PopCount(nint value) => BitOperations.PopCount((nuint)value); 344public static nint RotateLeft(nint value, int rotateAmount) => (nint)BitOperations.RotateLeft((nuint)value, rotateAmount); 348public static nint RotateRight(nint value, int rotateAmount) => (nint)BitOperations.RotateRight((nuint)value, rotateAmount); 352public static nint TrailingZeroCount(nint value) => BitOperations.TrailingZeroCount(value); 512return (sizeof(nint_t) * 8) - BitOperations.LeadingZeroCount((nuint)value); 516return (sizeof(nint_t) * 8) + 1 - BitOperations.LeadingZeroCount((nuint)(~value)); 557public static bool IsPow2(nint value) => BitOperations.IsPow2(value); 568return BitOperations.Log2((nuint)value);

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

10using static System.Numerics.BitOperations;

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

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

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

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

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

536return 64 - BitOperations.LeadingZeroCount(value); 550return (lastIndex * BitsPerBlock) + (BitsPerBlock - BitOperations.LeadingZeroCount(value._blocks[lastIndex]));

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

93int lzcnt = BitOperations.LeadingZeroCount(f);

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

41mantissaHighBitIdx = (uint)BitOperations.Log2(mantissa); 293int hiBlockLog2 = BitOperations.Log2(hiBlock);

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

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

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

1284int lz = BitOperations.LeadingZeroCount(w);

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

1480int lz = BitOperations.LeadingZeroCount(significand);

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

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

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

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

src\runtime\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\runtime\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; 245byte shift = (byte)BitOperations.LeadingZeroCount((nuint)(size - 1));

src\runtime\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\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\ComWrappers.cs (1)

1341uint bucketCount = BitOperations.RoundUpToPowerOf2((uint)Math.Min(Environment.ProcessorCount, MaxBucketCount));

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

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

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

4341return AdvSimdFixupBitCount<T>(BitOperations.PopCount(AdvSimdExtractBitMask(vector))); 4345return BitOperations.PopCount(vector.ExtractMostSignificantBits()); 4362int result = AdvSimdFixupBitCount<T>(BitOperations.TrailingZeroCount(AdvSimdExtractBitMask(vector))); 4367int result = BitOperations.TrailingZeroCount(vector.ExtractMostSignificantBits()); 4377return (Vector128<T>.Count - 1) - AdvSimdFixupBitCount<T>(BitOperations.LeadingZeroCount(AdvSimdExtractBitMask(vector))); 4381return 31 - BitOperations.LeadingZeroCount(vector.ExtractMostSignificantBits());

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

4246return BitOperations.PopCount(vector.ExtractMostSignificantBits()); 4268int result = BitOperations.TrailingZeroCount(vector.ExtractMostSignificantBits()); 4290return 31 - BitOperations.LeadingZeroCount(vector.ExtractMostSignificantBits());

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

4225return BitOperations.PopCount(vector.ExtractMostSignificantBits()); 4247int result = BitOperations.TrailingZeroCount(vector.ExtractMostSignificantBits()); 4269return 63 - BitOperations.LeadingZeroCount(vector.ExtractMostSignificantBits());

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

4464return AdvSimdFixupBitCount<T>(BitOperations.PopCount(AdvSimdExtractBitMask(vector))); 4468return BitOperations.PopCount(vector.ExtractMostSignificantBits()); 4485int result = AdvSimdFixupBitCount<T>(BitOperations.TrailingZeroCount(AdvSimdExtractBitMask(vector))); 4490int result = BitOperations.TrailingZeroCount(vector.ExtractMostSignificantBits()); 4500return (Vector64<T>.Count - 1) - AdvSimdFixupBitCount<T>(BitOperations.LeadingZeroCount(AdvSimdExtractBitMask(vector))); 4504return 31 - BitOperations.LeadingZeroCount(vector.ExtractMostSignificantBits());

src\runtime\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> 98/// <para>Its functionality is exposed in the public <see cref="Numerics.BitOperations" /> class.</para> 109/// <para>Its functionality is exposed in the public <see cref="Numerics.BitOperations" /> class.</para>

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

282public static sbyte LeadingZeroCount(sbyte value) => (sbyte)(BitOperations.LeadingZeroCount((byte)value) - 24); 295public static sbyte PopCount(sbyte value) => (sbyte)BitOperations.PopCount((byte)value); 304public static sbyte TrailingZeroCount(sbyte value) => (sbyte)(BitOperations.TrailingZeroCount(value << 24) - 24); 466public static bool IsPow2(sbyte value) => BitOperations.IsPow2(value); 475return (sbyte)BitOperations.Log2((byte)value);

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

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

548int matchOffset = BitOperations.TrailingZeroCount(resultMask); 563int candidateOffset = BitOperations.TrailingZeroCount(candidateMask); 575candidateMask = BitOperations.ResetLowestSetBit(candidateMask); 579resultMask = BitOperations.ResetLowestSetBit(resultMask); 596int matchOffset = BitOperations.TrailingZeroCount(resultMask); 608int candidateOffset = BitOperations.TrailingZeroCount(candidateMask); 620candidateMask = BitOperations.ResetLowestSetBit(candidateMask); 624resultMask = BitOperations.ResetLowestSetBit(resultMask); 641int matchOffset = BitOperations.TrailingZeroCount(resultMask); 653int candidateOffset = BitOperations.TrailingZeroCount(candidateMask); 665candidateMask = BitOperations.ResetLowestSetBit(candidateMask); 669resultMask = BitOperations.ResetLowestSetBit(resultMask);

src\runtime\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\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Byte.cs (26)

src\runtime\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); 611return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 638return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 669return (int)(offset + (uint)BitOperations.TrailingZeroCount(matches)); 692return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 715return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 755return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 780return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 803return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 842return (int)(offset + ((uint)BitOperations.TrailingZeroCount(matches) / sizeof(char))); 867=> BitOperations.TrailingZeroCount(match) >> 4;

src\runtime\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\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (21)

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

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

83int index = BitOperations.TrailingZeroCount(mask) >> 2; 602pBuffer += (uint)BitOperations.TrailingZeroCount(currentSseMask); 647pBuffer += (nuint)(BitOperations.TrailingZeroCount(candidateUInt64) >> 3); 1144pBuffer = (char*)((byte*)pBuffer + (uint)BitOperations.TrailingZeroCount(currentMask) - 1); 1157pBuffer += BitOperations.TrailingZeroCount(asciiCompareMask) >> 3; 1205pBuffer = (char*)((byte*)pBuffer + ((nuint)(BitOperations.TrailingZeroCount(candidateUInt64) >> 3) & ~(nuint)1)); 2184asciiData = BitOperations.RotateLeft(asciiData, 8);

src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Latin1Utility.cs (1)

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

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

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

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

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

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

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

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

140trailingZeroCount = (nuint)BitOperations.TrailingZeroCount(mask) >> 2; 158trailingZeroCount = (nuint)BitOperations.TrailingZeroCount(mask); 167trailingZeroCount = (nuint)BitOperations.TrailingZeroCount(mask); 619thisDWord = BitOperations.RotateRight(thisDWord, 8);

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

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\UInt128.cs (5)

807int shift = BitOperations.LeadingZeroCount(divHi); 900int shift = BitOperations.LeadingZeroCount(divisor); 918Debug.Assert(BitOperations.LeadingZeroCount(divisor) == 0); 1014return 64 + BitOperations.LeadingZeroCount(value._lower); 1016return BitOperations.LeadingZeroCount(value._upper);

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

273public static ushort LeadingZeroCount(ushort value) => (ushort)(BitOperations.LeadingZeroCount(value) - 16); 279public static ushort PopCount(ushort value) => (ushort)BitOperations.PopCount(value); 288public static ushort TrailingZeroCount(ushort value) => (ushort)(BitOperations.TrailingZeroCount(value << 16) - 16); 412public static bool IsPow2(ushort value) => BitOperations.IsPow2((uint)value); 415public static ushort Log2(ushort value) => (ushort)BitOperations.Log2(value);

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

290public static uint LeadingZeroCount(uint value) => (uint)BitOperations.LeadingZeroCount(value); 301uint log2 = (uint)BitOperations.Log2(value) + 1; 323public static uint PopCount(uint value) => (uint)BitOperations.PopCount(value); 327public static uint RotateLeft(uint value, int rotateAmount) => BitOperations.RotateLeft(value, rotateAmount); 331public static uint RotateRight(uint value, int rotateAmount) => BitOperations.RotateRight(value, rotateAmount); 335public static uint TrailingZeroCount(uint value) => (uint)BitOperations.TrailingZeroCount(value); 437int IBinaryInteger<uint>.GetShortestBitLength() => (sizeof(uint) * 8) - BitOperations.LeadingZeroCount(m_value); 476public static bool IsPow2(uint value) => BitOperations.IsPow2(value); 480public static uint Log2(uint value) => (uint)BitOperations.Log2(value);

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

289public static ulong LeadingZeroCount(ulong value) => (ulong)BitOperations.LeadingZeroCount(value); 298uint log2 = (uint)BitOperations.Log2(value) + 1; 330public static ulong PopCount(ulong value) => (ulong)BitOperations.PopCount(value); 334public static ulong RotateLeft(ulong value, int rotateAmount) => BitOperations.RotateLeft(value, rotateAmount); 338public static ulong RotateRight(ulong value, int rotateAmount) => BitOperations.RotateRight(value, rotateAmount); 342public static ulong TrailingZeroCount(ulong value) => (ulong)BitOperations.TrailingZeroCount(value); 444int IBinaryInteger<ulong>.GetShortestBitLength() => (sizeof(ulong) * 8) - BitOperations.LeadingZeroCount(m_value); 483public static bool IsPow2(ulong value) => BitOperations.IsPow2(value); 487public static ulong Log2(ulong value) => (ulong)BitOperations.Log2(value);

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

321public static nuint LeadingZeroCount(nuint value) => (nuint)BitOperations.LeadingZeroCount(value); 335public static nuint PopCount(nuint value) => (nuint)BitOperations.PopCount(value); 339public static nuint RotateLeft(nuint value, int rotateAmount) => BitOperations.RotateLeft(value, rotateAmount); 343public static nuint RotateRight(nuint value, int rotateAmount) => BitOperations.RotateRight(value, rotateAmount); 347public static nuint TrailingZeroCount(nuint value) => (nuint)BitOperations.TrailingZeroCount(value); 449int IBinaryInteger<nuint>.GetShortestBitLength() => (sizeof(nuint_t) * 8) - BitOperations.LeadingZeroCount(_value); 492public static bool IsPow2(nuint value) => BitOperations.IsPow2(value); 496public static nuint Log2(nuint value) => (nuint)BitOperations.Log2(value);

System\Runtime\CompilerServices\RuntimeHelpers.NativeAot.cs (1)

271if (!BitOperations.IsPow2(alignment))

System\Runtime\ThunkPool.cs (1)

49public static readonly uint PageSize = BitOperations.RoundUpToPowerOf2((uint)Math.Max(ThunkCodeSize * NumThunksPerBlock, ThunkDataSize * NumThunksPerBlock + IntPtr.Size));

System\Runtime\TypeLoaderExports.cs (1)

57IntPtr context = (IntPtr)BitOperations.RotateLeft((nuint)_context, 16);