1301 references to BinaryPrimitives
cdac-build-tool (6)
ObjectFileScraper.cs (6)
104public ulong GetUInt64(long offset) => LittleEndian ? BinaryPrimitives.ReadUInt64LittleEndian(Data.Span.Slice((int)offset)) : BinaryPrimitives.ReadUInt64BigEndian(Data.Span.Slice((int)offset)); 105public uint GetUInt32(long offset) => LittleEndian ? BinaryPrimitives.ReadUInt32LittleEndian(Data.Span.Slice((int)offset)) : BinaryPrimitives.ReadUInt32BigEndian(Data.Span.Slice((int)offset)); 106public ushort GetUInt16(long offset) => LittleEndian ? BinaryPrimitives.ReadUInt16LittleEndian(Data.Span.Slice((int)offset)) : BinaryPrimitives.ReadUInt16BigEndian(Data.Span.Slice((int)offset));
GenerateDocumentationAndConfigFiles (10)
src\roslyn\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\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
ILAssembler (1)
GrammarVisitor.cs (1)
3107BinaryPrimitives.ReverseEndianness(bytesAsChars[i]);
ILCompiler.Compiler (204)
Compiler\ObjectWriter\CodeView\CodeViewFileTableBuilder.cs (2)
50BinaryPrimitives.WriteUInt32LittleEndian(fileTableEntry, stringTableIndex); 51BinaryPrimitives.WriteUInt32LittleEndian(fileTableEntry.Slice(4), 0);
Compiler\ObjectWriter\CodeView\CodeViewSymbolsBuilder.cs (7)
54BinaryPrimitives.WriteUInt32LittleEndian(versionBuffer, 4); 320BinaryPrimitives.WriteUInt32LittleEndian(subsectionHeader, (uint)_kind); 321BinaryPrimitives.WriteUInt32LittleEndian(subsectionHeader.Slice(4), _size); 373BinaryPrimitives.WriteUInt16LittleEndian(lengthBuffer, (ushort)(_bufferWriter.WrittenCount)); 393BinaryPrimitives.WriteUInt16LittleEndian(_bufferWriter.GetSpan(sizeof(ushort)), value); 399BinaryPrimitives.WriteUInt32LittleEndian(_bufferWriter.GetSpan(sizeof(uint)), value); 405BinaryPrimitives.WriteUInt64LittleEndian(_bufferWriter.GetSpan(sizeof(ulong)), value);
Compiler\ObjectWriter\CodeView\CodeViewTypesBuilder.cs (5)
62BinaryPrimitives.WriteUInt32LittleEndian(versionBuffer, 4); 417BinaryPrimitives.WriteUInt16LittleEndian(lengthBuffer, (ushort)(length + padding - sizeof(ushort))); 432BinaryPrimitives.WriteUInt16LittleEndian(_bufferWriter.GetSpan(sizeof(ushort)), value); 438BinaryPrimitives.WriteUInt32LittleEndian(_bufferWriter.GetSpan(sizeof(uint)), value); 444BinaryPrimitives.WriteUInt64LittleEndian(_bufferWriter.GetSpan(sizeof(ulong)), value);
Compiler\ObjectWriter\Dwarf\DwarfBuilder.cs (2)
218BinaryPrimitives.WriteUInt32LittleEndian(sizeBuffer, (uint)(infoSectionWriter.Position - sizeof(uint))); 262BinaryPrimitives.WriteUInt32LittleEndian(sizeBuffer, (uint)(arangeSectionWriter.Position - sizeof(uint)));
Compiler\ObjectWriter\Dwarf\DwarfInfoWriter.cs (1)
212BinaryPrimitives.WriteUInt32LittleEndian(lateBoundReference.Data, offset);
Compiler\ObjectWriter\Dwarf\DwarfLineProgramTableWriter.cs (2)
111BinaryPrimitives.WriteInt32LittleEndian(headerSizeBuffer, (int)(lineSectionWriter.Position - headerStart)); 117BinaryPrimitives.WriteInt32LittleEndian(_sizeBuffer, (int)(_lineSectionWriter.Position - sizeof(uint)));
Compiler\ObjectWriter\Eabi\EabiUnwindConverter.cs (2)
76short dwarfReg = BinaryPrimitives.ReadInt16LittleEndian(blobData.AsSpan(offset + 2)); 77int cfiOffset = BinaryPrimitives.ReadInt32LittleEndian(blobData.AsSpan(offset + 4));
Compiler\ObjectWriter\MachObjectWriter.Aot.cs (5)
87BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer, cu.PcLength); 88BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer.Slice(4), cu.Code); 101BinaryPrimitives.WriteUInt64LittleEndian(tempBuffer, section.VirtualAddress + (ulong)symbol.Value); 156short dwarfReg = BinaryPrimitives.ReadInt16LittleEndian(blobData.AsSpan(offset)); 158int cfiOffset = BinaryPrimitives.ReadInt32LittleEndian(blobData.AsSpan(offset));
Compiler\ReachabilityInstrumentationProvider.cs (1)
114BinaryPrimitives.WriteInt32LittleEndian(newBytes.AsSpan()[2..6], MetadataTokens.GetToken(MetadataTokens.FieldDefinitionHandle(0)));
Compiler\SubstitutedILProvider.cs (2)
560BinaryPrimitives.WriteUInt32LittleEndian(new Span<byte>(newBody, dstPos, sizeof(uint)), (uint)(dest - dstJmpBase)); 582BinaryPrimitives.WriteUInt32LittleEndian(new Span<byte>(newBody, dstPos, sizeof(uint)), (uint)(dest - (dstPos + sizeof(uint))));
src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\ObjectDataBuilder.cs (8)
89BinaryPrimitives.WriteInt16LittleEndian(_data.AppendSpan(sizeof(short)), emit); 94BinaryPrimitives.WriteUInt16LittleEndian(_data.AppendSpan(sizeof(ushort)), emit); 99BinaryPrimitives.WriteInt32LittleEndian(_data.AppendSpan(sizeof(int)), emit); 104BinaryPrimitives.WriteUInt32LittleEndian(_data.AppendSpan(sizeof(uint)), emit); 109BinaryPrimitives.WriteInt64LittleEndian(_data.AppendSpan(sizeof(long)), emit); 234BinaryPrimitives.WriteInt16LittleEndian(_data.AsSpan(offset), emit); 245BinaryPrimitives.WriteInt32LittleEndian(_data.AsSpan(offset), emit); 251BinaryPrimitives.WriteUInt32LittleEndian(_data.AsSpan(offset), emit);
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\CoffObjectWriter.cs (39)
542BinaryPrimitives.WriteInt16LittleEndian(buffer, (short)Machine); 543BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(2), (ushort)NumberOfSections); 544BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4), TimeDateStamp); 545BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8), PointerToSymbolTable); 546BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(12), NumberOfSymbols); 547BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(16), SizeOfOptionalHeader); 548BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(18), (ushort)Characteristics); 557BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(2), 0xFFFF); 558BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(4), 2); 559BinaryPrimitives.WriteInt16LittleEndian(buffer.Slice(6), (short)Machine); 560BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8), TimeDateStamp); 562BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(44), NumberOfSections); 563BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(48), PointerToSymbolTable); 564BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(52), NumberOfSymbols); 642BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize), VirtualSize); 643BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 4), VirtualAddress); 644BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 8), SizeOfRawData); 645BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 12), PointerToRawData); 646BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 16), PointerToRelocations); 647BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 20), PointerToLineNumbers); 648BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(NameSize + 24), NumberOfRelocations); 649BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(NameSize + 26), NumberOfLineNumbers); 650BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 28), (uint)SectionCharacteristics); 718BinaryPrimitives.WriteUInt32LittleEndian(buffer, VirtualAddress); 719BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4), SymbolTableIndex); 720BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(8), (ushort)Type); 779BinaryPrimitives.WriteUInt32LittleEndian(buffer, 0); 780BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), stringTable.GetStringOffset(Name)); 783BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize), Value); 787BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 4), SectionIndex); 793BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(NameSize + 4), (ushort)SectionIndex); 796BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(sliceIndex), Type); 839BinaryPrimitives.WriteUInt32LittleEndian(buffer, SizeOfRawData); 840BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(4), NumberOfRelocations); 841BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(6), NumberOfLineNumbers); 842BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8), CheckSum); 843BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(12), (ushort)Number); 847BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(16), (ushort)(Number >> 16)); 866BinaryPrimitives.WriteUInt32LittleEndian(stringTableSize, Size);
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\Eabi\EabiAttributesBuilder.cs (2)
60BinaryPrimitives.WriteUInt32LittleEndian(_subsectionSize, (uint)(_sectionWriter.Position - _subsectionSizePosition)); 61BinaryPrimitives.WriteUInt32LittleEndian(_sectionSize, (uint)(_sectionWriter.Position - _sectionSizePosition));
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\ElfObjectWriter.cs (41)
140BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer, GRP_COMDAT); 351BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry, (uint)thunkSectionWriter.Position); 352BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry.Slice(4), ((uint)_symbolNameToIndex[externSymbol] << 8) | R_ARM_THM_JUMP24); 419BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry, (uint)symbolicRelocation.Offset); 420BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry.Slice(4), ((uint)symbolIndex << 8) | type); 447BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset); 448BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type); 449BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), symbolicRelocation.Addend); 479BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry, (uint)symbolicRelocation.Offset); 480BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry.Slice(4), ((uint)symbolIndex << 8) | type); 485BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry, (uint)(symbolicRelocation.Offset + 4)); 486BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry.Slice(4), ((uint)symbolIndex << 8) | (type + 1)); 521BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset); 522BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type); 523BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), symbolicRelocation.Addend); 549BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset); 550BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type); 551BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), symbolicRelocation.Addend); 556BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset + 4); 557BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type + 1); 558BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), symbolicRelocation.Addend); 587BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset); 588BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type); 589BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), symbolicRelocation.Addend); 601BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset + 4); 602BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type); 603BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), 0); 720BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer, section.SectionIndex); 806BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer, index >= SHN_LORESERVE ? index : 0); 984BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer, Flags); 985BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(4), (ushort)buffer.Length); 986BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(6), SegmentHeaderEntrySize); 987BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(8), SegmentHeaderEntryCount); 988BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(10), SectionHeaderEntrySize); 989BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(12), SectionHeaderEntryCount); 990BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(14), StringTableIndex); 1071BinaryPrimitives.WriteUInt32LittleEndian(buffer, !Name.IsNull ? stringTable.GetStringOffset(Name) : 0); 1078BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(14), sectionIndex); 1084BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(6), sectionIndex); 1085BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(8), Value); 1086BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(16), Size);
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\MachObjectWriter.cs (70)
422BinaryPrimitives.WriteUInt32LittleEndian(data, (uint)addend + (uint)range.Size); 441BinaryPrimitives.WriteInt64LittleEndian(data, addend); 444BinaryPrimitives.WriteUInt32LittleEndian(data, (uint)addend); 457BinaryPrimitives.WriteUInt64LittleEndian(data, _sections[targetSectionIndex].VirtualAddress + (ulong)addend); 485BinaryPrimitives.WriteInt32LittleEndian( 487BinaryPrimitives.ReadInt32LittleEndian(data) + 495BinaryPrimitives.WriteInt32LittleEndian( 497BinaryPrimitives.ReadInt32LittleEndian(data) + 906BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), MH_MAGIC_64); 907BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), (uint)CpuType); 908BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8, 4), CpuSubType); 909BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(12, 4), FileType); 910BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(16, 4), NumberOfCommands); 911BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(20, 4), SizeOfCommands); 912BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(24, 4), Flags); 913BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(28, 4), Reserved); 937BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), LC_SEGMENT_64); 938BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), (uint)(HeaderSize + NumberOfSections * MachSection.HeaderSize)); 941BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(24, 8), Address); 942BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(32, 8), Size); 943BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(40, 8), FileOffset); 944BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(48, 8), FileSize); 945BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(56, 4), MaximumProtection); 946BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(60, 4), InitialProtection); 947BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(64, 4), NumberOfSections); 948BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(68, 4), Flags); 1001BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(32, 8), VirtualAddress); 1002BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(40, 8), Size); 1003BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(48, 4), FileOffset); 1004BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(52, 4), Log2Alignment); 1005BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(56, 4), RelocationOffset); 1006BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(60, 4), NumberOfRelocationEntries); 1007BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(64, 4), Flags); 1030BinaryPrimitives.WriteInt32LittleEndian(relocationBuffer, Address); 1031BinaryPrimitives.WriteUInt32LittleEndian(relocationBuffer.Slice(4), info); 1049BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), nameIndex); 1052BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(6, 2), Descriptor); 1053BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(8), Value); 1072BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), LC_SYMTAB); 1073BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), (uint)HeaderSize); 1074BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8, 4), SymbolTableOffset); 1075BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(12, 4), NumberOfSymbols); 1076BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(16, 4), StringTableOffset); 1077BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(20, 4), StringTableSize); 1110BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), LC_DYSYMTAB); 1111BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), (uint)HeaderSize); 1112BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8, 4), LocalSymbolsIndex); 1113BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(12, 4), LocalSymbolsCount); 1114BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(16, 4), ExternalSymbolsIndex); 1115BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(20, 4), ExternalSymbolsCount); 1116BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(24, 4), UndefinedSymbolsIndex); 1117BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(28, 4), UndefinedSymbolsCount); 1118BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(32, 4), TableOfContentsOffset); 1119BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(36, 4), TableOfContentsCount); 1120BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(40, 4), ModuleTableOffset); 1121BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(44, 4), ModuleTableCount); 1122BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(48, 4), ExternalReferenceTableOffset); 1123BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(52, 4), ExternalReferenceTableCount); 1124BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(56, 4), IndirectSymbolTableOffset); 1125BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(60, 4), IndirectSymbolTableCount); 1126BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(64, 4), ExternalRelocationTableOffset); 1127BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(68, 4), ExternalRelocationTableCount); 1128BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(72, 4), LocalRelocationTableOffset); 1129BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(76, 4), LocalRelocationTableCount); 1147BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), LC_BUILD_VERSION); 1148BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), (uint)HeaderSize); 1149BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8, 4), Platform); 1150BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(12, 4), MinimumPlatformVersion); 1151BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(16, 4), SdkVersion); 1152BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(20, 4), 0); // No tools
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\PEObjectWriter.cs (1)
882BinaryPrimitives.WriteUInt32LittleEndian(timestamp, BlobContentId.FromHash(hash.ToArray()).Stamp);
src\runtime\src\coreclr\tools\Common\Pgo\PgoFormat.cs (2)
167signedInt = BinaryPrimitives.ReadInt64BigEndian(bytes.AsSpan(offset + 1, sizeof(long))); 172signedInt = BinaryPrimitives.ReadInt32BigEndian(bytes.AsSpan(offset + 1, sizeof(int)));
src\runtime\src\coreclr\tools\Common\TypeSystem\IL\ILImporter.cs (3)
33if (!BinaryPrimitives.TryReadUInt16LittleEndian(_ilBytes.AsSpan(_currentOffset), out ushort value)) 42if (!BinaryPrimitives.TryReadUInt32LittleEndian(_ilBytes.AsSpan(_currentOffset), out uint value)) 56if (!BinaryPrimitives.TryReadUInt64LittleEndian(_ilBytes.AsSpan(_currentOffset), out ulong value))
src\runtime\src\coreclr\tools\Common\TypeSystem\IL\ILReader.cs (6)
44if (!BinaryPrimitives.TryReadUInt16LittleEndian(_ilBytes.Slice(_currentOffset), out ushort value)) 53if (!BinaryPrimitives.TryReadUInt32LittleEndian(_ilBytes.Slice(_currentOffset), out uint value)) 67if (!BinaryPrimitives.TryReadUInt64LittleEndian(_ilBytes.Slice(_currentOffset), out ulong value)) 76if (!BinaryPrimitives.TryReadSingleLittleEndian(_ilBytes.Slice(_currentOffset), out float value)) 85if (!BinaryPrimitives.TryReadDoubleLittleEndian(_ilBytes.Slice(_currentOffset), out double value)) 118if (!BinaryPrimitives.TryReadInt32LittleEndian(_ilBytes.Slice(_currentOffset), out int value))
src\runtime\src\coreclr\tools\Common\TypeSystem\Interop\IL\Marshaller.Aot.cs (3)
969codeStream.EmitLdc(BinaryPrimitives.ReadInt32LittleEndian(bytes)); 970codeStream.EmitLdc(BinaryPrimitives.ReadInt16LittleEndian(bytes.Slice(4))); 971codeStream.EmitLdc(BinaryPrimitives.ReadInt16LittleEndian(bytes.Slice(6)));
ILCompiler.ReadyToRun (186)
Compiler\DependencyAnalysis\ReadyToRun\MethodWithGCInfo.cs (1)
399CORINFO_EH_CLAUSE_FLAGS flags = (CORINFO_EH_CLAUSE_FLAGS)BinaryPrimitives.ReadUInt32LittleEndian(
src\runtime\src\coreclr\tools\Common\Compiler\DependencyAnalysis\ObjectDataBuilder.cs (8)
89BinaryPrimitives.WriteInt16LittleEndian(_data.AppendSpan(sizeof(short)), emit); 94BinaryPrimitives.WriteUInt16LittleEndian(_data.AppendSpan(sizeof(ushort)), emit); 99BinaryPrimitives.WriteInt32LittleEndian(_data.AppendSpan(sizeof(int)), emit); 104BinaryPrimitives.WriteUInt32LittleEndian(_data.AppendSpan(sizeof(uint)), emit); 109BinaryPrimitives.WriteInt64LittleEndian(_data.AppendSpan(sizeof(long)), emit); 234BinaryPrimitives.WriteInt16LittleEndian(_data.AsSpan(offset), emit); 245BinaryPrimitives.WriteInt32LittleEndian(_data.AsSpan(offset), emit); 251BinaryPrimitives.WriteUInt32LittleEndian(_data.AsSpan(offset), emit);
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\CoffObjectWriter.cs (39)
542BinaryPrimitives.WriteInt16LittleEndian(buffer, (short)Machine); 543BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(2), (ushort)NumberOfSections); 544BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4), TimeDateStamp); 545BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8), PointerToSymbolTable); 546BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(12), NumberOfSymbols); 547BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(16), SizeOfOptionalHeader); 548BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(18), (ushort)Characteristics); 557BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(2), 0xFFFF); 558BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(4), 2); 559BinaryPrimitives.WriteInt16LittleEndian(buffer.Slice(6), (short)Machine); 560BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8), TimeDateStamp); 562BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(44), NumberOfSections); 563BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(48), PointerToSymbolTable); 564BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(52), NumberOfSymbols); 642BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize), VirtualSize); 643BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 4), VirtualAddress); 644BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 8), SizeOfRawData); 645BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 12), PointerToRawData); 646BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 16), PointerToRelocations); 647BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 20), PointerToLineNumbers); 648BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(NameSize + 24), NumberOfRelocations); 649BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(NameSize + 26), NumberOfLineNumbers); 650BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 28), (uint)SectionCharacteristics); 718BinaryPrimitives.WriteUInt32LittleEndian(buffer, VirtualAddress); 719BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4), SymbolTableIndex); 720BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(8), (ushort)Type); 779BinaryPrimitives.WriteUInt32LittleEndian(buffer, 0); 780BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), stringTable.GetStringOffset(Name)); 783BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize), Value); 787BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(NameSize + 4), SectionIndex); 793BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(NameSize + 4), (ushort)SectionIndex); 796BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(sliceIndex), Type); 839BinaryPrimitives.WriteUInt32LittleEndian(buffer, SizeOfRawData); 840BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(4), NumberOfRelocations); 841BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(6), NumberOfLineNumbers); 842BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8), CheckSum); 843BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(12), (ushort)Number); 847BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(16), (ushort)(Number >> 16)); 866BinaryPrimitives.WriteUInt32LittleEndian(stringTableSize, Size);
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\Eabi\EabiAttributesBuilder.cs (2)
60BinaryPrimitives.WriteUInt32LittleEndian(_subsectionSize, (uint)(_sectionWriter.Position - _subsectionSizePosition)); 61BinaryPrimitives.WriteUInt32LittleEndian(_sectionSize, (uint)(_sectionWriter.Position - _sectionSizePosition));
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\ElfObjectWriter.cs (41)
140BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer, GRP_COMDAT); 351BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry, (uint)thunkSectionWriter.Position); 352BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry.Slice(4), ((uint)_symbolNameToIndex[externSymbol] << 8) | R_ARM_THM_JUMP24); 419BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry, (uint)symbolicRelocation.Offset); 420BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry.Slice(4), ((uint)symbolIndex << 8) | type); 447BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset); 448BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type); 449BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), symbolicRelocation.Addend); 479BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry, (uint)symbolicRelocation.Offset); 480BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry.Slice(4), ((uint)symbolIndex << 8) | type); 485BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry, (uint)(symbolicRelocation.Offset + 4)); 486BinaryPrimitives.WriteUInt32LittleEndian(relocationEntry.Slice(4), ((uint)symbolIndex << 8) | (type + 1)); 521BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset); 522BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type); 523BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), symbolicRelocation.Addend); 549BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset); 550BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type); 551BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), symbolicRelocation.Addend); 556BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset + 4); 557BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type + 1); 558BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), symbolicRelocation.Addend); 587BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset); 588BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type); 589BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), symbolicRelocation.Addend); 601BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry, (ulong)symbolicRelocation.Offset + 4); 602BinaryPrimitives.WriteUInt64LittleEndian(relocationEntry.Slice(8), ((ulong)symbolIndex << 32) | type); 603BinaryPrimitives.WriteInt64LittleEndian(relocationEntry.Slice(16), 0); 720BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer, section.SectionIndex); 806BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer, index >= SHN_LORESERVE ? index : 0); 984BinaryPrimitives.WriteUInt32LittleEndian(tempBuffer, Flags); 985BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(4), (ushort)buffer.Length); 986BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(6), SegmentHeaderEntrySize); 987BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(8), SegmentHeaderEntryCount); 988BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(10), SectionHeaderEntrySize); 989BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(12), SectionHeaderEntryCount); 990BinaryPrimitives.WriteUInt16LittleEndian(tempBuffer.Slice(14), StringTableIndex); 1071BinaryPrimitives.WriteUInt32LittleEndian(buffer, !Name.IsNull ? stringTable.GetStringOffset(Name) : 0); 1078BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(14), sectionIndex); 1084BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(6), sectionIndex); 1085BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(8), Value); 1086BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(16), Size);
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\MachObjectWriter.cs (70)
422BinaryPrimitives.WriteUInt32LittleEndian(data, (uint)addend + (uint)range.Size); 441BinaryPrimitives.WriteInt64LittleEndian(data, addend); 444BinaryPrimitives.WriteUInt32LittleEndian(data, (uint)addend); 457BinaryPrimitives.WriteUInt64LittleEndian(data, _sections[targetSectionIndex].VirtualAddress + (ulong)addend); 485BinaryPrimitives.WriteInt32LittleEndian( 487BinaryPrimitives.ReadInt32LittleEndian(data) + 495BinaryPrimitives.WriteInt32LittleEndian( 497BinaryPrimitives.ReadInt32LittleEndian(data) + 906BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), MH_MAGIC_64); 907BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), (uint)CpuType); 908BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8, 4), CpuSubType); 909BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(12, 4), FileType); 910BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(16, 4), NumberOfCommands); 911BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(20, 4), SizeOfCommands); 912BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(24, 4), Flags); 913BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(28, 4), Reserved); 937BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), LC_SEGMENT_64); 938BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), (uint)(HeaderSize + NumberOfSections * MachSection.HeaderSize)); 941BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(24, 8), Address); 942BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(32, 8), Size); 943BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(40, 8), FileOffset); 944BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(48, 8), FileSize); 945BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(56, 4), MaximumProtection); 946BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(60, 4), InitialProtection); 947BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(64, 4), NumberOfSections); 948BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(68, 4), Flags); 1001BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(32, 8), VirtualAddress); 1002BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(40, 8), Size); 1003BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(48, 4), FileOffset); 1004BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(52, 4), Log2Alignment); 1005BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(56, 4), RelocationOffset); 1006BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(60, 4), NumberOfRelocationEntries); 1007BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(64, 4), Flags); 1030BinaryPrimitives.WriteInt32LittleEndian(relocationBuffer, Address); 1031BinaryPrimitives.WriteUInt32LittleEndian(relocationBuffer.Slice(4), info); 1049BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), nameIndex); 1052BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(6, 2), Descriptor); 1053BinaryPrimitives.WriteUInt64LittleEndian(buffer.Slice(8), Value); 1072BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), LC_SYMTAB); 1073BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), (uint)HeaderSize); 1074BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8, 4), SymbolTableOffset); 1075BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(12, 4), NumberOfSymbols); 1076BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(16, 4), StringTableOffset); 1077BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(20, 4), StringTableSize); 1110BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), LC_DYSYMTAB); 1111BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), (uint)HeaderSize); 1112BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8, 4), LocalSymbolsIndex); 1113BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(12, 4), LocalSymbolsCount); 1114BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(16, 4), ExternalSymbolsIndex); 1115BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(20, 4), ExternalSymbolsCount); 1116BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(24, 4), UndefinedSymbolsIndex); 1117BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(28, 4), UndefinedSymbolsCount); 1118BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(32, 4), TableOfContentsOffset); 1119BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(36, 4), TableOfContentsCount); 1120BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(40, 4), ModuleTableOffset); 1121BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(44, 4), ModuleTableCount); 1122BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(48, 4), ExternalReferenceTableOffset); 1123BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(52, 4), ExternalReferenceTableCount); 1124BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(56, 4), IndirectSymbolTableOffset); 1125BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(60, 4), IndirectSymbolTableCount); 1126BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(64, 4), ExternalRelocationTableOffset); 1127BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(68, 4), ExternalRelocationTableCount); 1128BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(72, 4), LocalRelocationTableOffset); 1129BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(76, 4), LocalRelocationTableCount); 1147BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(0, 4), LC_BUILD_VERSION); 1148BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(4, 4), (uint)HeaderSize); 1149BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(8, 4), Platform); 1150BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(12, 4), MinimumPlatformVersion); 1151BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(16, 4), SdkVersion); 1152BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(20, 4), 0); // No tools
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\PEObjectWriter.cs (1)
882BinaryPrimitives.WriteUInt32LittleEndian(timestamp, BlobContentId.FromHash(hash.ToArray()).Stamp);
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\WasmObjectWriter.cs (2)
761BinaryPrimitives.WriteUInt32LittleEndian(lengthBuffer, (uint)_webcilSegment.GetFlatMappedSize()); 762BinaryPrimitives.WriteUInt32LittleEndian(lengthBuffer.AsSpan().Slice(4), (uint)_uniqueSymbols.Count);
src\runtime\src\coreclr\tools\Common\Compiler\ObjectWriter\WebcilEncoder.cs (14)
47BinaryPrimitives.WriteUInt32LittleEndian(headerBuffer.Slice(0, 4), header.Id); 48BinaryPrimitives.WriteUInt16LittleEndian(headerBuffer.Slice(4, 2), header.VersionMajor); 49BinaryPrimitives.WriteUInt16LittleEndian(headerBuffer.Slice(6, 2), header.VersionMinor); 50BinaryPrimitives.WriteUInt16LittleEndian(headerBuffer.Slice(8, 2), header.CoffSections); 51BinaryPrimitives.WriteUInt16LittleEndian(headerBuffer.Slice(10, 2), header.Reserved0); 52BinaryPrimitives.WriteUInt32LittleEndian(headerBuffer.Slice(12, 4), header.PeCliHeaderRva); 53BinaryPrimitives.WriteUInt32LittleEndian(headerBuffer.Slice(16, 4), header.PeCliHeaderSize); 54BinaryPrimitives.WriteUInt32LittleEndian(headerBuffer.Slice(20, 4), header.PeDebugRva); 55BinaryPrimitives.WriteUInt32LittleEndian(headerBuffer.Slice(24, 4), header.PeDebugSize); 61BinaryPrimitives.WriteUInt32LittleEndian(headerBuffer.Slice(28, 4), 0); 82BinaryPrimitives.WriteUInt32LittleEndian(header.Slice(0, 4), sectionHeader.VirtualSize); 83BinaryPrimitives.WriteUInt32LittleEndian(header.Slice(4, 4), sectionHeader.VirtualAddress); 84BinaryPrimitives.WriteUInt32LittleEndian(header.Slice(8, 4), sectionHeader.SizeOfRawData); 85BinaryPrimitives.WriteUInt32LittleEndian(header.Slice(12, 4), sectionHeader.PointerToRawData);
src\runtime\src\coreclr\tools\Common\Pgo\PgoFormat.cs (2)
167signedInt = BinaryPrimitives.ReadInt64BigEndian(bytes.AsSpan(offset + 1, sizeof(long))); 172signedInt = BinaryPrimitives.ReadInt32BigEndian(bytes.AsSpan(offset + 1, sizeof(int)));
src\runtime\src\coreclr\tools\Common\TypeSystem\IL\ILReader.cs (6)
44if (!BinaryPrimitives.TryReadUInt16LittleEndian(_ilBytes.Slice(_currentOffset), out ushort value)) 53if (!BinaryPrimitives.TryReadUInt32LittleEndian(_ilBytes.Slice(_currentOffset), out uint value)) 67if (!BinaryPrimitives.TryReadUInt64LittleEndian(_ilBytes.Slice(_currentOffset), out ulong value)) 76if (!BinaryPrimitives.TryReadSingleLittleEndian(_ilBytes.Slice(_currentOffset), out float value)) 85if (!BinaryPrimitives.TryReadDoubleLittleEndian(_ilBytes.Slice(_currentOffset), out double value)) 118if (!BinaryPrimitives.TryReadInt32LittleEndian(_ilBytes.Slice(_currentOffset), out int value))
ILCompiler.RyuJit (6)
src\runtime\src\coreclr\tools\Common\TypeSystem\IL\ILReader.cs (6)
44if (!BinaryPrimitives.TryReadUInt16LittleEndian(_ilBytes.Slice(_currentOffset), out ushort value)) 53if (!BinaryPrimitives.TryReadUInt32LittleEndian(_ilBytes.Slice(_currentOffset), out uint value)) 67if (!BinaryPrimitives.TryReadUInt64LittleEndian(_ilBytes.Slice(_currentOffset), out ulong value)) 76if (!BinaryPrimitives.TryReadSingleLittleEndian(_ilBytes.Slice(_currentOffset), out float value)) 85if (!BinaryPrimitives.TryReadDoubleLittleEndian(_ilBytes.Slice(_currentOffset), out double value)) 118if (!BinaryPrimitives.TryReadInt32LittleEndian(_ilBytes.Slice(_currentOffset), out int value))
ILCompiler.TypeSystem (15)
src\runtime\src\coreclr\tools\Common\TypeSystem\IL\ILDisassembler.cs (3)
195ushort val = BinaryPrimitives.ReadUInt16LittleEndian(_ilBytes.AsSpan(_currentOffset, sizeof(ushort))); 202uint val = BinaryPrimitives.ReadUInt32LittleEndian(_ilBytes.AsSpan(_currentOffset, sizeof(uint))); 215ulong value = BinaryPrimitives.ReadUInt64LittleEndian(_ilBytes.AsSpan(_currentOffset, sizeof(ulong)));
src\runtime\src\coreclr\tools\Common\TypeSystem\IL\ILReader.cs (6)
44if (!BinaryPrimitives.TryReadUInt16LittleEndian(_ilBytes.Slice(_currentOffset), out ushort value)) 53if (!BinaryPrimitives.TryReadUInt32LittleEndian(_ilBytes.Slice(_currentOffset), out uint value)) 67if (!BinaryPrimitives.TryReadUInt64LittleEndian(_ilBytes.Slice(_currentOffset), out ulong value)) 76if (!BinaryPrimitives.TryReadSingleLittleEndian(_ilBytes.Slice(_currentOffset), out float value)) 85if (!BinaryPrimitives.TryReadDoubleLittleEndian(_ilBytes.Slice(_currentOffset), out double value)) 118if (!BinaryPrimitives.TryReadInt32LittleEndian(_ilBytes.Slice(_currentOffset), out int value))
src\runtime\src\coreclr\tools\Common\TypeSystem\IL\ILTokenReplacer.cs (2)
35int token = BinaryPrimitives.ReadInt32LittleEndian(tokenSpan); 37BinaryPrimitives.WriteInt32LittleEndian(tokenSpan, alternateToken);
src\runtime\src\coreclr\tools\Common\TypeSystem\IL\Stubs\ILEmitter.cs (4)
63BinaryPrimitives.WriteUInt16LittleEndian(_instructions.AsSpan(_length, sizeof(ushort)), value); 72BinaryPrimitives.WriteInt32LittleEndian(_instructions.AsSpan(_length, sizeof(int)), value); 484int delta = BinaryPrimitives.ReadInt32LittleEndian(offsetSpan); 488BinaryPrimitives.WriteInt32LittleEndian(offsetSpan, value);
Microsoft.AspNetCore.Components.Endpoints (2)
CacheView\CacheViewKeyResolver.cs (2)
255System.Buffers.Binary.BinaryPrimitives.WriteInt32BigEndian(buffer, value); 263System.Buffers.Binary.BinaryPrimitives.WriteInt32BigEndian(lengthPrefix, byteCount);
Microsoft.AspNetCore.Components.Server (3)
src\aspnetcore\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);
Microsoft.AspNetCore.DataProtection (5)
KeyManagement\KeyRingBasedDataProtector.cs (3)
213var magicHeaderFromPayload = BinaryPrimitives.ReadUInt32BigEndian(protectedData.AsSpan(0, sizeof(uint))); 393BinaryPrimitives.WriteUInt32BigEndian(targetSpan.Slice(0), MAGIC_HEADER_V0); 396BinaryPrimitives.WriteInt32BigEndian(targetSpan.Slice(4 + keySize), targetLength);
KeyManagement\KeyRingBasedSpanDataProtector.cs (2)
51BinaryPrimitives.WriteUInt32BigEndian(headerBuffer.Slice(0, sizeof(uint)), MAGIC_HEADER_V0); 101var magicHeaderFromPayload = BinaryPrimitives.ReadUInt32BigEndian(protectedData.Slice(0, sizeof(uint)));
Microsoft.AspNetCore.Identity (2)
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);
Microsoft.AspNetCore.Razor.Utilities.Shared (12)
Utilities\Checksum.Builder.cs (3)
90BinaryPrimitives.WriteUInt16LittleEndian(buffer, value); 97BinaryPrimitives.WriteInt32LittleEndian(buffer, value); 104BinaryPrimitives.WriteInt64LittleEndian(buffer, value);
Utilities\Hashing\XxHash128.cs (5)
223low = BinaryPrimitives.ReverseEndianness(low); 224high = BinaryPrimitives.ReverseEndianness(high); 268uint combinedh = RuntimeBitOperations.RotateLeft(BinaryPrimitives.ReverseEndianness(combinedl), 13); 284seed ^= (ulong)BinaryPrimitives.ReverseEndianness((uint)seed) << 32; 322m128Low ^= BinaryPrimitives.ReverseEndianness(m128High);
Utilities\Hashing\XxHashShared.cs (4)
160static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 794BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 800BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 807value = BinaryPrimitives.ReverseEndianness(value);
Microsoft.AspNetCore.Server.Kestrel.Core (26)
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\aspnetcore\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\aspnetcore\src\Shared\ServerInfrastructure\Http2\Bitshifter.cs (2)
34return BinaryPrimitives.ReadUInt32BigEndian(source) & 0x7F_FF_FF_FF; 53BinaryPrimitives.WriteUInt32BigEndian(destination, value);
src\aspnetcore\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));
Microsoft.Build (2)
BackEnd\Client\MSBuildClientPacketPump.cs (1)
269int packetLength = BinaryPrimitives.ReadInt32LittleEndian(new Span<byte>(headerByte, 1, 4));
BackEnd\Components\Communications\NodeProviderOutOfProcBase.cs (1)
1123int packetLength = BinaryPrimitives.ReadInt32LittleEndian(new Span<byte>(_headerByte, 1, 4));
Microsoft.Build.Tasks.Core (2)
src\msbuild\src\Shared\NodePipeBase.cs (2)
124int packetLength = BinaryPrimitives.ReadInt32LittleEndian(new Span<byte>(_headerData, 1, 4)); 174int packetLength = BinaryPrimitives.ReadInt32LittleEndian(new Span<byte>(_headerData, 1, 4));
Microsoft.CodeAnalysis (16)
CryptographicHashProvider.cs (5)
280BinaryPrimitives.WriteInt32LittleEndian(span, bits[0]); 281BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4), bits[1]); 282BinaryPrimitives.WriteInt32LittleEndian(span.Slice(8), bits[2]); 283BinaryPrimitives.WriteInt32LittleEndian(span.Slice(12), bits[3]); 294BinaryPrimitives.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)
679BinaryPrimitives.ReverseEndianness(source: shortSpan, destination: shortSpan);
Microsoft.CodeAnalysis.Analyzers (10)
src\roslyn\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\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.AnalyzerUtilities (10)
src\roslyn\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\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.CodeStyle (10)
src\roslyn\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\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.CSharp (4)
Compilation\CSharpCompilation.cs (1)
2547BinaryPrimitives.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()),
Microsoft.CodeAnalysis.ResxSourceGenerator (10)
src\roslyn\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\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.CodeAnalysis.Workspaces (10)
src\roslyn\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\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
Microsoft.Diagnostics.DataContractReader.Contracts (12)
Contracts\Debugger\Debugger_1.cs (2)
203? BinaryPrimitives.ReadUInt32LittleEndian(slice) 204: BinaryPrimitives.ReadUInt32BigEndian(slice);
LinearReadCache.cs (2)
45? BinaryPrimitives.ReadUInt32LittleEndian(buffer) 46: BinaryPrimitives.ReadUInt32BigEndian(buffer);
src\runtime\src\coreclr\tools\aot\ILCompiler.Reflection.ReadyToRun\NativeReader.cs (8)
59return _littleEndian ? BinaryPrimitives.ReadInt64LittleEndian(bytes) : BinaryPrimitives.ReadInt64BigEndian(bytes); 73return _littleEndian ? BinaryPrimitives.ReadInt32LittleEndian(bytes) : BinaryPrimitives.ReadInt32BigEndian(bytes); 87return _littleEndian ? BinaryPrimitives.ReadUInt32LittleEndian(bytes) : BinaryPrimitives.ReadUInt32BigEndian(bytes); 101return _littleEndian ? BinaryPrimitives.ReadUInt16LittleEndian(bytes) : BinaryPrimitives.ReadUInt16BigEndian(bytes);
Microsoft.Diagnostics.NETCore.Client (9)
DiagnosticsClient\DiagnosticsClient.cs (1)
866uint hr = BinaryPrimitives.ReadUInt32LittleEndian(new ReadOnlySpan<byte>(responseMessage.Payload, 0, 4));
DiagnosticsClient\EventPipeSession.cs (1)
154ulong sessionId = BinaryPrimitives.ReadUInt64LittleEndian(new ReadOnlySpan<byte>(response.Value.Message.Payload, 0, 8));
DiagnosticsIpc\IpcAdvertise.cs (2)
73ulong pid = BinaryPrimitives.ReadUInt64LittleEndian(new ReadOnlySpan<byte>(buffer, index, 8)); 76ushort future = BinaryPrimitives.ReadUInt16LittleEndian(new ReadOnlySpan<byte>(buffer, index, 2));
DiagnosticsIpc\ProcessEnvironment.cs (2)
22helper.ExpectedSizeInBytes = BinaryPrimitives.ReadUInt32LittleEndian(new ReadOnlySpan<byte>(payload, 0, 4)); 23helper.Future = BinaryPrimitives.ReadUInt16LittleEndian(new ReadOnlySpan<byte>(payload, 4, 2));
DiagnosticsIpc\ProcessInfo.cs (2)
69uint version = BinaryPrimitives.ReadUInt32LittleEndian(new ReadOnlySpan<byte>(payload, index, 4)); 86processInfo.ProcessId = BinaryPrimitives.ReadUInt64LittleEndian(new ReadOnlySpan<byte>(payload, index, 8));
IpcHelpers.cs (1)
15int length = BinaryPrimitives.ReadInt32LittleEndian(new ReadOnlySpan<byte>(buffer, index, 4));
Microsoft.DotNet.Build.Tasks.Installers (36)
src\RpmHeader.cs (28)
78Tag = BinaryPrimitives.ReadInt32BigEndian(bytes), 79Type = (RpmHeaderEntryType)BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(4)), 80Offset = BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(8)), 81Count = BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(12)) 87BinaryPrimitives.WriteInt32BigEndian(bytes, entry.Tag); 88BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(4), (int)entry.Type); 89BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(8), entry.Offset); 90BinaryPrimitives.WriteInt32BigEndian(bytes.Slice(12), entry.Count); 112int numIndexEntries = BinaryPrimitives.ReadInt32BigEndian(stream.ReadExactly(4)); 113int numHeaderBytes = BinaryPrimitives.ReadInt32BigEndian(stream.ReadExactly(4)); 210contents.SetValue(BinaryPrimitives.ReadInt16BigEndian(store.AsSpan().Slice(offset.AlignUp(2), 2)), i); 215contents.SetValue(BinaryPrimitives.ReadInt32BigEndian(store.AsSpan().Slice(offset.AlignUp(4), 4)), i); 220contents.SetValue(BinaryPrimitives.ReadInt64BigEndian(store.AsSpan().Slice(offset.AlignUp(8), 8)), i); 240BinaryPrimitives.WriteInt32BigEndian(numIndexEntries, Entries.Count + 1); 251BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes, Convert.ToInt32(entry.Tag)); 252BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(4), (int)entry.Type); 255BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(8), (int)storeStream.Length); 260BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(12), binary.Count); 268BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(8), (int)storeStream.Length); 269BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(12), 1); 278BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(8), (int)storeStream.Length); 282BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(12), strings.Length); 304BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(8), (int)storeStream.Length); 308BinaryPrimitives.WriteInt32BigEndian(indexInfoBytes.AsSpan(12), contents.Length); 322BinaryPrimitives.WriteInt16BigEndian(tempBeBytes, (short)contents.GetValue(i)!); 326BinaryPrimitives.WriteInt32BigEndian(tempBeBytes, (int)contents.GetValue(i)!); 330BinaryPrimitives.WriteInt64BigEndian(tempBeBytes, (long)contents.GetValue(i)!); 365BinaryPrimitives.WriteInt32BigEndian(numHeaderBytes, (int)storeStream.Length);
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);
Microsoft.DotNet.HotReload.Watch (5)
src\sdk\src\Dotnet.Watch\HotReloadAgent.PipeRpc\StreamExtensions.cs (5)
46BinaryPrimitives.WriteInt32LittleEndian(buffer, value); 70BinaryPrimitives.WriteInt32LittleEndian(buffer, value.Length); 73BinaryPrimitives.WriteInt32LittleEndian(buffer.AsSpan((i + 1) * sizeof(int), sizeof(int)), value[i]); 133return BinaryPrimitives.ReadInt32LittleEndian(buffer); 193result[i] = BinaryPrimitives.ReadInt32LittleEndian(buffer.AsSpan(i * sizeof(int)));
Microsoft.Extensions.Caching.Hybrid (10)
Internal\DefaultHybridCache.L2.cs (2)
113BinaryPrimitives.WriteInt64LittleEndian(oversized, timestamp); 151timestamp = BinaryPrimitives.ReadInt64LittleEndian(buffer.AsSpan());
Internal\HybridCachePayload.cs (8)
106BinaryPrimitives.WriteUInt16LittleEndian(destination.AsSpan(0, 2), UInt16SentinelPrefixPair); 107BinaryPrimitives.WriteUInt16LittleEndian(destination.AsSpan(2, 2), (ushort)_entropySource.Next(0, 0x010000)); // Next is exclusive at RHS 108BinaryPrimitives.WriteInt64LittleEndian(destination.AsSpan(4, 8), creationTime); 140BinaryPrimitives.WriteUInt16LittleEndian(destination.AsSpan(len, 2), UInt16SentinelPrefixPair); 197switch (BinaryPrimitives.ReadUInt16LittleEndian(bytes)) 200entropy = BinaryPrimitives.ReadUInt16LittleEndian(bytes.Slice(2)); 201long creationTime = BinaryPrimitives.ReadInt64LittleEndian(bytes.Slice(4)); 294|| BinaryPrimitives.ReadUInt16LittleEndian(bytes.Slice(payloadLength)) != UInt16SentinelPrefixPair)
Microsoft.Extensions.DotNetDeltaApplier (5)
src\sdk\src\Dotnet.Watch\HotReloadAgent.PipeRpc\StreamExtensions.cs (5)
46BinaryPrimitives.WriteInt32LittleEndian(buffer, value); 70BinaryPrimitives.WriteInt32LittleEndian(buffer, value.Length); 73BinaryPrimitives.WriteInt32LittleEndian(buffer.AsSpan((i + 1) * sizeof(int), sizeof(int)), value[i]); 133return BinaryPrimitives.ReadInt32LittleEndian(buffer); 193result[i] = BinaryPrimitives.ReadInt32LittleEndian(buffer.AsSpan(i * sizeof(int)));
Microsoft.Extensions.ServiceDiscovery.Dns (26)
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)
28TransactionId = BinaryPrimitives.ReadUInt16BigEndian(buffer), 29QueryFlags = (QueryFlags)BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(2)), 30QueryCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(4)), 31AnswerCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(6)), 32AuthorityCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(8)), 33AdditionalRecordCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(10)) 49BinaryPrimitives.WriteUInt16BigEndian(buffer, header.TransactionId); 50BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(2), (ushort)header.QueryFlags); 51BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(4), header.QueryCount); 52BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(6), header.AnswerCount); 53BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(8), header.AuthorityCount); 54BinaryPrimitives.WriteUInt16BigEndian(buffer.Slice(10), header.AdditionalRecordCount); 276if (!BinaryPrimitives.TryReadUInt16BigEndian(buffer.Span, out priority) || 277!BinaryPrimitives.TryReadUInt16BigEndian(buffer.Span.Slice(2), out weight) || 278!BinaryPrimitives.TryReadUInt16BigEndian(buffer.Span.Slice(4), out port) || 298!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2), out serial) || 299!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 4), out refresh) || 300!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 8), out retry) || 301!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 12), out expire) || 302!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 16), out minimum))
Resolver\DnsResolver.cs (2)
772BinaryPrimitives.WriteUInt16BigEndian(buffer, (ushort)length); 793responseLength = BinaryPrimitives.ReadUInt16BigEndian(buffer.AsSpan(0, 2));
Microsoft.Extensions.ServiceDiscovery.Dns.Tests (10)
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))
Microsoft.NET.HostModel (15)
AppHost\PEUtils.cs (2)
140=> BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value); 143=> BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value);
ComHost\TypeLibReader.cs (5)
43int typelibGuidEntryOffset = (int)BinaryPrimitives.ReadUInt32LittleEndian(fileContents.Slice(OffsetOfGuidOffset)); 44int infoRefsOffsetCount = (int)BinaryPrimitives.ReadUInt32LittleEndian(fileContents.Slice(OffsetOfTypeInfosCount)); 47int fileOffset = (int)BinaryPrimitives.ReadUInt32LittleEndian(fileContents.Slice(guidTableOffset)); 60ushort majorVer = BinaryPrimitives.ReadUInt16LittleEndian(span.Slice(OffsetOfMajorVersion)); 61ushort minorVer = BinaryPrimitives.ReadUInt16LittleEndian(span.Slice(OffsetOfMinorVersion));
MachO\FileUtils\EndianConversionExtensions.cs (4)
13return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value; 18return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value; 23return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value; 28return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(value) : value;
MachO\FileUtils\StreamExtensions.cs (2)
21return BinaryPrimitives.ReadUInt32BigEndian(buffer); 36BinaryPrimitives.WriteUInt32BigEndian(buffer, value);
src\runtime\src\coreclr\tools\Common\MachO\MachMagicExtensions.cs (2)
22=> BinaryPrimitives.ReverseEndianness(value), 34=> BinaryPrimitives.ReverseEndianness(value),
mscorlib (1)
mscorlib.cs (1)
49[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.Binary.BinaryPrimitives))]
netstandard (1)
netstandard.cs (1)
61[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.Binary.BinaryPrimitives))]
Roslyn.Diagnostics.Analyzers (10)
src\roslyn\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\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\InterceptsLocationUtilities.cs (1)
104var position = BinaryPrimitives.ReadInt32LittleEndian(bytes[PositionIndex..]);
System.Console (1)
System\TermInfo.Database.cs (1)
291=> BinaryPrimitives.ReadInt32LittleEndian(buffer.AsSpan(pos));
System.Diagnostics.DiagnosticSource (3)
System\Diagnostics\Activity.cs (3)
2041span[0] = BinaryPrimitives.ReverseEndianness(span[0]); 2042span[1] = BinaryPrimitives.ReverseEndianness(span[1]); 2198id = BinaryPrimitives.ReverseEndianness(id);
System.Diagnostics.Process (1)
System\Diagnostics\Process.Multiplexing.cs (1)
215ushort firstTwoBytes = BinaryPrimitives.ReadUInt16LittleEndian(byteBuffer);
System.Formats.Asn1 (4)
System\Formats\Asn1\AsnCharacterStringEncodings.cs (1)
334char 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 (14)
System\Formats\Cbor\CborHelpers.netcoreapp.cs (5)
29=> BinaryPrimitives.ReadHalfBigEndian(source); 33=> BinaryPrimitives.ReadSingleBigEndian(source); 37=> BinaryPrimitives.ReadDoubleBigEndian(source); 41=> BinaryPrimitives.WriteSingleBigEndian(destination, value); 45=> 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 (3)
System\Formats\Nrbf\ArraySinglePrimitiveRecord.cs (3)
166BinaryPrimitives.ReverseEndianness(span, span); 178BinaryPrimitives.ReverseEndianness(span, span); 190BinaryPrimitives.ReverseEndianness(span, span);
System.Formats.Tar (3)
System\Formats\Tar\TarHeader.Write.cs (3)
871BinaryPrimitives.WriteInt64BigEndian(destination, destinationValue); 895BinaryPrimitives.WriteUInt32BigEndian(destination, value < 0 ? 0xffffffff : 0x80000000); 896BinaryPrimitives.WriteInt64BigEndian(destination.Slice(Offset), value);
System.IO.Compression (122)
System\IO\Compression\WinZipAesStream.cs (1)
315BinaryPrimitives.WriteUInt128LittleEndian(_keystreamBuffer.AsSpan(i, BlockSize), _counter);
System\IO\Compression\ZipArchiveEntry.Async.cs (1)
922BinaryPrimitives.WriteUInt16LittleEndian(flagBytes, (ushort)savedFlags);
System\IO\Compression\ZipArchiveEntry.cs (39)
866BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.VersionNeededToExtract..], (ushort)_versionToExtract); 867BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.GeneralPurposeBitFlags..], (ushort)_generalPurposeBitFlag); 872BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.CompressionMethod..], compressionMethodToWrite); 874BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.LastModified..], ZipHelper.DateTimeToDosTime(_lastModified.DateTime)); 877BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.Crc32..], crcToWrite); 878BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.CompressedSize..], compressedSizeTruncated); 879BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.UncompressedSize..], uncompressedSizeTruncated); 880BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.FilenameLength..], (ushort)_storedEntryNameBytes.Length); 881BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.ExtraFieldLength..], extraFieldLength); 882BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.FileCommentLength..], (ushort)_fileComment.Length); 883BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.DiskNumberStart..], 0); 884BinaryPrimitives.WriteUInt16LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.InternalFileAttributes..], 0); 885BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.ExternalFileAttributes..], _externalFileAttr); 886BinaryPrimitives.WriteUInt32LittleEndian(cdStaticHeader[ZipCentralDirectoryFileHeader.FieldLocations.RelativeOffsetOfLocalHeader..], offsetOfLocalHeaderTruncated); 1729BinaryPrimitives.WriteUInt16LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.VersionNeededToExtract..], (ushort)_versionToExtract); 1730BinaryPrimitives.WriteUInt16LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.GeneralPurposeBitFlags..], (ushort)_generalPurposeBitFlag); 1734BinaryPrimitives.WriteUInt16LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.CompressionMethod..], compressionMethodToWrite); 1736BinaryPrimitives.WriteUInt32LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.LastModified..], ZipHelper.DateTimeToDosTime(_lastModified.DateTime)); 1737BinaryPrimitives.WriteUInt32LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.Crc32..], crc32); 1738BinaryPrimitives.WriteUInt32LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.CompressedSize..], compressedSizeTruncated); 1739BinaryPrimitives.WriteUInt32LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.UncompressedSize..], uncompressedSizeTruncated); 1740BinaryPrimitives.WriteUInt16LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.FilenameLength..], (ushort)_storedEntryNameBytes.Length); 1741BinaryPrimitives.WriteUInt16LittleEndian(lfStaticHeader[ZipLocalFileHeader.FieldLocations.ExtraFieldLength..], extraFieldLength); 1931BinaryPrimitives.WriteUInt16LittleEndian(flagBytes, (ushort)savedFlags); 2063BinaryPrimitives.WriteUInt16LittleEndian(writeBuffer[relativeVersionToExtractLocation..], (ushort)_versionToExtract); 2064BinaryPrimitives.WriteUInt16LittleEndian(writeBuffer[relativeGeneralPurposeBitFlagsLocation..], (ushort)_generalPurposeBitFlag); 2078BinaryPrimitives.WriteUInt32LittleEndian(writeBuffer[relativeCrc32Location..], crcToWrite); 2079BinaryPrimitives.WriteUInt32LittleEndian(writeBuffer[relativeCompressedSizeLocation..], compressedSizeTruncated); 2080BinaryPrimitives.WriteUInt32LittleEndian(writeBuffer[relativeUncompressedSizeLocation..], uncompressedSizeTruncated); 2096BinaryPrimitives.WriteInt64LittleEndian(writeBuffer[relativeUncompressedSizeLocation..], _uncompressedSize); 2097BinaryPrimitives.WriteInt64LittleEndian(writeBuffer[relativeCompressedSizeLocation..], _compressedSize); 2107BinaryPrimitives.WriteUInt32LittleEndian(writeBuffer.Slice(relativeCrc32Location), crcToWrite); 2108BinaryPrimitives.WriteInt64LittleEndian(writeBuffer.Slice(relativeCompressedSizeLocation), _compressedSize); 2109BinaryPrimitives.WriteInt64LittleEndian(writeBuffer.Slice(relativeUncompressedSizeLocation), _uncompressedSize); 2134BinaryPrimitives.WriteUInt32LittleEndian(dataDescriptor[ZipLocalFileHeader.ZipDataDescriptor.FieldLocations.Crc32..], crcToWrite); 2138BinaryPrimitives.WriteInt64LittleEndian(dataDescriptor[ZipLocalFileHeader.Zip64DataDescriptor.FieldLocations.CompressedSize..], _compressedSize); 2139BinaryPrimitives.WriteInt64LittleEndian(dataDescriptor[ZipLocalFileHeader.Zip64DataDescriptor.FieldLocations.UncompressedSize..], _uncompressedSize); 2145BinaryPrimitives.WriteUInt32LittleEndian(dataDescriptor[ZipLocalFileHeader.ZipDataDescriptor.FieldLocations.CompressedSize..], (uint)_compressedSize); 2146BinaryPrimitives.WriteUInt32LittleEndian(dataDescriptor[ZipLocalFileHeader.ZipDataDescriptor.FieldLocations.UncompressedSize..], (uint)_uncompressedSize);
System\IO\Compression\ZipBlocks.cs (79)
40BinaryPrimitives.WriteUInt16LittleEndian(extraFieldHeader[FieldLocations.Tag..], _tag); 41BinaryPrimitives.WriteUInt16LittleEndian(extraFieldHeader[FieldLocations.Size..], _size); 56field._tag = BinaryPrimitives.ReadUInt16LittleEndian(bytes[FieldLocations.Tag..]); 57field._size = BinaryPrimitives.ReadUInt16LittleEndian(bytes[FieldLocations.Size..]); 309zip64Block._uncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(data); 328zip64Block._compressedSize = BinaryPrimitives.ReadInt64LittleEndian(data); 347zip64Block._localHeaderOffset = BinaryPrimitives.ReadInt64LittleEndian(data); 366zip64Block._startDiskNumber = BinaryPrimitives.ReadUInt32LittleEndian(data); 416BinaryPrimitives.WriteUInt16LittleEndian(extraFieldData[FieldLocations.Tag..], TagConstant); 417BinaryPrimitives.WriteUInt16LittleEndian(extraFieldData[FieldLocations.Size..], _size); 421BinaryPrimitives.WriteInt64LittleEndian(extraFieldData[startOffset..], _uncompressedSize.Value); 427BinaryPrimitives.WriteInt64LittleEndian(extraFieldData[startOffset..], _compressedSize.Value); 433BinaryPrimitives.WriteInt64LittleEndian(extraFieldData[startOffset..], _localHeaderOffset.Value); 439BinaryPrimitives.WriteUInt32LittleEndian(extraFieldData[startOffset..], _startDiskNumber.Value); 474NumberOfDiskWithZip64EOCD = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.NumberOfDiskWithZip64EOCD..]), 475OffsetOfZip64EOCD = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.OffsetOfZip64EOCD..]), 476TotalNumberOfDisks = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.TotalNumberOfDisks..]) 497BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.NumberOfDiskWithZip64EOCD..], 0); 498BinaryPrimitives.WriteInt64LittleEndian(blockContents[FieldLocations.OffsetOfZip64EOCD..], zip64EOCDRecordStart); 500BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.TotalNumberOfDisks..], 1); 547SizeOfThisRecord = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.SizeOfThisRecord..]), 548VersionMadeBy = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.VersionMadeBy..]), 549VersionNeededToExtract = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.VersionNeededToExtract..]), 550NumberOfThisDisk = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.NumberOfThisDisk..]), 551NumberOfDiskWithStartOfCD = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.NumberOfDiskWithStartOfCD..]), 552NumberOfEntriesOnThisDisk = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.NumberOfEntriesOnThisDisk..]), 553NumberOfEntriesTotal = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.NumberOfEntriesTotal..]), 554SizeOfCentralDirectory = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.SizeOfCentralDirectory..]), 555OffsetOfCentralDirectory = BinaryPrimitives.ReadUInt64LittleEndian(blockContents[FieldLocations.OffsetOfCentralDirectory..]) 576BinaryPrimitives.WriteUInt64LittleEndian(blockContents[FieldLocations.SizeOfThisRecord..], NormalSize); 578BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.VersionMadeBy..], (ushort)ZipVersionNeededValues.Zip64); 580BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.VersionNeededToExtract..], (ushort)ZipVersionNeededValues.Zip64); 582BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.NumberOfThisDisk..], 0); 584BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.NumberOfDiskWithStartOfCD..], 0); 586BinaryPrimitives.WriteInt64LittleEndian(blockContents[FieldLocations.NumberOfEntriesOnThisDisk..], numberOfEntries); 588BinaryPrimitives.WriteInt64LittleEndian(blockContents[FieldLocations.NumberOfEntriesTotal..], numberOfEntries); 589BinaryPrimitives.WriteInt64LittleEndian(blockContents[FieldLocations.SizeOfCentralDirectory..], sizeOfCentralDirectory); 590BinaryPrimitives.WriteInt64LittleEndian(blockContents[FieldLocations.OffsetOfCentralDirectory..], startOfCentralDirectory); 619filenameLength = BinaryPrimitives.ReadUInt16LittleEndian(fixedHeaderBuffer[relativeFilenameLengthLocation..]); 620extraFieldLength = BinaryPrimitives.ReadUInt16LittleEndian(fixedHeaderBuffer[relativeExtraFieldLengthLocation..]); 687ushort filenameLength = BinaryPrimitives.ReadUInt16LittleEndian(blockBytes[relativeFilenameLengthLocation..]); 688ushort extraFieldLength = BinaryPrimitives.ReadUInt16LittleEndian(blockBytes[relativeExtraFieldLengthLocation..]); 778ushort headerId = BinaryPrimitives.ReadUInt16LittleEndian(extraFieldData); 779ushort fieldSize = BinaryPrimitives.ReadUInt16LittleEndian(extraFieldData.Slice(2)); 810ushort vendorVersion = BinaryPrimitives.ReadUInt16LittleEndian(data); 825compressionMethod: BinaryPrimitives.ReadUInt16LittleEndian(data.Slice(5, 2)) 846BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(0), HeaderId); 847BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(2), DataSize); 848BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(4), VendorVersion); 852BinaryPrimitives.WriteUInt16LittleEndian(buffer.Slice(9), CompressionMethod); 917VersionNeededToExtract = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.VersionNeededToExtract..]), 918GeneralPurposeBitFlag = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.GeneralPurposeBitFlags..]), 919CompressionMethod = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.CompressionMethod..]), 920LastModified = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.LastModified..]), 921Crc32 = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.Crc32..]), 922FilenameLength = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.FilenameLength..]), 923ExtraFieldLength = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.ExtraFieldLength..]), 924FileCommentLength = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.FileCommentLength..]), 925InternalFileAttributes = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.InternalFileAttributes..]), 926ExternalFileAttributes = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.ExternalFileAttributes..]) 929compressedSizeSmall = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.CompressedSize..]); 930uncompressedSizeSmall = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.UncompressedSize..]); 931diskNumberStartSmall = BinaryPrimitives.ReadUInt16LittleEndian(buffer[FieldLocations.DiskNumberStart..]); 932relativeOffsetOfLocalHeaderSmall = BinaryPrimitives.ReadUInt32LittleEndian(buffer[FieldLocations.RelativeOffsetOfLocalHeader..]); 1082BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.NumberOfThisDisk..], 0); 1084BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.NumberOfTheDiskWithTheStartOfTheCentralDirectory..], 0); 1086BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.NumberOfEntriesInTheCentralDirectoryOnThisDisk..], numberOfEntriesTruncated); 1088BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.NumberOfEntriesInTheCentralDirectory..], numberOfEntriesTruncated); 1089BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.SizeOfCentralDirectory..], sizeOfCentralDirectoryTruncated); 1090BinaryPrimitives.WriteUInt32LittleEndian(blockContents[FieldLocations.OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber..], startOfCentralDirectoryTruncated); 1096BinaryPrimitives.WriteUInt16LittleEndian(blockContents[FieldLocations.ArchiveCommentLength..], (ushort)archiveComment.Length); 1128Signature = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.Signature..]), 1129NumberOfThisDisk = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.NumberOfThisDisk..]), 1130NumberOfTheDiskWithTheStartOfTheCentralDirectory = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.NumberOfTheDiskWithTheStartOfTheCentralDirectory..]), 1131NumberOfEntriesInTheCentralDirectoryOnThisDisk = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.NumberOfEntriesInTheCentralDirectoryOnThisDisk..]), 1132NumberOfEntriesInTheCentralDirectory = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.NumberOfEntriesInTheCentralDirectory..]), 1133SizeOfCentralDirectory = BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.SizeOfCentralDirectory..]), 1135BinaryPrimitives.ReadUInt32LittleEndian(blockContents[FieldLocations.OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber..]) 1138ushort commentLength = BinaryPrimitives.ReadUInt16LittleEndian(blockContents[FieldLocations.ArchiveCommentLength..]);
System\IO\Compression\ZipCryptoStream.cs (2)
159BinaryPrimitives.WriteUInt16LittleEndian(header.Slice(10), (ushort)(crc >> 16)); 163BinaryPrimitives.WriteUInt16LittleEndian(header.Slice(10), _verifierLow2Bytes);
System.IO.Hashing (42)
System\IO\Hashing\Adler32.cs (5)
82=> BinaryPrimitives.WriteUInt32BigEndian(destination, _adler); 90BinaryPrimitives.WriteUInt32BigEndian(destination, _adler); 127BinaryPrimitives.WriteUInt32BigEndian(ret, hash); 152BinaryPrimitives.WriteUInt32BigEndian(destination, hash); 173BinaryPrimitives.WriteUInt32BigEndian(destination, hash);
System\IO\Hashing\Crc32ParameterSet.cs (3)
78BinaryPrimitives.WriteUInt32LittleEndian(destination, crc); 82BinaryPrimitives.WriteUInt32BigEndian(destination, crc); 112return BinaryPrimitives.ReverseEndianness(value);
System\IO\Hashing\Crc32ParameterSet.WellKnown.cs (4)
144BinaryPrimitives.ReadUInt64LittleEndian(source)); 166BinaryPrimitives.ReadUInt32LittleEndian(source)); 203ulong value = BinaryPrimitives.ReadUInt64LittleEndian(source); 211uint value = BinaryPrimitives.ReadUInt32LittleEndian(source);
System\IO\Hashing\Crc64ParameterSet.cs (3)
78BinaryPrimitives.WriteUInt64LittleEndian(destination, crc); 82BinaryPrimitives.WriteUInt64BigEndian(destination, crc); 112return BinaryPrimitives.ReverseEndianness(value);
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)
157static ulong ReadLE64(ulong data) => BitConverter.IsLittleEndian ? data : BinaryPrimitives.ReverseEndianness(data); 800BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<uint>(data)); 806BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ulong>(data)); 813value = BinaryPrimitives.ReverseEndianness(value);
System.Memory (4)
src\runtime\artifacts\obj\System.Memory\Release\net11.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);
System.Net.Http (26)
src\runtime\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)
214BinaryPrimitives.WriteUInt16BigEndian(_outgoingBuffer.AvailableSpan, (ushort)SettingId.EnablePush); 216BinaryPrimitives.WriteUInt32BigEndian(_outgoingBuffer.AvailableSpan, 0); 218BinaryPrimitives.WriteUInt16BigEndian(_outgoingBuffer.AvailableSpan, (ushort)SettingId.InitialWindowSize); 220BinaryPrimitives.WriteUInt32BigEndian(_outgoingBuffer.AvailableSpan, (uint)_pool.Settings._initialHttp2StreamWindowSize); 230BinaryPrimitives.WriteUInt32BigEndian(_outgoingBuffer.AvailableSpan, windowUpdateAmount); 763if (BinaryPrimitives.TryReadUInt16BigEndian(span, out ushort originLength)) 854ushort settingId = BinaryPrimitives.ReadUInt16BigEndian(settings); 856uint settingValue = BinaryPrimitives.ReadUInt32BigEndian(settings); 1004long pingContentLong = BinaryPrimitives.ReadInt64BigEndian(pingContent); 1028int amount = BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan) & 0x7FFFFFFF; 1078var protocolError = (Http2ProtocolErrorCode)BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan); 1136int lastStreamId = (int)(BinaryPrimitives.ReadUInt32BigEndian(_incomingBuffer.ActiveSpan) & 0x7FFFFFFF); 1137Http2ProtocolErrorCode errorCode = (Http2ProtocolErrorCode)BinaryPrimitives.ReadInt32BigEndian(_incomingBuffer.ActiveSpan.Slice(sizeof(int))); 1331BinaryPrimitives.WriteInt64BigEndian(span.Slice(FrameHeader.Size), state.pingContent); 1346BinaryPrimitives.WriteInt32BigEndian(span.Slice(FrameHeader.Size), (int)s.errorCode); 1804BinaryPrimitives.WriteInt32BigEndian(span.Slice(FrameHeader.Size), s.amount); 1984int streamId = (int)(BinaryPrimitives.ReadUInt32BigEndian(buffer.Slice(5)) & 0x7FFFFFFF); 1997BinaryPrimitives.WriteInt32BigEndian(destination.Slice(5), streamId);
System\Net\Http\SocketsHttpHandler\SocksHelper.cs (2)
183BinaryPrimitives.WriteUInt16BigEndian(buffer.AsSpan(addressLength + 4), (ushort)port); 228BinaryPrimitives.WriteUInt16BigEndian(buffer.AsSpan(2), (ushort)port);
System.Net.Http.WinHttpHandler (1)
System\Net\Http\WinHttpRequestCallback.cs (1)
341AddressFamily.InterNetwork => new IPAddress(BinaryPrimitives.ReadUInt32LittleEndian(remoteAddressSpan.Slice(4))),
System.Net.NetworkInformation (1)
System\Net\NetworkInformation\PhysicalAddress.cs (1)
32hash ^= BinaryPrimitives.ReadInt32LittleEndian(_address.AsSpan(i));
System.Net.Primitives (10)
src\runtime\src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)
55return BinaryPrimitives.ReadInt32BigEndian(numbers);
System\Net\IPAddress.cs (5)
213numbers[i] = BinaryPrimitives.ReadUInt16BigEndian(address.Slice(i * 2)); 368BinaryPrimitives.WriteUInt16BigEndian(destination.Slice(i * 2), numbers[i]); 538return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host; 543return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host; 548return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(host) : host;
System\Net\IPNetwork.cs (4)
86mask = BinaryPrimitives.ReverseEndianness(mask); 104mask = BinaryPrimitives.ReverseEndianness(mask); 245mask = BinaryPrimitives.ReverseEndianness(mask); 269mask = BinaryPrimitives.ReverseEndianness(mask);
System.Net.Quic (1)
src\runtime\src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)
55return BinaryPrimitives.ReadInt32BigEndian(numbers);
System.Net.Security (38)
src\runtime\src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)
55return BinaryPrimitives.ReadInt32BigEndian(numbers);
src\runtime\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 (22)
135readonly get => BitConverter.IsLittleEndian ? _length : BinaryPrimitives.ReverseEndianness(_length); 136set => _length = BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value); 140readonly get => BitConverter.IsLittleEndian ? _maximumLength : BinaryPrimitives.ReverseEndianness(_maximumLength); 141set => _maximumLength = BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value); 145readonly get => BitConverter.IsLittleEndian ? _payloadOffset : BinaryPrimitives.ReverseEndianness(_payloadOffset); 146set => _payloadOffset = BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value); 178readonly get => BitConverter.IsLittleEndian ? _productBuild : BinaryPrimitives.ReverseEndianness(_productBuild); 179set => _productBuild = BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value); 194readonly get => BitConverter.IsLittleEndian ? _flags : (Flags)BinaryPrimitives.ReverseEndianness((uint)_flags); 195set => _flags = BitConverter.IsLittleEndian ? value : (Flags)BinaryPrimitives.ReverseEndianness((uint)value); 219readonly get => BitConverter.IsLittleEndian ? _flags : (Flags)BinaryPrimitives.ReverseEndianness((uint)_flags); 220set => _flags = BitConverter.IsLittleEndian ? value : (Flags)BinaryPrimitives.ReverseEndianness((uint)value); 247readonly get => BitConverter.IsLittleEndian ? _flags : (Flags)BinaryPrimitives.ReverseEndianness((uint)_flags); 248set => _flags = BitConverter.IsLittleEndian ? value : (Flags)BinaryPrimitives.ReverseEndianness((uint)value); 268readonly get => BitConverter.IsLittleEndian ? _time : BinaryPrimitives.ReverseEndianness(_time); 269set => _time = BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value); 496BinaryPrimitives.WriteInt32LittleEndian(prefix.Slice(sizeof(uint) * 4), cbtDataSize); 555time = DateTime.FromFileTimeUtc(BinaryPrimitives.ReadInt64LittleEndian(info.Slice(4, 8))); 586BinaryPrimitives.WriteUInt16LittleEndian(targetInfoBuffer.AsSpan(2 + targetInfoOffset), (ushort)spnSize); 796BinaryPrimitives.WriteInt32LittleEndian(signature, 1); 797BinaryPrimitives.WriteUInt32LittleEndian(signature.Slice(12), sequenceNumber); 812BinaryPrimitives.ReadInt32LittleEndian(signature) != 1 ||
System\Net\Security\NegotiateStream.cs (5)
373readBytes = BinaryPrimitives.ReadInt32LittleEndian(_readHeader); 552BinaryPrimitives.WriteInt32LittleEndian(_writeHeader, _writeBuffer.WrittenCount); 787BinaryPrimitives.WriteInt64LittleEndian(message, ERROR_TRUST_FAILURE); 847BinaryPrimitives.WriteInt64LittleEndian(message, errorCode); 885long error = BinaryPrimitives.ReadInt64LittleEndian(message);
System\Net\Security\TlsFrameHelper.cs (8)
446int extensionListLength = BinaryPrimitives.ReadUInt16BigEndian(p); 489int extensionListLength = BinaryPrimitives.ReadUInt16BigEndian(p); 507ExtensionType extensionType = (ExtensionType)BinaryPrimitives.ReadUInt16BigEndian(extensions); 510ushort extensionLength = BinaryPrimitives.ReadUInt16BigEndian(extensions); 578int serverNameListLength = BinaryPrimitives.ReadUInt16BigEndian(serverNameListExtension); 635int hostNameLength = BinaryPrimitives.ReadUInt16BigEndian(hostNameStruct); 710int AlpnListLength = BinaryPrimitives.ReadUInt16BigEndian(extensionData); 846ushort length = BinaryPrimitives.ReadUInt16BigEndian(bytes);
System.Net.WebSockets (8)
System\Net\WebSockets\ManagedWebSocket.cs (7)
738BinaryPrimitives.WriteUInt16BigEndian(sendBuffer.AsSpan(2), (ushort)payload.Length); 744BinaryPrimitives.WriteUInt64BigEndian(sendBuffer.AsSpan(2), (ulong)payload.Length); 1103closeStatus = (WebSocketCloseStatus)BinaryPrimitives.ReadUInt16BigEndian(_receiveBuffer.Span.Slice(_receiveBufferOffset)); 1223long pongPayload = BinaryPrimitives.ReadInt64BigEndian(_receiveBuffer.Span.Slice(_receiveBufferOffset, (int)header.PayloadLength)); 1334header.PayloadLength = BinaryPrimitives.ReadUInt16BigEndian(receiveBufferSpan.Slice(_receiveBufferOffset)); 1340header.PayloadLength = BinaryPrimitives.ReadInt64BigEndian(receiveBufferSpan.Slice(_receiveBufferOffset)); 1565BinaryPrimitives.WriteUInt16BigEndian(buffer, (ushort)closeStatus);
System\Net\WebSockets\ManagedWebSocket.KeepAlive.cs (1)
118BinaryPrimitives.WriteInt64BigEndian(pingPayloadBuffer, pingPayload);
System.Private.CoreLib (182)
src\runtime\src\libraries\Common\src\System\Sha1ForNonSecretPurposes.cs (5)
41w[i] = BinaryPrimitives.ReadUInt32BigEndian(source); 55BinaryPrimitives.WriteUInt64BigEndian(tail.Slice(pos), (ulong)originalLength * 8); 62w[i] = BinaryPrimitives.ReadUInt32BigEndian(tail); 70BinaryPrimitives.WriteUInt32BigEndian(destination, w[i]); 159BinaryPrimitives.WriteUInt32BigEndian(output, _w[i]);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Boolean.cs (1)
34int dw = BinaryPrimitives.ReadInt32LittleEndian(source) & ~0x20202020;
src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Char.cs (4)
1275result = (char)BinaryPrimitives.ReadUInt16BigEndian(source.Slice(source.Length - sizeof(char))); 1316result = (char)BinaryPrimitives.ReadUInt16LittleEndian(source); 1338if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, m_value)) 1351if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, m_value))
src\runtime\src\libraries\System.Private.CoreLib\src\System\Collections\BitArray.cs (4)
99BinaryPrimitives.ReverseEndianness(array, MemoryMarshal.Cast<byte, int>((Span<byte>)_array)); 261BinaryPrimitives.ReverseEndianness(values, MemoryMarshal.Cast<byte, int>((Span<byte>)_array)); 698BinaryPrimitives.ReverseEndianness(source, intArray.AsSpan(index)); 960BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Decimal.cs (12)
626BinaryPrimitives.WriteInt32LittleEndian(buffer, (int)d.Low); 627BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(4), (int)d.Mid); 628BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(8), (int)d.High); 629BinaryPrimitives.WriteInt32LittleEndian(buffer.Slice(12), d._flags); 636int lo = BinaryPrimitives.ReadInt32LittleEndian(span); 637int mid = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(4)); 638int hi = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(8)); 639int flags = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(12)); 1172BinaryPrimitives.WriteUInt32BigEndian(destination, _hi32); 1173BinaryPrimitives.WriteUInt64BigEndian(destination.Slice(sizeof(uint)), _lo64); 1189BinaryPrimitives.WriteUInt64LittleEndian(destination, _lo64); 1190BinaryPrimitives.WriteUInt32LittleEndian(destination.Slice(sizeof(ulong)), _hi32);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (11)
33decodedFields[i] = BinaryPrimitives.ReadIntPtrLittleEndian(payload); 38decodedFields[i] = BinaryPrimitives.ReadInt32LittleEndian(payload); 43decodedFields[i] = BinaryPrimitives.ReadUInt32LittleEndian(payload); 48decodedFields[i] = BinaryPrimitives.ReadInt64LittleEndian(payload); 53decodedFields[i] = BinaryPrimitives.ReadUInt64LittleEndian(payload); 68decodedFields[i] = BinaryPrimitives.ReadInt16LittleEndian(payload); 73decodedFields[i] = BinaryPrimitives.ReadUInt16LittleEndian(payload); 78decodedFields[i] = BinaryPrimitives.ReadSingleLittleEndian(payload); 83decodedFields[i] = BinaryPrimitives.ReadDoubleLittleEndian(payload); 89decodedFields[i] = (BinaryPrimitives.ReadInt32LittleEndian(payload) == 1); 100decodedFields[i] = (char)BinaryPrimitives.ReadUInt16LittleEndian(payload);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Double.cs (4)
720if (BinaryPrimitives.TryWriteInt16BigEndian(destination, Exponent)) 738if (BinaryPrimitives.TryWriteInt16LittleEndian(destination, Exponent)) 756if (BinaryPrimitives.TryWriteUInt64BigEndian(destination, Significand)) 774if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination, Significand))
src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\CharUnicodeInfo.cs (7)
274temp = BinaryPrimitives.ReverseEndianness(temp); 289int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 308int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 324int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 343int delta = (BitConverter.IsLittleEndian) ? rsDelta : BinaryPrimitives.ReverseEndianness(rsDelta); 496index = BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ushort>(ref level2Ref)); 533index = BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ushort>(ref level2Ref));
src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Guid.cs (12)
77_a = BinaryPrimitives.ReverseEndianness(_a); 78_b = BinaryPrimitives.ReverseEndianness(_b); 79_c = BinaryPrimitives.ReverseEndianness(_c); 94_a = BinaryPrimitives.ReverseEndianness(_a); 95_b = BinaryPrimitives.ReverseEndianness(_b); 96_c = BinaryPrimitives.ReverseEndianness(_c); 254_a = BinaryPrimitives.ReverseEndianness(_a); 255_b = BinaryPrimitives.ReverseEndianness(_b); 256_c = BinaryPrimitives.ReverseEndianness(_c); 588result._de = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness((ushort)uintTmp) : (ushort)uintTmp; 591result._fg = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness((ushort)uintTmp) : (ushort)uintTmp; 596result._hijk = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(uintTmp) : uintTmp;
src\runtime\src\libraries\System.Private.CoreLib\src\System\Half.cs (2)
1408if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, Significand)) 1421if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, Significand))
src\runtime\src\libraries\System.Private.CoreLib\src\System\Int128.cs (5)
803result = BinaryPrimitives.ReadInt128BigEndian(source.Slice(source.Length - Size)); 876result = BinaryPrimitives.ReadInt128LittleEndian(source); 893result = BinaryPrimitives.ReverseEndianness(result); 927if (BinaryPrimitives.TryWriteInt128BigEndian(destination, this)) 940if (BinaryPrimitives.TryWriteInt128LittleEndian(destination, this))
src\runtime\src\libraries\System.Private.CoreLib\src\System\Int16.cs (4)
351result = BinaryPrimitives.ReadInt16BigEndian(source.Slice(source.Length - sizeof(short))); 417result = BinaryPrimitives.ReadInt16LittleEndian(source); 456if (BinaryPrimitives.TryWriteInt16BigEndian(destination, m_value)) 469if (BinaryPrimitives.TryWriteInt16LittleEndian(destination, m_value))
src\runtime\src\libraries\System.Private.CoreLib\src\System\Int32.cs (5)
372result = BinaryPrimitives.ReadInt32BigEndian(source.Slice(source.Length - sizeof(int))); 445result = BinaryPrimitives.ReadInt32LittleEndian(source); 462result = BinaryPrimitives.ReverseEndianness(result); 496if (BinaryPrimitives.TryWriteInt32BigEndian(destination, m_value)) 509if (BinaryPrimitives.TryWriteInt32LittleEndian(destination, m_value))
src\runtime\src\libraries\System.Private.CoreLib\src\System\Int64.cs (5)
369result = BinaryPrimitives.ReadInt64BigEndian(source.Slice(source.Length - sizeof(long))); 442result = BinaryPrimitives.ReadInt64LittleEndian(source); 459result = BinaryPrimitives.ReverseEndianness(result); 493if (BinaryPrimitives.TryWriteInt64BigEndian(destination, m_value)) 506if (BinaryPrimitives.TryWriteInt64LittleEndian(destination, m_value))
src\runtime\src\libraries\System.Private.CoreLib\src\System\IntPtr.cs (5)
398result = BinaryPrimitives.ReadIntPtrBigEndian(source.Slice(source.Length - sizeof(nint_t))); 471result = BinaryPrimitives.ReadIntPtrLittleEndian(source); 488result = BinaryPrimitives.ReverseEndianness(result); 522if (BinaryPrimitives.TryWriteIntPtrBigEndian(destination, _value)) 535if (BinaryPrimitives.TryWriteIntPtrLittleEndian(destination, _value))
src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (9)
214public virtual short ReadInt16() => BinaryPrimitives.ReadInt16LittleEndian(InternalRead(stackalloc byte[sizeof(short)])); 217public virtual ushort ReadUInt16() => BinaryPrimitives.ReadUInt16LittleEndian(InternalRead(stackalloc byte[sizeof(ushort)])); 219public virtual int ReadInt32() => BinaryPrimitives.ReadInt32LittleEndian(InternalRead(stackalloc byte[sizeof(int)])); 221public virtual uint ReadUInt32() => BinaryPrimitives.ReadUInt32LittleEndian(InternalRead(stackalloc byte[sizeof(uint)])); 222public virtual long ReadInt64() => BinaryPrimitives.ReadInt64LittleEndian(InternalRead(stackalloc byte[sizeof(long)])); 224public virtual ulong ReadUInt64() => BinaryPrimitives.ReadUInt64LittleEndian(InternalRead(stackalloc byte[sizeof(ulong)])); 225public virtual unsafe Half ReadHalf() => BinaryPrimitives.ReadHalfLittleEndian(InternalRead(stackalloc byte[sizeof(Half)])); 226public virtual unsafe float ReadSingle() => BinaryPrimitives.ReadSingleLittleEndian(InternalRead(stackalloc byte[sizeof(float)])); 227public virtual unsafe double ReadDouble() => BinaryPrimitives.ReadDoubleLittleEndian(InternalRead(stackalloc byte[sizeof(double)]));
src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\BinaryWriter.cs (9)
247BinaryPrimitives.WriteDoubleLittleEndian(buffer, value); 264BinaryPrimitives.WriteInt16LittleEndian(buffer, value); 275BinaryPrimitives.WriteUInt16LittleEndian(buffer, value); 285BinaryPrimitives.WriteInt32LittleEndian(buffer, value); 296BinaryPrimitives.WriteUInt32LittleEndian(buffer, value); 306BinaryPrimitives.WriteInt64LittleEndian(buffer, value); 317BinaryPrimitives.WriteUInt64LittleEndian(buffer, value); 327BinaryPrimitives.WriteSingleLittleEndian(buffer, value); 337BinaryPrimitives.WriteHalfLittleEndian(buffer, value);
src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (1)
479ushort firstTwoBytes = BinaryPrimitives.ReadUInt16LittleEndian(byteBuffer);
src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\Number.NumberToFloatingPointBits.cs (1)
961val = BinaryPrimitives.ReverseEndianness(val);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Numerics\Colors\Argb.cs (4)
25color = BinaryPrimitives.ReverseEndianness(color); 43color = BinaryPrimitives.ReverseEndianness(color); 61return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(bits) : bits; 76return BitConverter.IsLittleEndian ? bits : BinaryPrimitives.ReverseEndianness(bits);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Numerics\Colors\Rgba.cs (4)
25color = BinaryPrimitives.ReverseEndianness(color); 43color = BinaryPrimitives.ReverseEndianness(color); 61return BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(bits) : bits; 76return BitConverter.IsLittleEndian ? bits : BinaryPrimitives.ReverseEndianness(bits);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Numerics\Decimal128.cs (4)
850if (BinaryPrimitives.TryWriteInt32BigEndian(destination, Number.UnpackDecimalIeee754<Decimal128, UInt128>(new UInt128(_upper, _lower)).UnbiasedExponent)) 863if (BinaryPrimitives.TryWriteInt32LittleEndian(destination, Number.UnpackDecimalIeee754<Decimal128, UInt128>(new UInt128(_upper, _lower)).UnbiasedExponent)) 876if (BinaryPrimitives.TryWriteUInt128BigEndian(destination, Number.UnpackDecimalIeee754<Decimal128, UInt128>(new UInt128(_upper, _lower)).Significand)) 889if (BinaryPrimitives.TryWriteUInt128LittleEndian(destination, Number.UnpackDecimalIeee754<Decimal128, UInt128>(new UInt128(_upper, _lower)).Significand))
src\runtime\src\libraries\System.Private.CoreLib\src\System\Numerics\Decimal32.cs (4)
873if (BinaryPrimitives.TryWriteInt32BigEndian(destination, Number.UnpackDecimalIeee754<Decimal32, uint>(_value).UnbiasedExponent)) 886if (BinaryPrimitives.TryWriteInt32LittleEndian(destination, Number.UnpackDecimalIeee754<Decimal32, uint>(_value).UnbiasedExponent)) 899if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, Number.UnpackDecimalIeee754<Decimal32, uint>(_value).Significand)) 912if (BinaryPrimitives.TryWriteUInt32LittleEndian(destination, Number.UnpackDecimalIeee754<Decimal32, uint>(_value).Significand))
src\runtime\src\libraries\System.Private.CoreLib\src\System\Numerics\Decimal64.cs (4)
864if (BinaryPrimitives.TryWriteInt32BigEndian(destination, Number.UnpackDecimalIeee754<Decimal64, ulong>(_value).UnbiasedExponent)) 877if (BinaryPrimitives.TryWriteInt32LittleEndian(destination, Number.UnpackDecimalIeee754<Decimal64, ulong>(_value).UnbiasedExponent)) 890if (BinaryPrimitives.TryWriteUInt64BigEndian(destination, Number.UnpackDecimalIeee754<Decimal64, ulong>(_value).Significand)) 903if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination, Number.UnpackDecimalIeee754<Decimal64, ulong>(_value).Significand))
src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\AssemblyNameHelpers.StrongName.cs (3)
44uint sigAlgID = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob); 45uint hashAlgID = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob.Slice(4)); 46uint cbPublicKey = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob.Slice(8));
src\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (2)
173return BinaryPrimitives.ReadInt32LittleEndian(new ReadOnlySpan<byte>(p, sizeof(int))); 407arr[i] = (char)BinaryPrimitives.ReverseEndianness((short)charPtr[i]);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\AsyncProfiler.cs (10)
505BinaryPrimitives.WriteUInt32LittleEndian(headerSpan.Slice(headerSpanIndex), 0); 509BinaryPrimitives.WriteUInt32LittleEndian(headerSpan.Slice(headerSpanIndex), context.AsyncThreadContextId); 513BinaryPrimitives.WriteUInt64LittleEndian(headerSpan.Slice(headerSpanIndex), context.OsThreadId); 517BinaryPrimitives.WriteUInt32LittleEndian(headerSpan.Slice(headerSpanIndex), 0); 521BinaryPrimitives.WriteUInt64LittleEndian(headerSpan.Slice(headerSpanIndex), (ulong)currentTimestamp); 525BinaryPrimitives.WriteUInt64LittleEndian(headerSpan.Slice(headerSpanIndex), 0); 670BinaryPrimitives.WriteUInt16LittleEndian(eventBuffer.Data.AsSpan(payloadLengthFieldOffset), (ushort)payloadLength); 830BinaryPrimitives.WriteUInt32LittleEndian(headerSpan.Slice(spanIndex), (uint)eventBuffer.Index); 836BinaryPrimitives.WriteUInt32LittleEndian(headerSpan.Slice(spanIndex), eventBuffer.EventCount); 842BinaryPrimitives.WriteUInt64LittleEndian(headerSpan.Slice(spanIndex), (ulong)LastEventTimestamp);
src\runtime\src\libraries\System.Private.CoreLib\src\System\Single.cs (2)
753if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, Significand)) 771if (BinaryPrimitives.TryWriteUInt32LittleEndian(destination, Significand))
src\runtime\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\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\TimeZoneInfo.Unix.cs (4)
1122=> BinaryPrimitives.ReadInt16BigEndian(value); 1127=> BinaryPrimitives.ReadInt32BigEndian(value.AsSpan(startIndex)); 1132=> BinaryPrimitives.ReadInt32BigEndian(value); 1137=> BinaryPrimitives.ReadInt64BigEndian(value.AsSpan(startIndex));
src\runtime\src\libraries\System.Private.CoreLib\src\System\UInt128.cs (4)
1131result = BinaryPrimitives.ReadUInt128BigEndian(source.Slice(source.Length - Size)); 1179result = BinaryPrimitives.ReadUInt128LittleEndian(source); 1214if (BinaryPrimitives.TryWriteUInt128BigEndian(destination, this)) 1227if (BinaryPrimitives.TryWriteUInt128LittleEndian(destination, this))
src\runtime\src\libraries\System.Private.CoreLib\src\System\UInt16.cs (4)
318result = BinaryPrimitives.ReadUInt16BigEndian(source.Slice(source.Length - sizeof(ushort))); 359result = BinaryPrimitives.ReadUInt16LittleEndian(source); 381if (BinaryPrimitives.TryWriteUInt16BigEndian(destination, m_value)) 394if (BinaryPrimitives.TryWriteUInt16LittleEndian(destination, m_value))
src\runtime\src\libraries\System.Private.CoreLib\src\System\UInt32.cs (4)
365result = BinaryPrimitives.ReadUInt32BigEndian(source.Slice(source.Length - sizeof(uint))); 413result = BinaryPrimitives.ReadUInt32LittleEndian(source); 445if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, m_value)) 458if (BinaryPrimitives.TryWriteUInt32LittleEndian(destination, m_value))
src\runtime\src\libraries\System.Private.CoreLib\src\System\UInt64.cs (4)
372result = BinaryPrimitives.ReadUInt64BigEndian(source.Slice(source.Length - sizeof(ulong))); 420result = BinaryPrimitives.ReadUInt64LittleEndian(source); 452if (BinaryPrimitives.TryWriteUInt64BigEndian(destination, m_value)) 465if (BinaryPrimitives.TryWriteUInt64LittleEndian(destination, m_value))
src\runtime\src\libraries\System.Private.CoreLib\src\System\UIntPtr.cs (4)
373result = BinaryPrimitives.ReadUIntPtrBigEndian(source.Slice(source.Length - sizeof(nuint_t))); 421result = BinaryPrimitives.ReadUIntPtrLittleEndian(source); 453if (BinaryPrimitives.TryWriteUIntPtrBigEndian(destination, _value)) 466if (BinaryPrimitives.TryWriteUIntPtrLittleEndian(destination, _value))
System.Private.DataContractSerialization (43)
System\Runtime\Serialization\DataContract.cs (1)
1868b = unchecked(a + f + sines[j] + BinaryPrimitives.ReadUInt32LittleEndian(block.AsSpan(g)));
System\Xml\UniqueId.cs (4)
77_idLow = BinaryPrimitives.ReadInt64LittleEndian(source); 78_idHigh = BinaryPrimitives.ReadInt64LittleEndian(source.Slice(8)); 292BinaryPrimitives.WriteInt64LittleEndian(destination, _idLow); 293BinaryPrimitives.WriteInt64LittleEndian(destination.Slice(8), _idHigh);
System\Xml\XmlBinaryWriter.cs (19)
134=> WriteTextNodeRaw<short>(nodeType, BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness((value))); 137=> WriteTextNodeRaw<int>(nodeType, BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness((value))); 140=> WriteTextNodeRaw<long>(nodeType, BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness((value))); 513=> WriteRaw<long>(BitConverter.IsLittleEndian ? value : BinaryPrimitives.ReverseEndianness(value)); 738BinaryPrimitives.WriteSingleLittleEndian(span.Slice(1), f); 763BinaryPrimitives.WriteDoubleLittleEndian(span.Slice(1), d); 783BinaryPrimitives.WriteInt32LittleEndian(span.Slice(0 + 1), bits[3]); 784BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4 + 1), bits[2]); 785BinaryPrimitives.WriteInt32LittleEndian(span.Slice(8 + 1), bits[0]); 786BinaryPrimitives.WriteInt32LittleEndian(span.Slice(12 + 1), bits[1]); 876WriteRaw(BinaryPrimitives.ReverseEndianness(s)); 892WriteRaw(BinaryPrimitives.ReverseEndianness(i)); 908WriteRaw(BinaryPrimitives.ReverseEndianness(l)); 925BinaryPrimitives.WriteSingleLittleEndian(span, f); 943BinaryPrimitives.WriteDoubleLittleEndian(span, d); 965BinaryPrimitives.WriteInt32LittleEndian(span, bits[3]); 966BinaryPrimitives.WriteInt32LittleEndian(span.Slice(4), bits[2]); 967BinaryPrimitives.WriteInt32LittleEndian(span.Slice(8), bits[0]); 968BinaryPrimitives.WriteInt32LittleEndian(span.Slice(12), bits[1]);
System\Xml\XmlBufferReader.cs (18)
356=> BitConverter.IsLittleEndian ? ReadRawBytes<ushort>() : BinaryPrimitives.ReverseEndianness(ReadRawBytes<ushort>()); 362=> BitConverter.IsLittleEndian ? ReadRawBytes<int>() : BinaryPrimitives.ReverseEndianness(ReadRawBytes<int>()); 373=> BitConverter.IsLittleEndian ? ReadRawBytes<long>() : BinaryPrimitives.ReverseEndianness(ReadRawBytes<long>()); 377float f = BinaryPrimitives.ReadSingleLittleEndian(GetBuffer(sizeof(float), out int offset).AsSpan(offset, sizeof(float))); 384double d = BinaryPrimitives.ReadDoubleLittleEndian(GetBuffer(sizeof(double), out int offset).AsSpan(offset, sizeof(double))); 401BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(8, 4)), 402BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(12, 4)), 403BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(4, 4)), 404BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(0, 4)) 952=> BitConverter.IsLittleEndian ? ReadRawBytes<short>(offset) : BinaryPrimitives.ReverseEndianness(ReadRawBytes<short>(offset)); 955=> BitConverter.IsLittleEndian ? ReadRawBytes<int>(offset) : BinaryPrimitives.ReverseEndianness(ReadRawBytes<int>(offset)); 958=> BitConverter.IsLittleEndian ? ReadRawBytes<long>(offset) : BinaryPrimitives.ReverseEndianness(ReadRawBytes<long>(offset)); 964=> BinaryPrimitives.ReadSingleLittleEndian(_buffer.AsSpan(offset, sizeof(float))); 967=> BinaryPrimitives.ReadDoubleLittleEndian(_buffer.AsSpan(offset, sizeof(double))); 980BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(8, 4)), 981BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(12, 4)), 982BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(4, 4)), 983BinaryPrimitives.ReadInt32LittleEndian(bytes.Slice(0, 4))
System\Xml\XmlStreamNodeWriter.cs (1)
345BinaryPrimitives.ReverseEndianness(new ReadOnlySpan<short>(chars, charCount),
System.Private.Uri (1)
src\runtime\src\libraries\Common\src\System\Net\IPv4AddressHelper.Common.cs (1)
55return BinaryPrimitives.ReadInt32BigEndian(numbers);
System.Private.Windows.Core (3)
System\IO\BinaryReaderExtensions.cs (3)
135BinaryPrimitives.ReverseEndianness(ushorts, ushorts); 140BinaryPrimitives.ReverseEndianness(ints, ints); 145BinaryPrimitives.ReverseEndianness(longs, longs);
System.Private.Xml (15)
System\Xml\BinaryXml\SqlUtils.cs (1)
73=> BinaryPrimitives.ReadUInt32LittleEndian(data.AsSpan(offset));
System\Xml\BinaryXml\XmlBinaryReader.cs (11)
3498if (!BinaryPrimitives.TryReadUInt16LittleEndian(data, out ushort value)) 3511if (!BinaryPrimitives.TryReadUInt16LittleEndian(data, out ushort value)) 3525if (!BinaryPrimitives.TryReadUInt16LittleEndian(data, out ushort lowSurr)) 4375private short GetInt16(int pos) => BinaryPrimitives.ReadInt16LittleEndian(_data.AsSpan(pos)); 4377private ushort GetUInt16(int pos) => BinaryPrimitives.ReadUInt16LittleEndian(_data.AsSpan(pos)); 4379private int GetInt32(int pos) => BinaryPrimitives.ReadInt32LittleEndian(_data.AsSpan(pos)); 4381private uint GetUInt32(int pos) => BinaryPrimitives.ReadUInt32LittleEndian(_data.AsSpan(pos)); 4383private long GetInt64(int pos) => BinaryPrimitives.ReadInt64LittleEndian(_data.AsSpan(pos)); 4385private ulong GetUInt64(int pos) => BinaryPrimitives.ReadUInt64LittleEndian(_data.AsSpan(pos)); 4387private float GetSingle(int offset) => BinaryPrimitives.ReadSingleLittleEndian(_data.AsSpan(offset)); 4389private double GetDouble(int offset) => BinaryPrimitives.ReadDoubleLittleEndian(_data.AsSpan(offset));
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 (5)
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.Metadata (19)
System\Reflection\Internal\Utilities\BlobUtilities.cs (5)
26BinaryPrimitives.WriteUInt16LittleEndian(buffer.AsSpan(start), value); 29BinaryPrimitives.WriteUInt16BigEndian(buffer.AsSpan(start), value); 32BinaryPrimitives.WriteUInt32BigEndian(buffer.AsSpan(start), value); 35BinaryPrimitives.WriteUInt32LittleEndian(buffer.AsSpan(start), value); 38BinaryPrimitives.WriteUInt64LittleEndian(buffer.AsSpan(start), value);
System\Reflection\Internal\Utilities\MemoryBlock.cs (2)
131return BitConverter.IsLittleEndian ? result : BinaryPrimitives.ReverseEndianness(result); 189return BitConverter.IsLittleEndian ? result : BinaryPrimitives.ReverseEndianness(result);
System\Reflection\Metadata\BlobWriterImpl.cs (10)
160BinaryPrimitives.WriteUInt32LittleEndian(bytes, 0); 177BinaryPrimitives.WriteInt32LittleEndian(bytes, (int)value); 187BinaryPrimitives.WriteUInt16LittleEndian(bytes, (char)value); 193BinaryPrimitives.WriteDoubleLittleEndian(bytes, (double)value); 205BinaryPrimitives.WriteInt16LittleEndian(bytes, (short)value); 210BinaryPrimitives.WriteInt64LittleEndian(bytes, (long)value); 221BinaryPrimitives.WriteSingleLittleEndian(bytes, (float)value); 233BinaryPrimitives.WriteUInt16LittleEndian(bytes, (ushort)value); 238BinaryPrimitives.WriteUInt32LittleEndian(bytes, (uint)value); 243BinaryPrimitives.WriteUInt64LittleEndian(bytes, (ulong)value);
System\Reflection\Metadata\TypeSystem\Handles.TypeSystem.cs (1)
2599BinaryPrimitives.WriteUInt32LittleEndian(blob.AsSpan(TemplateParameterOffset_AttributeUsageTarget), VirtualValue);
System\Reflection\PortableExecutable\PEBuilder.cs (1)
539checksum = AggregateChecksum(checksum, BinaryPrimitives.ReadUInt16LittleEndian(segment));
System.Resources.Extensions (2)
src\runtime\src\libraries\System.Private.CoreLib\src\System\Resources\ResourceReader.cs (2)
173return BinaryPrimitives.ReadInt32LittleEndian(new ReadOnlySpan<byte>(p, sizeof(int))); 407arr[i] = (char)BinaryPrimitives.ReverseEndianness((short)charPtr[i]);
System.Runtime.Numerics (11)
System\Numerics\BigInteger.cs (11)
436BinaryPrimitives.ReverseEndianness(limbSpan, limbSpan); 1697BinaryPrimitives.WriteUIntPtrBigEndian(destination.Slice(curByte), limb); 1701BinaryPrimitives.WriteUIntPtrLittleEndian(destination.Slice(curByte), limb); 3838BinaryPrimitives.WriteIntPtrBigEndian(destination, _sign); 3848BinaryPrimitives.WriteUIntPtrBigEndian(dest, bits[i]); 3864BinaryPrimitives.WriteUIntPtrBigEndian(dest, nuint.MaxValue); 3890BinaryPrimitives.WriteUIntPtrBigEndian(dest, part); 3916BinaryPrimitives.WriteIntPtrLittleEndian(destination, _sign); 3926BinaryPrimitives.WriteUIntPtrLittleEndian(dest, bits[i]); 3959BinaryPrimitives.WriteUIntPtrLittleEndian(dest, part); 3967BinaryPrimitives.WriteUIntPtrLittleEndian(dest, nuint.MaxValue);
System.Security.Cryptography (19)
src\runtime\src\libraries\Common\src\System\Security\Cryptography\DSACng.ImportExport.cs (2)
359dsaParams.Counter = BinaryPrimitives.ReadInt32BigEndian(Interop.BCrypt.Consume(dsaBlob, ref offset, 4)); 393dsaParams.Counter = BinaryPrimitives.ReadInt32BigEndian(Interop.BCrypt.Consume(dsaBlob, ref offset, 4));
src\runtime\src\libraries\Common\src\System\Security\Cryptography\RsaPaddingProcessor.cs (1)
598BinaryPrimitives.WriteInt32BigEndian(bigEndianCount, count);
System\Security\Cryptography\Aes.cs (8)
378iv = BinaryPrimitives.ReadUInt64BigEndian(decrypt); 447BinaryPrimitives.WriteUInt64BigEndian(buf, iv); 500BinaryPrimitives.WriteUInt64BigEndian(A, iv); 512uint al = BinaryPrimitives.ReadUInt32BigEndian(ALo); 514BinaryPrimitives.WriteUInt32BigEndian(ALo, al); 544uint al = BinaryPrimitives.ReadUInt32BigEndian(ALo); 546BinaryPrimitives.WriteUInt32BigEndian(ALo, al); 556return BinaryPrimitives.ReadUInt64BigEndian(A);
System\Security\Cryptography\CapiHelper.Windows.cs (1)
749int dwAlgId = BinaryPrimitives.ReadInt32LittleEndian(algid);
System\Security\Cryptography\DES.cs (2)
72ulong key = BinaryPrimitives.ReadUInt64BigEndian(rgbOddParityKey); 90ulong key = BinaryPrimitives.ReadUInt64BigEndian(rgbOddParityKey);
System\Security\Cryptography\DSACryptoServiceProvider.Windows.cs (1)
207_keySize = BinaryPrimitives.ReadInt32LittleEndian(keySize);
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\RSACryptoServiceProvider.Windows.cs (1)
196_keySize = BinaryPrimitives.ReadInt32LittleEndian(keySize);
System\Security\Cryptography\XmlKeyHelper.cs (1)
107BinaryPrimitives.WriteInt32BigEndian(valBuf, value);
System.Security.Cryptography.Cose (3)
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.Encoding.CodePages (22)
System\Text\BaseCodePageEncoding.cs (16)
117pTableName[i] = (char)BinaryPrimitives.ReverseEndianness((ushort)pTableName[i]); 122pVersion[i] = BinaryPrimitives.ReverseEndianness(pVersion[i]); 124p->CodePageCount = BinaryPrimitives.ReverseEndianness(p->CodePageCount); 155pCodePageName[i] = (char)BinaryPrimitives.ReverseEndianness((ushort)pCodePageName[i]); 157p->CodePage = BinaryPrimitives.ReverseEndianness(p->CodePage); 158p->ByteCount = BinaryPrimitives.ReverseEndianness(p->ByteCount); 159p->Offset = BinaryPrimitives.ReverseEndianness(p->Offset); 201pCodePageName[i] = (char)BinaryPrimitives.ReverseEndianness((ushort)pCodePageName[i]); 203p->VersionMajor = BinaryPrimitives.ReverseEndianness(p->VersionMajor); 204p->VersionMinor = BinaryPrimitives.ReverseEndianness(p->VersionMinor); 205p->VersionRevision = BinaryPrimitives.ReverseEndianness(p->VersionRevision); 206p->VersionBuild = BinaryPrimitives.ReverseEndianness(p->VersionBuild); 207p->CodePage = BinaryPrimitives.ReverseEndianness(p->CodePage); 208p->ByteCount = BinaryPrimitives.ReverseEndianness(p->ByteCount); 209p->UnicodeReplace = (char)BinaryPrimitives.ReverseEndianness((ushort)p->UnicodeReplace); 210p->ByteReplace = BinaryPrimitives.ReverseEndianness(p->ByteReplace);
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 (2)
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))