BinaryPrimitives

HttpUtilities\HttpUtilities.cs (1)

312return BinaryPrimitives.ReadUInt64LittleEndian(bytes);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

src\Shared\Http2cat\Http2Utilities.cs (4)

427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);

src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)

34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)

154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

src\Shared\Http2cat\Http2Utilities.cs (4)

427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);

src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)

34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)

154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

src\Shared\Http2cat\Http2Utilities.cs (4)

427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);

src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)

34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)

154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

src\Shared\Http2cat\Http2Utilities.cs (4)

427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);

src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)

34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)

154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

src\Shared\Http2cat\Http2Utilities.cs (4)

427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);

src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)

34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)

154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)

34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)

154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

src\Shared\Http2cat\Http2Utilities.cs (4)

427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);

src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)

34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)

154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

Http2\Http2TestBase.cs (1)

1147BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL);

src\Servers\Kestrel\shared\test\PipeWriterHttp2FrameExtensions.cs (1)

102BinaryPrimitives.WriteUInt32BigEndian(writer.GetSpan(4), (uint)sizeIncrement);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

src\submodules\MessagePack-CSharp\src\MessagePack.UnityClient\Assets\Scripts\MessagePack\SequenceReaderExtensions.cs (3)

164value = BinaryPrimitives.ReverseEndianness(value); 205value = BinaryPrimitives.ReverseEndianness(value); 246value = BinaryPrimitives.ReverseEndianness(value);

Circuits\RenderBatchWriterTest.cs (1)

356=> BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(startOffset, 4));

KeyManagement\KeyRingBasedDataProtector.cs (2)

388BinaryPrimitives.WriteUInt32BigEndian(targetSpan.Slice(0), MAGIC_HEADER_V0); 391BinaryPrimitives.WriteInt32BigEndian(targetSpan.Slice(4 + keySize), targetLength);

Passkeys\AttestedCredentialData.cs (1)

64var credentialIdLength = BinaryPrimitives.ReadUInt16BigEndian(data.Slice(offset, CredentialIdLengthLength).Span);

Passkeys\AuthenticatorData.cs (1)

113var signCount = BinaryPrimitives.ReadUInt32BigEndian(bytes.Slice(offset, SignCountLength).Span);

Passkeys\CredentialHelpers.cs (2)

22BinaryPrimitives.WriteUInt16BigEndian(result.AsSpan(offset, CredentialIdLengthLength), (ushort)args.CredentialId.Length); 59BinaryPrimitives.WriteUInt32BigEndian(result.AsSpan(offset, SignCountLength), args.SignCount);

src\Shared\Http2cat\Http2Utilities.cs (4)

427BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 428BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 765BinaryPrimitives.WriteUInt32BigEndian(payload, (uint)Http2ErrorCode.CANCEL); 807BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)sizeIncrement);

src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)

34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)

154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

Internal\Http\HttpHeaders.Generated.cs (3)

7489result = BinaryPrimitives.ReverseEndianness(result); 7499result = BinaryPrimitives.ReverseEndianness(result); 7509result = BinaryPrimitives.ReverseEndianness(result);

Internal\Http2\Http2FrameWriter.cs (4)

887BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)errorCode); 928BinaryPrimitives.WriteUInt16BigEndian(destination, (ushort)setting.Parameter); 929BinaryPrimitives.WriteUInt32BigEndian(destination.Slice(2), setting.Value); 1002BinaryPrimitives.WriteUInt32BigEndian(buffer, (uint)errorCode);

Internal\Infrastructure\HttpUtilities.cs (7)

61return BinaryPrimitives.ReadUInt64LittleEndian(bytes); 73return BinaryPrimitives.ReadUInt32LittleEndian(bytes); 80return BinaryPrimitives.ReadUInt64LittleEndian(bytes); 219if (BinaryPrimitives.ReadUInt32LittleEndian(span) == _httpGetMethodInt) 226var value = BinaryPrimitives.ReadUInt64LittleEndian(span); 411if (BinaryPrimitives.TryReadUInt64LittleEndian(span, out var version)) 434if (BinaryPrimitives.TryReadUInt64LittleEndian(span, out var scheme))

src\Shared\runtime\Http3\Helpers\VariableLengthIntegerHelper.cs (6)

53if (BinaryPrimitives.TryReadUInt16BigEndian(buffer, out ushort serializedShort)) 61if (BinaryPrimitives.TryReadUInt32BigEndian(buffer, out uint serializedInt)) 70if (BinaryPrimitives.TryReadUInt64BigEndian(buffer, out ulong serializedLong)) 163if (BinaryPrimitives.TryWriteUInt16BigEndian(buffer, (ushort)((uint)longToEncode | TwoByteLengthMask))) 171if (BinaryPrimitives.TryWriteUInt32BigEndian(buffer, (uint)longToEncode | FourByteLengthMask)) 179if (BinaryPrimitives.TryWriteUInt64BigEndian(buffer, (ulong)longToEncode | EightByteLengthMask))

src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)

34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)

154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

src\Servers\Kestrel\shared\test\PipeWriterHttp2FrameExtensions.cs (1)

102BinaryPrimitives.WriteUInt32BigEndian(writer.GetSpan(4), (uint)sizeIncrement);

BinaryPrimitivesBenchmark.cs (1)

39v = BinaryPrimitives.ReadUInt32BigEndian(_data.AsSpan());

src\Servers\Kestrel\shared\test\PipeWriterHttp2FrameExtensions.cs (1)

102BinaryPrimitives.WriteUInt32BigEndian(writer.GetSpan(4), (uint)sizeIncrement);

src\Shared\runtime\Http3\Helpers\VariableLengthIntegerHelper.cs (6)

53if (BinaryPrimitives.TryReadUInt16BigEndian(buffer, out ushort serializedShort)) 61if (BinaryPrimitives.TryReadUInt32BigEndian(buffer, out uint serializedInt)) 70if (BinaryPrimitives.TryReadUInt64BigEndian(buffer, out ulong serializedLong)) 163if (BinaryPrimitives.TryWriteUInt16BigEndian(buffer, (ushort)((uint)longToEncode | TwoByteLengthMask))) 171if (BinaryPrimitives.TryWriteUInt32BigEndian(buffer, (uint)longToEncode | FourByteLengthMask)) 179if (BinaryPrimitives.TryWriteUInt64BigEndian(buffer, (ulong)longToEncode | EightByteLengthMask))

src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)

34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);

src\Shared\ServerInfrastructure\Http2\Http2FrameReader.cs (4)

154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 175frame.RstStreamErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders); 243var id = (Http2SettingsParameter)BinaryPrimitives.ReadUInt16BigEndian(payload); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

BackEnd\Client\MSBuildClientPacketPump.cs (1)

270int packetLength = BinaryPrimitives.ReadInt32LittleEndian(new Span<byte>(headerByte, 1, 4));

BackEnd\Components\Communications\NodeProviderOutOfProcBase.cs (1)

702int packetLength = BinaryPrimitives.ReadInt32LittleEndian(new Span<byte>(_headerByte, 1, 4));

NodePipeBase.cs (2)

130int packetLength = BinaryPrimitives.ReadInt32LittleEndian(new Span<byte>(_headerData, 1, 4)); 182int packetLength = BinaryPrimitives.ReadInt32LittleEndian(new Span<byte>(_headerData, 1, 4));

CryptographicHashProvider.cs (5)

262BinaryPrimitives.WriteInt32LittleEndian(span, bits[0]); 263BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4), bits[1]); 264BinaryPrimitives.WriteInt32LittleEndian(span.Slice(8), bits[2]); 265BinaryPrimitives.WriteInt32LittleEndian(span.Slice(12), bits[3]); 276BinaryPrimitives.WriteUInt32LittleEndian(bytes, value);

Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

InternalUtilities\LittleEndianReader.cs (1)

7using static System.Buffers.Binary.BinaryPrimitives;

Text\SourceText.cs (1)

656BinaryPrimitives.ReverseEndianness(source: shortSpan, destination: shortSpan);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

Compilation\CSharpCompilation.cs (1)

2468BinaryPrimitives.ReadInt32LittleEndian(obj.ContentHash.AsSpan()),

Utilities\ContentHashComparer.cs (1)

28return BinaryPrimitives.ReadInt32LittleEndian(obj.Span);

Utilities\InterceptableLocation.cs (2)

150var position = BinaryPrimitives.ReadInt32LittleEndian(bytes.AsSpan(start: positionIndex)); 180BinaryPrimitives.ReadInt32LittleEndian(_checksum.AsSpan()),

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

RemoteHostAssetWriter.cs (1)

186BinaryPrimitives.WriteInt32LittleEndian(span, (int)length);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

src\Compilers\Core\Portable\InternalUtilities\LittleEndianReader.cs (1)

7using static System.Buffers.Binary.BinaryPrimitives;

XxHash128Tests.cs (2)

141var high = BinaryPrimitives.ReadUInt64BigEndian(span); 142var low = BinaryPrimitives.ReadUInt64BigEndian(span.Slice(8));

src\RpmHeader.cs (28)

src\RpmLead.cs (8)

36lead.Type = BinaryPrimitives.ReadInt16BigEndian(stream.ReadExactly(2)); 37lead.Architecture = BinaryPrimitives.ReadInt16BigEndian(stream.ReadExactly(2)); 41lead.OperatingSystem = BinaryPrimitives.ReadInt16BigEndian(stream.ReadExactly(2)); 42lead.SignatureType = BinaryPrimitives.ReadInt16BigEndian(stream.ReadExactly(2)); 53BinaryPrimitives.WriteInt16BigEndian(beBytes, Type); 55BinaryPrimitives.WriteInt16BigEndian(beBytes, Architecture); 62BinaryPrimitives.WriteInt16BigEndian(beBytes, OperatingSystem); 64BinaryPrimitives.WriteInt16BigEndian(beBytes, SignatureType);

AzureAIInferenceEmbeddingGenerator.cs (1)

154ints[i] = BinaryPrimitives.ReverseEndianness(ints[i]);

Internal\DefaultHybridCache.L2.cs (2)

115BinaryPrimitives.WriteInt64LittleEndian(oversized, timestamp); 154timestamp = BinaryPrimitives.ReadInt64LittleEndian(buffer.AsSpan());

Internal\HybridCachePayload.cs (8)

108BinaryPrimitives.WriteUInt16LittleEndian(destination.AsSpan(0, 2), UInt16SentinelPrefixPair); 109BinaryPrimitives.WriteUInt16LittleEndian(destination.AsSpan(2, 2), (ushort)_entropySource.Next(0, 0x010000)); // Next is exclusive at RHS 110BinaryPrimitives.WriteInt64LittleEndian(destination.AsSpan(4, 8), creationTime); 142BinaryPrimitives.WriteUInt16LittleEndian(destination.AsSpan(len, 2), UInt16SentinelPrefixPair); 202switch (BinaryPrimitives.ReadUInt16LittleEndian(bytes)) 205entropy = BinaryPrimitives.ReadUInt16LittleEndian(bytes.Slice(2)); 206long creationTime = BinaryPrimitives.ReadInt64LittleEndian(bytes.Slice(4)); 299|| BinaryPrimitives.ReadUInt16LittleEndian(bytes.Slice(payloadLength)) != UInt16SentinelPrefixPair)

Resolver\DnsDataReader.cs (2)

61value = BinaryPrimitives.ReadUInt16BigEndian(MessageBuffer.AsSpan(_position)); 74value = BinaryPrimitives.ReadUInt32BigEndian(MessageBuffer.AsSpan(_position));

Resolver\DnsDataWriter.cs (2)

93BinaryPrimitives.WriteUInt16BigEndian(_buffer.Span.Slice(_position), value); 105BinaryPrimitives.WriteUInt32BigEndian(_buffer.Span.Slice(_position), value);

Resolver\DnsPrimitives.cs (20)

Resolver\DnsResolver.cs (2)

774BinaryPrimitives.WriteUInt16BigEndian(buffer, (ushort)length); 795responseLength = BinaryPrimitives.ReadUInt16BigEndian(buffer.AsSpan(0, 2));

Resolver\LoopbackDnsServer.cs (10)

99length = BinaryPrimitives.ReadUInt16BigEndian(buffer.AsSpan(0, 2)); 104BinaryPrimitives.WriteUInt16BigEndian(buffer.AsSpan(0, 2), (ushort)bytesWritten); 258if (!BinaryPrimitives.TryWriteUInt16BigEndian(buff, priority) || 259!BinaryPrimitives.TryWriteUInt16BigEndian(buff.AsSpan(2), weight) || 260!BinaryPrimitives.TryWriteUInt16BigEndian(buff.AsSpan(4), port) || 279!BinaryPrimitives.TryWriteUInt32BigEndian(buff.AsSpan(w1 + w2), serial) || 280!BinaryPrimitives.TryWriteUInt32BigEndian(buff.AsSpan(w1 + w2 + 4), refresh) || 281!BinaryPrimitives.TryWriteUInt32BigEndian(buff.AsSpan(w1 + w2 + 8), retry) || 282!BinaryPrimitives.TryWriteUInt32BigEndian(buff.AsSpan(w1 + w2 + 12), expire) || 283!BinaryPrimitives.TryWriteUInt32BigEndian(buff.AsSpan(w1 + w2 + 16), minimum))

mscorlib.cs (1)

49[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.Binary.BinaryPrimitives))]

netstandard.cs (1)

61[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.Binary.BinaryPrimitives))]

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

System\TermInfo.Database.cs (1)

291=> BinaryPrimitives.ReadInt32LittleEndian(buffer.AsSpan(pos));

System\Diagnostics\Activity.cs (3)

1983span[0] = BinaryPrimitives.ReverseEndianness(span[0]); 1984span[1] = BinaryPrimitives.ReverseEndianness(span[1]); 2166id = BinaryPrimitives.ReverseEndianness(id);

System\Formats\Asn1\AsnCharacterStringEncodings.cs (1)

377char c = (char)BinaryPrimitives.ReadInt16BigEndian(bytes.Slice(i));

System\Formats\Asn1\AsnDecoder.Integer.cs (1)

409if (BinaryPrimitives.TryReadUInt16BigEndian(contents, out ushort bigEndianValue))

System\Formats\Asn1\AsnDecoder.Oid.cs (1)

201BinaryPrimitives.WriteInt64LittleEndian(accumValueBytes, accum);

System\Formats\Asn1\AsnWriter.Integer.cs (1)

258if (BinaryPrimitives.TryReadUInt16BigEndian(value, out ushort bigEndianValue))

System\Formats\Cbor\CborHelpers.netcoreapp.cs (5)

45=> BinaryPrimitives.ReadHalfBigEndian(source); 49=> BinaryPrimitives.ReadSingleBigEndian(source); 53=> BinaryPrimitives.ReadDoubleBigEndian(source); 57=> BinaryPrimitives.WriteSingleBigEndian(destination, value); 61=> BinaryPrimitives.WriteDoubleBigEndian(destination, value);

System\Formats\Cbor\Reader\CborReader.Integer.cs (3)

181result = BinaryPrimitives.ReadUInt16BigEndian(data.Slice(1)); 193result = BinaryPrimitives.ReadUInt32BigEndian(data.Slice(1)); 205result = BinaryPrimitives.ReadUInt64BigEndian(data.Slice(1));

System\Formats\Cbor\Reader\CborReader.Simple.netcoreapp.cs (1)

32result = BinaryPrimitives.ReadHalfBigEndian(buffer.Slice(1));

System\Formats\Cbor\Writer\CborWriter.Integer.cs (3)

102BinaryPrimitives.WriteUInt16BigEndian(_buffer.AsSpan(_offset), (ushort)value); 109BinaryPrimitives.WriteUInt32BigEndian(_buffer.AsSpan(_offset), (uint)value); 116BinaryPrimitives.WriteUInt64BigEndian(_buffer.AsSpan(_offset), value);

System\Formats\Cbor\Writer\CborWriter.Simple.netcoreapp.cs (2)

26BinaryPrimitives.WriteUInt16BigEndian(_buffer.AsSpan(_offset), PositiveQNaNBitsHalf); 30BinaryPrimitives.WriteHalfBigEndian(_buffer.AsSpan(_offset), value);

System\Formats\Nrbf\ArraySinglePrimitiveRecord.cs (3)

166BinaryPrimitives.ReverseEndianness(span, span); 178BinaryPrimitives.ReverseEndianness(span, span); 190BinaryPrimitives.ReverseEndianness(span, span);

System\Formats\Tar\TarHeader.Write.cs (3)

1115BinaryPrimitives.WriteInt64BigEndian(destination, destinationValue); 1139BinaryPrimitives.WriteUInt32BigEndian(destination, value < 0 ? 0xffffffff : 0x80000000); 1140BinaryPrimitives.WriteInt64BigEndian(destination.Slice(Offset), value);

System\IO\Compression\ZipArchiveEntry.cs (38)

System\IO\Compression\ZipBlocks.cs (71)

System\IO\Hashing\Crc32.cs (5)

78BinaryPrimitives.WriteUInt32LittleEndian(destination, ~_crc); 87BinaryPrimitives.WriteUInt32LittleEndian(destination, ~_crc); 120BinaryPrimitives.WriteUInt32LittleEndian(ret, hash); 145BinaryPrimitives.WriteUInt32LittleEndian(destination, hash); 166BinaryPrimitives.WriteUInt32LittleEndian(destination, hash);

System\IO\Hashing\Crc64.cs (5)

76BinaryPrimitives.WriteUInt64BigEndian(destination, _crc); 85BinaryPrimitives.WriteUInt64BigEndian(destination, _crc); 118BinaryPrimitives.WriteUInt64BigEndian(ret, hash); 143BinaryPrimitives.WriteUInt64BigEndian(destination, hash); 164BinaryPrimitives.WriteUInt64BigEndian(destination, hash);

System\IO\Hashing\XxHash128.cs (5)

221low = BinaryPrimitives.ReverseEndianness(low); 222high = BinaryPrimitives.ReverseEndianness(high); 266uint combinedh = BitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 282seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 320m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

System\IO\Hashing\XxHash3.cs (5)

76BinaryPrimitives.WriteUInt64BigEndian(result, hash); 110hash = BinaryPrimitives.ReverseEndianness(hash); 169BinaryPrimitives.WriteUInt64BigEndian(destination, hash); 246seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 273BinaryPrimitives.ReverseEndianness(inputLow) +

System\IO\Hashing\XxHash32.cs (4)

135BinaryPrimitives.WriteUInt32BigEndian(destination, hash); 195BinaryPrimitives.WriteUInt32BigEndian(ret, hash); 221BinaryPrimitives.WriteUInt32BigEndian(destination, hash); 243BinaryPrimitives.WriteUInt32BigEndian(destination, hash);

System\IO\Hashing\XxHash32.State.cs (2)

62acc += BinaryPrimitives.ReadUInt32LittleEndian(lane) * Prime32_2; 77uint lane = BinaryPrimitives.ReadUInt32LittleEndian(remaining);

System\IO\Hashing\XxHash64.cs (4)

135BinaryPrimitives.WriteUInt64BigEndian(destination, hash); 195BinaryPrimitives.WriteUInt64BigEndian(ret, hash); 221BinaryPrimitives.WriteUInt64BigEndian(destination, hash); 243BinaryPrimitives.WriteUInt64BigEndian(destination, hash);

System\IO\Hashing\XxHash64.State.cs (3)

88return ApplyRound(acc, BinaryPrimitives.ReadUInt64LittleEndian(lane)); 112ulong lane = BinaryPrimitives.ReadUInt64LittleEndian(remaining); 124ulong lane = BinaryPrimitives.ReadUInt32LittleEndian(remaining);

System\IO\Hashing\XxHashShared.cs (4)

156static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 786BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 792BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 799value = BinaryPrimitives.ReverseEndianness(value);

artifacts\obj\System.Memory\Debug\net10.0\System.Memory.Forwards.cs (1)

3[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.Binary.BinaryPrimitives))]

System\Buffers\SequenceReaderExtensions.Binary.cs (3)

88value = BinaryPrimitives.ReverseEndianness(value); 127value = BinaryPrimitives.ReverseEndianness(value); 166value = BinaryPrimitives.ReverseEndianness(value);

src\libraries\Common\src\System\Net\Http\aspnetcore\Http3\Helpers\VariableLengthIntegerHelper.cs (6)

53if (BinaryPrimitives.TryReadUInt16BigEndian(buffer, out ushort serializedShort)) 61if (BinaryPrimitives.TryReadUInt32BigEndian(buffer, out uint serializedInt)) 70if (BinaryPrimitives.TryReadUInt64BigEndian(buffer, out ulong serializedLong)) 163if (BinaryPrimitives.TryWriteUInt16BigEndian(buffer, (ushort)((uint)longToEncode | TwoByteLengthMask))) 171if (BinaryPrimitives.TryWriteUInt32BigEndian(buffer, (uint)longToEncode | FourByteLengthMask)) 179if (BinaryPrimitives.TryWriteUInt64BigEndian(buffer, (ulong)longToEncode | EightByteLengthMask))

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (18)

System\Net\Http\SocketsHttpHandler\SocksHelper.cs (2)

182BinaryPrimitives.WriteUInt16BigEndian(buffer.AsSpan(addressLength + 4), (ushort)port); 227BinaryPrimitives.WriteUInt16BigEndian(buffer.AsSpan(2), (ushort)port);

System\Net\NetworkInformation\PhysicalAddress.cs (1)

32hash ^= BinaryPrimitives.ReadInt32LittleEndian(_address.AsSpan(i));

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)

55return BinaryPrimitives.ReadInt32BigEndian(numbers);

System\Net\IPAddress.cs (5)

215numbers[i] = BinaryPrimitives.ReadUInt16BigEndian(address.Slice(i * 2)); 369BinaryPrimitives.WriteUInt16BigEndian(destination.Slice(i * 2), numbers[i]); 539return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host; 544return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host; 549return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host;

System\Net\IPNetwork.cs (4)

103mask = BinaryPrimitives.ReverseEndianness(mask); 121mask = BinaryPrimitives.ReverseEndianness(mask); 258mask = BinaryPrimitives.ReverseEndianness(mask); 276mask = BinaryPrimitives.ReverseEndianness(mask);

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)

55return BinaryPrimitives.ReadInt32BigEndian(numbers);

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)

55return BinaryPrimitives.ReadInt32BigEndian(numbers);

src\libraries\Common\src\System\Net\Security\MD4.cs (2)

177BinaryPrimitives.WriteUInt32LittleEndian(output.Slice(j), input[i]); 185output[i] = BinaryPrimitives.ReadUInt32LittleEndian(input.Slice(j));

System\Net\NegotiateAuthenticationPal.ManagedNtlm.cs (11)

312return BinaryPrimitives.ReadInt16LittleEndian(span); 318return BinaryPrimitives.ReadInt16LittleEndian(span.Slice(4)); 342BinaryPrimitives.WriteInt16LittleEndian(span, (short)length); 343BinaryPrimitives.WriteInt16LittleEndian(span.Slice(2), (short)length); 344BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4), offset); 442BinaryPrimitives.WriteInt32LittleEndian(prefix.Slice(sizeof(uint) * 4), cbtDataSize); 520BinaryPrimitives.WriteUInt16LittleEndian(targetInfoBuffer.AsSpan(2 + targetInfoOffset), (ushort)spnSize); 577Flags flags = BitConverter.IsLittleEndian ? challengeMessage.Flags : (Flags)BinaryPrimitives.ReverseEndianness((uint)challengeMessage.Flags); 720BinaryPrimitives.WriteInt32LittleEndian(signature, 1); 721BinaryPrimitives.WriteUInt32LittleEndian(signature.Slice(12), sequenceNumber); 736BinaryPrimitives.ReadInt32LittleEndian(signature) != 1 ||

System\Net\Security\NegotiateStream.cs (5)

373readBytes = BinaryPrimitives.ReadInt32LittleEndian(_readHeader); 544BinaryPrimitives.WriteInt32LittleEndian(_writeHeader, _writeBuffer.WrittenCount); 779BinaryPrimitives.WriteInt64LittleEndian(message, ERROR_TRUST_FAILURE); 839BinaryPrimitives.WriteInt64LittleEndian(message, errorCode); 877long error = BinaryPrimitives.ReadInt64LittleEndian(message);

System\Net\Security\TlsFrameHelper.cs (8)

System\Net\WebSockets\ManagedWebSocket.cs (7)

731BinaryPrimitives.WriteUInt16BigEndian(sendBuffer.AsSpan(2), (ushort)payload.Length); 737BinaryPrimitives.WriteUInt64BigEndian(sendBuffer.AsSpan(2), (ulong)payload.Length); 1095closeStatus = (WebSocketCloseStatus)BinaryPrimitives.ReadUInt16BigEndian(_receiveBuffer.Span.Slice(_receiveBufferOffset)); 1201long pongPayload = BinaryPrimitives.ReadInt64BigEndian(_receiveBuffer.Span.Slice(_receiveBufferOffset, (int)header.PayloadLength)); 1310header.PayloadLength = BinaryPrimitives.ReadUInt16BigEndian(receiveBufferSpan.Slice(_receiveBufferOffset)); 1316header.PayloadLength = BinaryPrimitives.ReadInt64BigEndian(receiveBufferSpan.Slice(_receiveBufferOffset)); 1530BinaryPrimitives.WriteUInt16BigEndian(buffer, (ushort)closeStatus);

System\Net\WebSockets\ManagedWebSocket.KeepAlive.cs (1)

118BinaryPrimitives.WriteInt64BigEndian(pingPayloadBuffer, pingPayload);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Boolean.cs (1)

34int dw = BinaryPrimitives.ReadInt32LittleEndian(source) & ~0x20202020;

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Float.cs (2)

159int diff = (BinaryPrimitives.ReadInt32LittleEndian(source.Slice(srcIndex)) ^ infi); 164diff = (BinaryPrimitives.ReadInt32LittleEndian(source.Slice(srcIndex + 4)) ^ nity);

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

1246result = BinaryPrimitives.ReverseEndianness(result); 1294result = BinaryPrimitives.ReverseEndianness(result); 1317if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, m_value)) 1330if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, m_value))

src\libraries\System.Private.CoreLib\src\System\Collections\BitArray.cs (4)

98BinaryPrimitives.ReverseEndianness(array, MemoryMarshal.Cast<byte, int>((Span<byte>)_array)); 252BinaryPrimitives.ReverseEndianness(values, MemoryMarshal.Cast<byte, int>((Span<byte>)_array)); 687BinaryPrimitives.ReverseEndianness(source, intArray.AsSpan(index)); 973BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value);

src\libraries\System.Private.CoreLib\src\System\Decimal.cs (12)

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (11)

src\libraries\System.Private.CoreLib\src\System\Double.cs (4)

725if (BinaryPrimitives.TryWriteInt16BigEndian(destination, Exponent)) 738if (BinaryPrimitives.TryWriteInt16LittleEndian(destination, Exponent)) 751if (BinaryPrimitives.TryWriteUInt64BigEndian(destination, Significand)) 764if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination, Significand))

src\libraries\System.Private.CoreLib\src\System\Globalization\CharUnicodeInfo.cs (7)

247temp = BinaryPrimitives.ReverseEndianness(temp); 262int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 281int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 297int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 316int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 470index = BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ushort>(ref level2Ref)); 507index = BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ushort>(ref level2Ref));

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

51BinaryPrimitives.WriteUInt16BigEndian(sortKey, (ushort)source[i]); 70BinaryPrimitives.WriteUInt16BigEndian(tmp, hr); 71BinaryPrimitives.WriteUInt16BigEndian(tmp.Slice(sizeof(ushort)), lr); 79BinaryPrimitives.WriteUInt16BigEndian(sortKey, (ushort)InvariantModeCasing.ToUpper(c));

src\libraries\System.Private.CoreLib\src\System\Guid.cs (12)

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

1396if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, Significand)) 1409if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, Significand))

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

807result = BinaryPrimitives.ReverseEndianness(result); 887result = BinaryPrimitives.ReverseEndianness(result); 905result = BinaryPrimitives.ReverseEndianness(result); 939if (BinaryPrimitives.TryWriteInt128BigEndian(destination, this)) 952if (BinaryPrimitives.TryWriteInt128LittleEndian(destination, this))

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

355result = BinaryPrimitives.ReverseEndianness(result); 428result = BinaryPrimitives.ReverseEndianness(result); 468if (BinaryPrimitives.TryWriteInt16BigEndian(destination, m_value)) 481if (BinaryPrimitives.TryWriteInt16LittleEndian(destination, m_value))

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

375result = BinaryPrimitives.ReverseEndianness(result); 455result = BinaryPrimitives.ReverseEndianness(result); 473result = BinaryPrimitives.ReverseEndianness(result); 507if (BinaryPrimitives.TryWriteInt32BigEndian(destination, m_value)) 520if (BinaryPrimitives.TryWriteInt32LittleEndian(destination, m_value))

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

372result = BinaryPrimitives.ReverseEndianness(result); 452result = BinaryPrimitives.ReverseEndianness(result); 470result = BinaryPrimitives.ReverseEndianness(result); 504if (BinaryPrimitives.TryWriteInt64BigEndian(destination, m_value)) 517if (BinaryPrimitives.TryWriteInt64LittleEndian(destination, m_value))

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

377result = BinaryPrimitives.ReverseEndianness(result); 457result = BinaryPrimitives.ReverseEndianness(result); 475result = BinaryPrimitives.ReverseEndianness(result); 509if (BinaryPrimitives.TryWriteIntPtrBigEndian(destination, _value)) 522if (BinaryPrimitives.TryWriteIntPtrLittleEndian(destination, _value))

src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (9)

src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (9)

src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (1)

476ushort firstTwoBytes = BinaryPrimitives.ReadUInt16LittleEndian(byteBuffer);

src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (2)

948ulong key = BinaryPrimitives.ReadUInt64LittleEndian(tableData); 949char value = (char)BinaryPrimitives.ReadUInt16LittleEndian(tableData.Slice(sizeof(ulong)));

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

960val = BinaryPrimitives.ReverseEndianness(val);

src\libraries\System.Private.CoreLib\src\System\Reflection\AssemblyNameHelpers.StrongName.cs (3)

48uint sigAlgID = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob); 49uint hashAlgID = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob.Slice(4)); 50uint cbPublicKey = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob.Slice(8));

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (2)

177return BinaryPrimitives.ReadInt32LittleEndian(new ReadOnlySpan<byte>(p, sizeof(int))); 411arr[i] = (char)BinaryPrimitives.ReverseEndianness((short)charPtr[i]);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\NFloat.cs (4)

1049exponent = BinaryPrimitives.ReverseEndianness(exponent); 1073exponent = BinaryPrimitives.ReverseEndianness(exponent); 1097significand = BinaryPrimitives.ReverseEndianness(significand); 1121significand = BinaryPrimitives.ReverseEndianness(significand);

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

748if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, Significand)) 761if (BinaryPrimitives.TryWriteUInt32LittleEndian(destination, Significand))

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

1433Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, offset), BinaryPrimitives.ReverseEndianness(tempLast)); 1434Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, lastOffset), BinaryPrimitives.ReverseEndianness(tempFirst)); 1452Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, offset), BinaryPrimitives.ReverseEndianness(tempLast)); 1453Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, lastOffset), BinaryPrimitives.ReverseEndianness(tempFirst));

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

117uint tempA = BinaryPrimitives.ReverseEndianness(value & 0x003F_0700u); // = [ 00000000 00000uuu 00xxxxxx 00000000 ] 223return BinaryPrimitives.ReverseEndianness((ushort)(temp + value + 0xC080u)); // [ 00000000 00000000 10xxxxxx 110yyyyy ] 441return BinaryPrimitives.ReverseEndianness(value);

src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (4)

1115=> BinaryPrimitives.ReadInt16BigEndian(value); 1120=> BinaryPrimitives.ReadInt32BigEndian(value.AsSpan(startIndex)); 1125=> BinaryPrimitives.ReadInt32BigEndian(value); 1130=> BinaryPrimitives.ReadInt64BigEndian(value.AsSpan(startIndex));

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

858result = BinaryPrimitives.ReverseEndianness(result); 913result = BinaryPrimitives.ReverseEndianness(result); 949if (BinaryPrimitives.TryWriteUInt128BigEndian(destination, this)) 962if (BinaryPrimitives.TryWriteUInt128LittleEndian(destination, this))

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

329result = BinaryPrimitives.ReverseEndianness(result); 377result = BinaryPrimitives.ReverseEndianness(result); 400if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, m_value)) 413if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, m_value))

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

350result = BinaryPrimitives.ReverseEndianness(result); 405result = BinaryPrimitives.ReverseEndianness(result); 438if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, m_value)) 451if (BinaryPrimitives.TryWriteUInt32LittleEndian(destination, m_value))

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

349result = BinaryPrimitives.ReverseEndianness(result); 404result = BinaryPrimitives.ReverseEndianness(result); 437if (BinaryPrimitives.TryWriteUInt64BigEndian(destination, m_value)) 450if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination, m_value))

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

353result = BinaryPrimitives.ReverseEndianness(result); 408result = BinaryPrimitives.ReverseEndianness(result); 441if (BinaryPrimitives.TryWriteUIntPtrBigEndian(destination, _value)) 454if (BinaryPrimitives.TryWriteUIntPtrLittleEndian(destination, _value))

src\System\Reflection\Emit\CustomAttributeBuilder.cs (2)

362writer.Write(BinaryPrimitives.ReverseEndianness((short)(length | 0x80_00))); 366writer.Write(BinaryPrimitives.ReverseEndianness(length | 0xC0_00_00_00));

src\System\Reflection\Emit\RuntimeILGenerator.cs (8)

src\System\Reflection\Emit\SignatureHelper.cs (2)

477BinaryPrimitives.WriteInt16BigEndian(m_signature.AsSpan(m_currSig), (short)(data | 0x80_00)); 482BinaryPrimitives.WriteInt32BigEndian(m_signature.AsSpan(m_currSig), (int)(data | 0xC0_00_00_00));

src\System\Reflection\RuntimeCustomAttributeData.cs (6)

946return BinaryPrimitives.ReadUInt16LittleEndian(tmp); 954return BinaryPrimitives.ReadUInt32LittleEndian(tmp); 962return BinaryPrimitives.ReadUInt64LittleEndian(tmp); 970return BinaryPrimitives.ReadSingleLittleEndian(tmp); 981return BinaryPrimitives.ReadDoubleLittleEndian(tmp); 1545data = BinaryPrimitives.ReverseEndianness(data);

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

67BinaryPrimitives.ReverseEndianness( 72BinaryPrimitives.ReverseEndianness( 77BinaryPrimitives.ReverseEndianness(

System\Runtime\Serialization\DataContract.cs (1)

1843b = unchecked(a + f + sines[j] + BinaryPrimitives.ReadUInt32LittleEndian(block.AsSpan(g)));

System\Xml\XmlBinaryWriter.cs (19)

System\Xml\XmlBufferReader.cs (18)

System\Xml\XmlStreamNodeWriter.cs (1)

345BinaryPrimitives.ReverseEndianness(new ReadOnlySpan<short>(chars, charCount),

src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)

55return BinaryPrimitives.ReadInt32BigEndian(numbers);

System\IO\BinaryReaderExtensions.cs (3)

134BinaryPrimitives.ReverseEndianness(ushorts, ushorts); 139BinaryPrimitives.ReverseEndianness(ints, ints); 144BinaryPrimitives.ReverseEndianness(longs, longs);

System\Xml\BinaryXml\SqlUtils.cs (1)

73=> BinaryPrimitives.ReadUInt32LittleEndian(data.AsSpan(offset));

System\Xml\BinaryXml\XmlBinaryReader.cs (11)

System\Xml\Serialization\Compiler.cs (1)

96return BinaryPrimitives.ReadUInt32BigEndian(hash);

System\Xml\XmlEncoding.cs (2)

521code = BinaryPrimitives.ReadUInt32LittleEndian(bytes.AsSpan(i)); 562code = BinaryPrimitives.ReadUInt32BigEndian(bytes.AsSpan(i));

System\Reflection\Emit\CustomAttributeWrapper.cs (3)

58int numNamed = BinaryPrimitives.ReadUInt16LittleEndian(binaryAttribute.Slice(pos)); 136return BinaryPrimitives.ReadInt32LittleEndian(data.Slice(pos)); 139return BinaryPrimitives.ReadInt16LittleEndian(data.Slice(pos));

System\Reflection\Emit\FieldBuilderImpl.cs (1)

60_offset = BinaryPrimitives.ReadInt32LittleEndian(binaryAttribute.Slice(2));

System\Reflection\Emit\MethodBuilderImpl.cs (1)

178int implValue = BinaryPrimitives.ReadUInt16LittleEndian(binaryAttribute.Slice(2));

System\Reflection\Internal\Utilities\BlobUtilities.cs (5)

52Unsafe.WriteUnaligned(ref buffer[start], !BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 55Unsafe.WriteUnaligned(ref buffer[start], BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 58Unsafe.WriteUnaligned(ref buffer[start], BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 61Unsafe.WriteUnaligned(ref buffer[start], !BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value); 64Unsafe.WriteUnaligned(ref buffer[start], !BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value);

System\Reflection\Internal\Utilities\MemoryBlock.cs (2)

131return BitConverter.IsLittleEndian ? result : BinaryPrimitives.ReverseEndianness(result); 189return BitConverter.IsLittleEndian ? result : BinaryPrimitives.ReverseEndianness(result);

src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (2)

177return BinaryPrimitives.ReadInt32LittleEndian(new ReadOnlySpan<byte>(p, sizeof(int))); 411arr[i] = (char)BinaryPrimitives.ReverseEndianness((short)charPtr[i]);

System\Numerics\BigInteger.cs (11)

src\libraries\Common\src\System\Security\Cryptography\RsaPaddingProcessor.cs (1)

598BinaryPrimitives.WriteInt32BigEndian(bigEndianCount, count);

System\Security\Cryptography\Aes.cs (8)

363iv = BinaryPrimitives.ReadUInt64BigEndian(decrypt); 420BinaryPrimitives.WriteUInt64BigEndian(buf, iv); 462BinaryPrimitives.WriteUInt64BigEndian(A, iv); 473uint al = BinaryPrimitives.ReadUInt32BigEndian(ALo); 475BinaryPrimitives.WriteUInt32BigEndian(ALo, al); 501uint al = BinaryPrimitives.ReadUInt32BigEndian(ALo); 503BinaryPrimitives.WriteUInt32BigEndian(ALo, al); 511return BinaryPrimitives.ReadUInt64BigEndian(A);

System\Security\Cryptography\DES.cs (2)

72ulong key = BinaryPrimitives.ReadUInt64BigEndian(rgbOddParityKey); 90ulong key = BinaryPrimitives.ReadUInt64BigEndian(rgbOddParityKey);

System\Security\Cryptography\PKCS1MaskGenerationMethod.cs (1)

43BinaryPrimitives.WriteUInt32BigEndian(rgbCounter, counter++);

System\Security\Cryptography\Rfc2898DeriveBytes.cs (1)

289BinaryPrimitives.WriteUInt32BigEndian(_salt.AsSpan(_salt.Length - sizeof(uint)), _block + 1);

System\Security\Cryptography\SP800108HmacCounterKdfImplementationManaged.cs (2)

49BinaryPrimitives.WriteUInt32BigEndian(lBuffer, (uint)destination.Length * 8U); 53BinaryPrimitives.WriteUInt32BigEndian(iBuffer, i);

System\Security\Cryptography\X509Certificates\UnixExportProvider.cs (1)

154BinaryPrimitives.WriteInt32LittleEndian(localKeyIdAttributeValue, localKeyIdCounter);

System\Security\Cryptography\XmlKeyHelper.cs (1)

107BinaryPrimitives.WriteInt32BigEndian(valBuf, value);

System\Security\Cryptography\Cose\CoseHelpers.cs (3)

65BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(1), (ushort)value); 73BinaryPrimitives.WriteUInt32BigEndian(buffer.Slice(1), (uint)value); 81BinaryPrimitives.WriteUInt64BigEndian(buffer.Slice(1), value);

System\Text\BaseCodePageEncoding.cs (16)

System\Text\BaseCodePageEncoding.netcoreapp.cs (4)

28pCodePageName[i] = (char)BinaryPrimitives.ReverseEndianness((ushort)pCodePageName[i]); 30p->CodePage = BinaryPrimitives.ReverseEndianness(p->CodePage); 31p->ByteCount = BinaryPrimitives.ReverseEndianness(p->ByteCount); 32p->Offset = BinaryPrimitives.ReverseEndianness(p->Offset);

System\Text\DBCSCodePageEncoding.cs (1)

53return (char)BinaryPrimitives.ReverseEndianness((ushort)*pChar);

System\Text\SBCSCodePageEncoding.cs (1)

44return BinaryPrimitives.ReverseEndianness(*(ushort*)pByte);

System\Text\Encodings\Web\AllowedBmpCodePointsBitmap.cs (1)

89thisAllowedCharactersBitmap[i] &= BinaryPrimitives.ReadUInt32LittleEndian(definedCharsBitmapAsLittleEndian.Slice(i * sizeof(uint)));

System\Text\Encodings\Web\OptimizedInboxTextEncoder.cs (1)

277if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination.Slice(dstIdx), preescapedEntry))

Infra\ScreenRecordService.cs (3)

463=> (int)BinaryPrimitives.ReadUInt32BigEndian(memory.Span); 525BinaryPrimitives.WriteUInt16BigEndian(encoded, value); 532BinaryPrimitives.WriteUInt32BigEndian(encoded, value);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);

src\Compilers\Core\Portable\Hashing\XxHash128.cs (5)

225low = BinaryPrimitives.ReverseEndianness(low); 226high = BinaryPrimitives.ReverseEndianness(high); 270uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 286seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 324m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);

src\Compilers\Core\Portable\Hashing\XxHashShared.cs (4)

161static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 795BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 801BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 808value = BinaryPrimitives.ReverseEndianness(value);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)

104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);