Fix (U)Int128 to double conversion precision loss

- Correctly calculate the sticky bit when converting large UInt128 values (>= 2^104) to double to prevent precision loss.
- Optimize the upper bits extraction by accessing _upper directly instead of shifting.
- Add regression tests for Int128 to ensure it is also fixed.
- Update test comments to better explain the test cases.

Fixes #122203

Author: sdcb

src/libraries/System.Private.CoreLib/src/System/UInt128.cs

@@ -276,7 +276,7 @@ public static explicit operator double(UInt128 value)
                 // lowest 24 bits and then or's them back to ensure rounding stays correct.
 
                 double lower = BitConverter.UInt64BitsToDouble(TwoPow76Bits | ((ulong)(value >> 12) >> 12) | ((value._lower & 0xFFFFFF) != 0 ? 1UL : 0UL)) - TwoPow76;
-                double upper = BitConverter.UInt64BitsToDouble(TwoPow128Bits | (ulong)(value >> 76)) - TwoPow128;
+                double upper = BitConverter.UInt64BitsToDouble(TwoPow128Bits | (value._upper >> 12)) - TwoPow128;
 
                 return lower + upper;
             }

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Int128Tests.cs

@@ -586,5 +586,34 @@ public static void BigMul(Int128 a, Int128 b, string result)
             Int128 upper = Int128.BigMul(a, b, out Int128 lower);
             Assert.Equal(result, $"{upper:X32}{lower:X32}");
         }
+
+        [Fact]
+        public static void ExplicitConversionToDouble_LargeValue()
+        {
+            // Value: 309485009821345068741558271 (approx 2^88)
+            Int128 value = Int128.Parse("309485009821345068741558271");
+            double d = (double)value;
+            Assert.Equal(3.094850098213451E+26, d);
+
+            // Negative Value
+            Int128 valueNeg = -value;
+            double dNeg = (double)valueNeg;
+            Assert.Equal(-3.094850098213451E+26, dNeg);
+
+            // Value >= 2^104
+            // The value is constructed as 2^104 + 2^24 + 1.
+            // This tests a value with a 1 at bit 104, a 1 at bit 24, and a 1 at bit 0.
+            // The lower bits (24 and 0) should contribute to the sticky bit calculation.
+            Int128 value2 = (Int128.One << 104) + (Int128.One << 24) + 1;
+            double d2 = (double)value2;
+            double expected2 = 20282409603651670423947251286016.0;
+            Assert.Equal(expected2, d2);
+
+            // Negative Value >= 2^104
+            Int128 value2Neg = -value2;
+            double d2Neg = (double)value2Neg;
+            Assert.Equal(-expected2, d2Neg);
+        }
     }
 }
+

src/libraries/System.Runtime/tests/System.Runtime.Tests/System/UInt128Tests.cs

@@ -529,9 +529,9 @@ public static void ExplicitConversionToDouble_LargeValue()
 
             // Value >= 2^104
             // 2^104 = 20282409603651670423947251286016
-            // We add 2^24 + 1 to ensure we test the sticky bit logic if it matters,
-            // or at least that the large value path doesn't crash or produce garbage.
-            // 2^104 + 2^24 + 1
+            // The value is constructed as 2^104 + 2^24 + 1.
+            // This tests a value with a 1 at bit 104, a 1 at bit 24, and a 1 at bit 0.
+            // The lower bits (24 and 0) should contribute to the sticky bit calculation.
             UInt128 value2 = (UInt128.One << 104) + (UInt128.One << 24) + 1;
             double d2 = (double)value2;
             // Expected: 2^104. 2^24 is far below ULP (2^52).