Fix BigInteger.LeadingZeroCount, PopCount, TrailingZeroCount, RotateLeft, and RotateRight for platform-independent 32-bit word semantics

[Copilot]

After the _bits migration from uint[] to nuint[] (#125799), several IBinaryInteger<BigInteger> methods returned platform-dependent results. This PR restores consistent 32-bit word semantics for all five affected methods, including both the _sign path and the _bits path.

Description

Changes

LeadingZeroCount:

• _sign path: nint.LeadingZeroCount → uint.LeadingZeroCount((uint)value._sign)
• _bits path: BitOperations.LeadingZeroCount(value._bits[^1]) & 31 to map to 32-bit word semantics

PopCount:

• _sign path: nint.PopCount(value._sign) → int.PopCount(value._sign)
  • Fixes PopCount(-1) returning 64 on 64-bit vs 32 on 32-bit
• _bits negative path: Uses standard nuint two's complement with MSL (most-significant limb) upper-32-bit correction. On 64-bit, the MSL's upper 32 bits may contain sign-extension 1s that don't correspond to real 32-bit words, so the correction subtracts BitOperations.PopCount(bits[^1] >> BitsPerUInt32) * (BitsPerLimb - BitsPerUInt32) to account for those phantom bits. Uses IndexOfAnyExcept((nuint)0) for efficient first non-zero limb detection.

TrailingZeroCount:

• _sign path: nint.TrailingZeroCount(value._sign) → int.TrailingZeroCount(value._sign)
  • Fixes TrailingZeroCount(BigInteger.Zero) returning 64 on 64-bit vs 32 on 32-bit

RotateLeft:

• _sign path: BitOperations.RotateLeft((nuint)value._sign, rotateAmount) → uint.RotateLeft((uint)value._sign, rotateAmount) with new BigInteger((int)rs) / new BigInteger(rs) result construction
  • Fixes RotateLeft(BigInteger.One, 32) returning 2^32 on 64-bit vs 1 on 32-bit
• _bits path: The rotation operates directly on nuint limbs using the original SIMD-accelerated algorithm. On 64-bit, a last-index fixup handles the edge case where the upper 32 bits of the final limb are zero (positive values) or the upper 33 bits are all ones (negative values after two's complement), indicating those bits are "extra" compared to uint[] storage. When the effective 32-bit word count is odd, SwapUpperAndLower uses MemoryMarshal.Cast<nuint, uint> for the digit swap at the mid-nuint boundary, while all shift operations use the existing SIMD-accelerated nuint overloads directly. On 32-bit, nuint == uint so the algorithm is unchanged.

RotateRight:

• _sign path: BitOperations.RotateRight((nuint)value._sign, rotateAmount) → uint.RotateRight((uint)value._sign, rotateAmount) with new BigInteger((int)rs) / new BigInteger(rs) result construction
  • Fixes RotateRight(BigInteger.One, 1) returning 2^63 on 64-bit vs 2^31 on 32-bit
• _bits path: Same Rotate() approach as RotateLeft (shared helper)

Performance: The rotation _bits path operates directly on nuint limbs, preserving full 64-bit throughput with SIMD-accelerated shifts. Only the SwapUpperAndLower digit-swap step uses a Span<uint> view (via MemoryMarshal.Cast) when the swap boundary falls mid-nuint on 64-bit with an odd word count. The Rotate() helper works directly in the final result nuint[] buffer allocated via RentedBuffer, avoiding any temporary array allocation.

Endianness safety: On big-endian 64-bit platforms, the SwapUpperAndLower helper swaps the two 32-bit halves within each nuint limb before and after performing uint-level digit swapping, ensuring correct word order regardless of endianness. On 32-bit platforms, nuint and uint are the same size so no special handling is needed.

BigIntegerCalculator helpers:

• The existing nuint RotateLeft / RotateRight / SwapUpperAndLower / LeftShiftSelf / RightShiftSelf overloads are used as the primary rotation API, with full Vector128/256/512 SIMD acceleration for shifts
• SwapUpperAndLower uses MemoryMarshal.Cast<nuint, uint> for digit swapping when the swap boundary falls mid-nuint on 64-bit with an odd word count
• SwapUpperAndLower uses RentedBuffer for temporary storage, matching the pattern used elsewhere in BigInteger

Tests: Comprehensive platform-independent test cases added to existing BigIntegerTests.GenericMath.cs for all five methods, covering _sign path values, _bits path boundary values (32-bit word boundaries), and negative multiword values including mixed-bit cases exercising the two's complement PopCount formula. All pre-existing Rotate.cs tests updated from platform-dependent nint.Size * 8 to fixed 32-bit semantics.

---

⌨️ Start Copilot coding agent tasks without leaving your editor — available in VS Code, Visual Studio, JetBrains IDEs and Eclipse.

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-numerics
See info in area-owners.md if you want to be subscribed.

[stephentoub]

@tannergooding, is the .NET 10 behavior that uses the upper 32-bit word what we want?

[Copilot]

Pull request overview

This PR restores platform-independent, 32-bit word–based semantics for BigInteger.LeadingZeroCount after the internal _bits storage migrated from uint[] to nuint[], and adds/updates tests to lock in the intended behavior.

Changes:

• Update BigInteger.LeadingZeroCount to always compute LZC using 32-bit word semantics (including on 64-bit platforms).
• Fix existing generic-math test expectations to be platform-independent (32/31 for Zero/One).
• Add a dedicated LeadingZeroCountTests suite and include it in the Numerics test project.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 2 comments.

File	Description
src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs	Adjusts LeadingZeroCount to use 32-bit word semantics for both _sign and _bits representations.
src/libraries/System.Runtime.Numerics/tests/BigIntegerTests.GenericMath.cs	Updates assertions to expect platform-independent results for LeadingZeroCount(Zero/One).
src/libraries/System.Runtime.Numerics/tests/BigInteger/LeadingZeroCountTests.cs	Adds coverage for boundary and platform-independence scenarios (small/large, positive/negative).
src/libraries/System.Runtime.Numerics/tests/System.Runtime.Numerics.Tests.csproj	Includes the newly added LeadingZeroCountTests.cs in the test build.

Comments suppressed due to low confidence (1)

src/libraries/System.Runtime.Numerics/tests/BigInteger/LeadingZeroCountTests.cs:67

• Same as above: this parse call would be clearer and more consistent with the surrounding test suite if it used using System.Globalization; + NumberStyles.HexNumber instead of the Globalization. qualifier.

            // Parse the magnitude as a positive hex value (leading zero keeps high bit clear),
            // then negate it so the result is negative and stored in _bits.
            BigInteger magnitude = BigInteger.Parse(hexMagnitude, Globalization.NumberStyles.HexNumber);
            BigInteger value = -magnitude;

[stephentoub]

@copilot also address RotateLeft/RotateRight and any other similarly affected methods on BigInteger. Ensure comprehensive tests are added/updated in a manner consistent with the other APIs in this PR.

[Copilot]

@copilot also address RotateLeft/RotateRight and any other similarly affected methods on BigInteger. Ensure comprehensive tests are added/updated in a manner consistent with the other ...

Fixed RotateLeft and RotateRight _sign paths in d9749d7 — replaced BitOperations.RotateLeft/Right((nuint)value._sign, ...) with uint.RotateLeft/Right((uint)value._sign, ...) and updated result construction to use (int)rs/(uint)rs. Updated all platform-dependent test assertions (nint.Size * 8 expressions → fixed 32-bit values) and added comprehensive tests for _sign path values.

I also verified that Log2 is NOT affected — the platform dependencies in BitsPerLimb and BitOperations.LeadingZeroCount cancel each other out, producing correct results on both platforms.

Note: The pre-existing Rotate.cs tests (RunSmallTests, RunRotateTests) fail because the _bits path Rotate() helper also has platform-dependent behavior when operating on nuint[] limbs (e.g., two's complement conversion sign-extends differently on 64-bit). This is a broader issue separate from the _sign path fixes in this PR.

[stephentoub]

Note: The pre-existing Rotate.cs tests (RunSmallTests, RunRotateTests) fail because the _bits path Rotate() helper also has platform-dependent behavior when operating on nuint[] limbs (e.g., two's complement conversion sign-extends differently on 64-bit). This is a broader issue separate from the _sign path fixes in this PR.

@copilot, can you elaborate? If it wasn't platform-dependent before #125799, then I need you to fix it in this PR.

[tannergooding]

This is still not as small of a diff as it should be, but I'm tired of fighting with copilot on the simpler fix for Rotate. I'll follow up to remove the unnecessary code duplication in a separate PR.

[tannergooding]

/ba-g unrelated mono ios timeout