Merged PR 21170: Fixing the shift-left handling to correctly account for overshifting

Fixing the shift-left handling to correctly account for overshifting

Author: tannergooding

src/libraries/System.Private.CoreLib/src/System/Number.BigInteger.cs

@@ -31,7 +31,9 @@ internal unsafe ref struct BigInteger
             private const int MaxBits = BitsForLongestBinaryMantissa + BitsForLongestDigitSequence + BitsPerBlock;
 
             private const int BitsPerBlock = sizeof(int) * 8;
-            private const int MaxBlockCount = (MaxBits + (BitsPerBlock - 1)) / BitsPerBlock;
+
+            // We need one extra block to make our shift left algorithm significantly simpler
+            private const int MaxBlockCount = ((MaxBits + (BitsPerBlock - 1)) / BitsPerBlock) + 1;
 
             private static readonly uint[] s_Pow10UInt32Table = new uint[]
             {
@@ -302,7 +304,8 @@ internal unsafe ref struct BigInteger
                 0xD9D61A05,
                 0x00000325,
 
-                // 9 Trailing blocks to ensure MaxBlockCount
+                // 10 Trailing blocks to ensure MaxBlockCount
+                0x00000000,
                 0x00000000,
                 0x00000000,
                 0x00000000,
@@ -1206,19 +1209,21 @@ public void ShiftLeft(uint shift)
                 int readIndex = (length - 1);
                 int writeIndex = readIndex + (int)(blocksToShift);
 
-                uint remainingBitsInLastBlock = (uint)BitOperations.LeadingZeroCount(_blocks[readIndex]);
-
-                if (remainingBitsToShift > remainingBitsInLastBlock)
-                {
-                    // We need an extra block for the partial shift
-                    writeIndex++;
-                }
-
-                Debug.Assert(unchecked((uint)(writeIndex)) < MaxBlockCount);
-
                 // Check if the shift is block aligned
                 if (remainingBitsToShift == 0)
                 {
+                    Debug.Assert(unchecked((uint)(length)) < MaxBlockCount);
+
+                    if (unchecked((uint)(length)) >= MaxBlockCount)
+                    {
+                        // We shouldn't reach here, and the above assert will help flag this
+                        // during testing, but we'll ensure that we return a safe value of
+                        // zero in the case we end up overflowing in any way.
+
+                        SetZero(out this);
+                        return;
+                    }
+
                     while (readIndex >= 0)
                     {
                         _blocks[writeIndex] = _blocks[readIndex];
@@ -1233,6 +1238,21 @@ public void ShiftLeft(uint shift)
                 }
                 else
                 {
+                    // We need an extra block for the partial shift
+
+                    writeIndex++;
+                    Debug.Assert(unchecked((uint)(length)) < MaxBlockCount);
+
+                    if (unchecked((uint)(length)) >= MaxBlockCount)
+                    {
+                        // We shouldn't reach here, and the above assert will help flag this
+                        // during testing, but we'll ensure that we return a safe value of
+                        // zero in the case we end up overflowing in any way.
+
+                        SetZero(out this);
+                        return;
+                    }
+
                     // Set the length to hold the shifted blocks
                     _length = writeIndex + 1;