Skip to content

Remove unsafe code from BigInteger.TryWriteBigEndian and TryWriteLittleEndian #124858

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
Copilot wants to merge 9 commits into from
Closed

Remove unsafe code from BigInteger.TryWriteBigEndian and TryWriteLittleEndian #124858

Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
893dce3
Initial plan
Copilot Feb 25, 2026
fc3f7c2
Remove unsafe code from TryWriteBigEndian and TryWriteLittleEndian in…
Copilot Feb 25, 2026
45fc4de
Add Slice(0, byteCount) before Cast for bounds-check-elimination frie…
Copilot Feb 25, 2026
3156ec1
Replace MemoryMarshal.Cast with BinaryPrimitives.WriteUInt32BigEndian…
Copilot Feb 25, 2026
4cd55fa
Use forward loops in TryWriteBigEndian, compute big-endian offset fro…
Copilot Feb 25, 2026
8f1df64
Update BigInteger.cs
EgorBo Feb 25, 2026
e6c1f5a
Fix big-endian byte order regression, restore do-while/while structure
Copilot Feb 25, 2026
9f8d523
Update BigInteger.cs
EgorBo Feb 26, 2026
fb01067
Update BigInteger.cs
EgorBo Feb 26, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
89 changes: 20 additions & 69 deletions src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3463,36 +3463,26 @@ bool IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<byte> destination, out in
{
if (bits is null)
{
int value = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(_sign) : _sign;
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
BinaryPrimitives.WriteInt32BigEndian(destination, _sign);
}
else if (_sign >= 0)
{
// When the value is positive, we simply need to copy all bits as big endian

ref byte startAddress = ref MemoryMarshal.GetReference(destination);
ref byte address = ref Unsafe.Add(ref startAddress, (bits.Length - 1) * sizeof(uint));
Span<uint> uintDestination = MemoryMarshal.Cast<byte, uint>(destination);

for (int i = 0; i < bits.Length; i++)
{
uint part = bits[i];

if (BitConverter.IsLittleEndian)
{
part = BinaryPrimitives.ReverseEndianness(part);
}

Unsafe.WriteUnaligned(ref address, part);
address = ref Unsafe.Subtract(ref address, sizeof(uint));
uintDestination[bits.Length - 1 - i] = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(bits[i]) : bits[i];
}
}
else
{
// When the value is negative, we need to copy the two's complement representation
// We'll do this "inline" to avoid needing to unnecessarily allocate.

ref byte startAddress = ref MemoryMarshal.GetReference(destination);
ref byte address = ref Unsafe.Add(ref startAddress, byteCount - sizeof(uint));
Span<uint> uintDestination = MemoryMarshal.Cast<byte, uint>(destination);
int uintCount = byteCount / sizeof(uint);

int i = 0;
uint part;
Expand All @@ -3502,14 +3492,7 @@ bool IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<byte> destination, out in
// first do complement and +1 as long as carry is needed
part = ~bits[i] + 1;

if (BitConverter.IsLittleEndian)
{
part = BinaryPrimitives.ReverseEndianness(part);
}

Unsafe.WriteUnaligned(ref address, part);
address = ref Unsafe.Subtract(ref address, sizeof(uint));

uintDestination[uintCount - 1 - i] = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(part) : part;
i++;
}
while ((part == 0) && (i < bits.Length));
Expand All @@ -3519,27 +3502,19 @@ bool IBinaryInteger<BigInteger>.TryWriteBigEndian(Span<byte> destination, out in
// now ones complement is sufficient
part = ~bits[i];

if (BitConverter.IsLittleEndian)
{
part = BinaryPrimitives.ReverseEndianness(part);
}

Unsafe.WriteUnaligned(ref address, part);
address = ref Unsafe.Subtract(ref address, sizeof(uint));

uintDestination[uintCount - 1 - i] = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(part) : part;
i++;
}

if (Unsafe.AreSame(ref address, ref startAddress))
if (uintCount > bits.Length)
{
// We need one extra part to represent the sign as the most
// significant bit of the two's complement value was 0.
Unsafe.WriteUnaligned(ref address, uint.MaxValue);
uintDestination[0] = uint.MaxValue;
}
else
{
// Otherwise we should have been precisely one part behind address
Debug.Assert(Unsafe.AreSame(ref startAddress, ref Unsafe.Add(ref address, sizeof(uint))));
Debug.Assert(uintCount == bits.Length);
}
}

Expand All @@ -3565,35 +3540,26 @@ bool IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<byte> destination, out
{
if (bits is null)
{
int value = BitConverter.IsLittleEndian ? _sign : BinaryPrimitives.ReverseEndianness(_sign);
Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
BinaryPrimitives.WriteInt32LittleEndian(destination, _sign);
}
else if (_sign >= 0)
{
// When the value is positive, we simply need to copy all bits as little endian

ref byte address = ref MemoryMarshal.GetReference(destination);
Span<uint> uintDestination = MemoryMarshal.Cast<byte, uint>(destination);

for (int i = 0; i < bits.Length; i++)
{
uint part = bits[i];

if (!BitConverter.IsLittleEndian)
{
part = BinaryPrimitives.ReverseEndianness(part);
}

Unsafe.WriteUnaligned(ref address, part);
address = ref Unsafe.Add(ref address, sizeof(uint));
uintDestination[i] = BitConverter.IsLittleEndian ? bits[i] : BinaryPrimitives.ReverseEndianness(bits[i]);
}
}
else
{
// When the value is negative, we need to copy the two's complement representation
// We'll do this "inline" to avoid needing to unnecessarily allocate.

ref byte address = ref MemoryMarshal.GetReference(destination);
ref byte lastAddress = ref Unsafe.Add(ref address, byteCount - sizeof(uint));
Span<uint> uintDestination = MemoryMarshal.Cast<byte, uint>(destination);
int uintCount = byteCount / sizeof(uint);

int i = 0;
uint part;
Expand All @@ -3603,14 +3569,7 @@ bool IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<byte> destination, out
// first do complement and +1 as long as carry is needed
part = ~bits[i] + 1;

if (!BitConverter.IsLittleEndian)
{
part = BinaryPrimitives.ReverseEndianness(part);
}

Unsafe.WriteUnaligned(ref address, part);
address = ref Unsafe.Add(ref address, sizeof(uint));

uintDestination[i] = BitConverter.IsLittleEndian ? part : BinaryPrimitives.ReverseEndianness(part);
i++;
}
while ((part == 0) && (i < bits.Length));
Expand All @@ -3620,27 +3579,19 @@ bool IBinaryInteger<BigInteger>.TryWriteLittleEndian(Span<byte> destination, out
// now ones complement is sufficient
part = ~bits[i];

if (!BitConverter.IsLittleEndian)
{
part = BinaryPrimitives.ReverseEndianness(part);
}

Unsafe.WriteUnaligned(ref address, part);
address = ref Unsafe.Add(ref address, sizeof(uint));

uintDestination[i] = BitConverter.IsLittleEndian ? part : BinaryPrimitives.ReverseEndianness(part);
i++;
}

if (Unsafe.AreSame(ref address, ref lastAddress))
if (uintCount > bits.Length)
{
// We need one extra part to represent the sign as the most
// significant bit of the two's complement value was 0.
Unsafe.WriteUnaligned(ref address, uint.MaxValue);
uintDestination[bits.Length] = uint.MaxValue;
}
else
{
// Otherwise we should have been precisely one part ahead address
Debug.Assert(Unsafe.AreSame(ref lastAddress, ref Unsafe.Subtract(ref address, sizeof(uint))));
Debug.Assert(uintCount == bits.Length);
}
}

Expand Down
Loading