Branchless algorithm for RuntimeLong.toDouble.

sjrd · sjrd · commit 944be5ae72af · 2025-07-09T00:11:12.000+02:00
It turns out the computation we did in the non-negative case also
works for the negative case. The proof relies on elementary
properties of the two's complement representation.

I don't know how I never saw this before. To make things worse, it
seems that Kotlin and J2CL knew all along, and I never realized
when skimming through their implementations either.
diff --git a/linker-private-library/src/main/scala/org/scalajs/linker/runtime/RuntimeLong.scala b/linker-private-library/src/main/scala/org/scalajs/linker/runtime/RuntimeLong.scala
@@ -695,17 +695,8 @@ object RuntimeLong {
     a.lo
 
   @inline
-  def toDouble(a: RuntimeLong): Double = {
-    val lo = a.lo
-    val hi = a.hi
-    if (hi < 0) {
-      // We need unsignedToDoubleApprox specifically for MinValue
-      val neg = inline_negate(lo, hi)
-      -unsignedToDoubleApprox(neg.lo, neg.hi)
-    } else {
-      nonNegativeToDoubleApprox(lo, hi)
-    }
-  }
+  def toDouble(a: RuntimeLong): Double =
+    signedToDoubleApprox(a.lo, a.hi)
 
   @inline
   def toFloat(a: RuntimeLong): Float =
@@ -1197,7 +1188,7 @@ object RuntimeLong {
 
   /** Converts an unsigned safe double into its Double representation. */
   @inline def asUnsignedSafeDouble(lo: Int, hi: Int): Double =
-    nonNegativeToDoubleApprox(lo, hi)
+    signedToDoubleApprox(lo, hi) // can use either signed or unsigned here; signed folds better
 
   /** Converts an unsigned safe double into its RuntimeLong representation. */
   @inline def fromUnsignedSafeDouble(x: Double): RuntimeLong =
@@ -1215,14 +1206,41 @@ object RuntimeLong {
   @inline def unsignedToDoubleApprox(lo: Int, hi: Int): Double =
     uintToDouble(hi) * TwoPow32 + uintToDouble(lo)
 
-  /** Approximates a non-negative (lo, hi) with a Double.
+  /** Approximates a signed (lo, hi) with a Double.
    *
    *  If `hi` is known to be non-negative, this method is equivalent to
    *  `unsignedToDoubleApprox`, but it can fold away part of the computation if
    *  `hi` is in fact constant.
    */
-  @inline def nonNegativeToDoubleApprox(lo: Int, hi: Int): Double =
+  @inline def signedToDoubleApprox(lo: Int, hi: Int): Double = {
+    /* We note a_u the mathematical value of a when interpreted as an unsigned
+     * quantity, and a_s when interpreted as a signed quantity.
+     *
+     * For x = (lo, hi), the result must be the correctly rounded value of x_s.
+     *
+     * If x_s >= 0, then hi_s >= 0. The obvious mathematical value of x_s is
+     *   x_s = hi_s * 2^32 + lo_u
+     *
+     * If x_s < 0, then hi_s < 0. The fundamental definition of two's
+     * completement means that
+     *   x_s = -2^64 + hi_u * 2^32 + lo_u
+     * Likewise,
+     *   hi_s = -2^32 + hi_u
+     *
+     * Now take the computation for the x_s >= 0 case, but substituting values
+     * for the negative case:
+     *   hi_s * 2^32 + lo_u
+     *     = (-2^32 + hi_u) * 2^32 + lo_u
+     *     = (-2^64 + hi_u * 2^32) + lo_u
+     * which is the correct mathematical result for x_s in the negative case.
+     *
+     * Therefore, we can always compute
+     *   x_s = hi_s * 2^32 + lo_u
+     * When computed with `Double` values, only the last `+` can be inexact,
+     * hence the result is correctly round.
+     */
     hi.toDouble * TwoPow32 + uintToDouble(lo)
+  }
 
   /** Interprets an `Int` as an unsigned integer and returns its value as a
    *  `Double`.
diff --git a/linker/shared/src/test/scala/org/scalajs/linker/LibrarySizeTest.scala b/linker/shared/src/test/scala/org/scalajs/linker/LibrarySizeTest.scala
@@ -70,9 +70,9 @@ class LibrarySizeTest {
     )
 
     testLinkedSizes(
-      expectedFastLinkSize = 148481,
-      expectedFullLinkSizeWithoutClosure = 87816,
-      expectedFullLinkSizeWithClosure = 20704,
+      expectedFastLinkSize = 147779,
+      expectedFullLinkSizeWithoutClosure = 87411,
+      expectedFullLinkSizeWithClosure = 20696,
       classDefs,
       moduleInitializers = MainTestModuleInitializers
     )
diff --git a/project/Build.scala b/project/Build.scala
@@ -2053,16 +2053,16 @@ object Build {
           case `default212Version` =>
             if (!useMinifySizes) {
               Some(ExpectedSizes(
-                  fastLink = 625000 to 626000,
+                  fastLink = 624000 to 625000,
                   fullLink = 94000 to 95000,
                   fastLinkGz = 75000 to 79000,
                   fullLinkGz = 24000 to 25000,
               ))
             } else {
               Some(ExpectedSizes(
-                  fastLink = 426000 to 427000,
-                  fullLink = 283000 to 284000,
-                  fastLinkGz = 61000 to 62000,
+                  fastLink = 425000 to 426000,
+                  fullLink = 282000 to 283000,
+                  fastLinkGz = 60000 to 61000,
                   fullLinkGz = 43000 to 44000,
               ))
             }
@@ -2078,7 +2078,7 @@ object Build {
             } else {
               Some(ExpectedSizes(
                   fastLink = 301000 to 302000,
-                  fullLink = 259000 to 260000,
+                  fullLink = 258000 to 259000,
                   fastLinkGz = 47000 to 48000,
                   fullLinkGz = 42000 to 43000,
               ))

Original file line number	Diff line number	Diff line change
`@@ -70,9 +70,9 @@ class LibrarySizeTest {`
`70`	`70`	`)`
`71`	`71`
`72`	`72`	`testLinkedSizes(`
`73`		`- expectedFastLinkSize = 148481,`
`74`		`- expectedFullLinkSizeWithoutClosure = 87816,`
`75`		`- expectedFullLinkSizeWithClosure = 20704,`
	`73`	`+ expectedFastLinkSize = 147779,`
	`74`	`+ expectedFullLinkSizeWithoutClosure = 87411,`
	`75`	`+ expectedFullLinkSizeWithClosure = 20696,`
`76`	`76`	`classDefs,`
`77`	`77`	`moduleInitializers = MainTestModuleInitializers`
`78`	`78`	`)`