From 44a9ca086ca92c4be9cca764a995e3d0235b372b Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 27 Oct 2026 10:30:04 +0000 Subject: [PATCH] std/softfloat: compare non-negative, non-NaN operands directly The f64 and f32 comparison, min and max functions now compare the bit patterns directly when neither operand is negative or a NaN, and call the unchanged general code (now f64_cmp_slow and f32_cmp_slow) otherwise. Results are unchanged: the ops harness and the old-vs-new differential test report zero mismatches. --- release/c/wuffs-unsupported-snapshot.c | 180 ++++++++++++++++++++++--- std/softfloat/README.md | 5 + std/softfloat/softfloat.wuffs | 79 +++++++++-- std/softfloat/softfloat_f32.wuffs | 79 +++++++++-- 4 files changed, 311 insertions(+), 32 deletions(-) diff --git a/release/c/wuffs-unsupported-snapshot.c b/release/c/wuffs-unsupported-snapshot.c index 6e516516..3fd992ac 100644 --- a/release/c/wuffs-unsupported-snapshot.c +++ b/release/c/wuffs-unsupported-snapshot.c @@ -41204,6 +41204,13 @@ wuffs_softfloat__arith__f64_propagate_nan( uint64_t a_a, uint64_t a_b); +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_softfloat__arith__f64_cmp_slow( + const wuffs_softfloat__arith* self, + uint64_t a_a, + uint64_t a_b); + WUFFS_BASE__GENERATED_C_CODE static uint64_t wuffs_softfloat__arith__f64_add_normal( @@ -41270,6 +41277,13 @@ wuffs_softfloat__arith__slow_f32_mul( uint32_t a_a, uint32_t a_b); +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_softfloat__arith__f32_cmp_slow( + const wuffs_softfloat__arith* self, + uint32_t a_a, + uint32_t a_b); + // ---------------- VTables // ---------------- Initializer Implementations @@ -41668,6 +41682,25 @@ wuffs_softfloat__arith__f64_cmp( return 0; } + if ((a_a | a_b) <= 9218868437227405312u) { + if (a_a < a_b) { + return 0u; + } else if (a_a == a_b) { + return 1u; + } + return 2u; + } + return wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b); +} + +// -------- func softfloat.arith.f64_cmp_slow + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_softfloat__arith__f64_cmp_slow( + const wuffs_softfloat__arith* self, + uint64_t a_a, + uint64_t a_b) { uint64_t v_ka = 0; uint64_t v_kb = 0; @@ -41708,7 +41741,13 @@ wuffs_softfloat__arith__f64_eq( return 0; } - if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 1u) { + if ((a_a | a_b) <= 9218868437227405312u) { + if (a_a == a_b) { + return 1u; + } + return 0u; + } + if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 1u) { return 1u; } return 0u; @@ -41730,7 +41769,13 @@ wuffs_softfloat__arith__f64_ne( return 0; } - if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 1u) { + if ((a_a | a_b) <= 9218868437227405312u) { + if (a_a != a_b) { + return 1u; + } + return 0u; + } + if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 1u) { return 0u; } return 1u; @@ -41752,7 +41797,13 @@ wuffs_softfloat__arith__f64_lt( return 0; } - if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 0u) { + if ((a_a | a_b) <= 9218868437227405312u) { + if (a_a < a_b) { + return 1u; + } + return 0u; + } + if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 0u) { return 1u; } return 0u; @@ -41774,7 +41825,13 @@ wuffs_softfloat__arith__f64_le( return 0; } - if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) <= 1u) { + if ((a_a | a_b) <= 9218868437227405312u) { + if (a_a <= a_b) { + return 1u; + } + return 0u; + } + if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) <= 1u) { return 1u; } return 0u; @@ -41796,7 +41853,13 @@ wuffs_softfloat__arith__f64_gt( return 0; } - if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 2u) { + if ((a_a | a_b) <= 9218868437227405312u) { + if (a_a > a_b) { + return 1u; + } + return 0u; + } + if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 2u) { return 1u; } return 0u; @@ -41820,7 +41883,13 @@ wuffs_softfloat__arith__f64_ge( uint32_t v_c = 0; - v_c = wuffs_softfloat__arith__f64_cmp(self, a_a, a_b); + if ((a_a | a_b) <= 9218868437227405312u) { + if (a_a >= a_b) { + return 1u; + } + return 0u; + } + v_c = wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b); if ((v_c == 1u) || (v_c == 2u)) { return 1u; } @@ -41843,7 +41912,13 @@ wuffs_softfloat__arith__f64_min( return 0; } - if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 0u) { + if ((a_a | a_b) <= 9218868437227405312u) { + if (a_a < a_b) { + return a_a; + } + return a_b; + } + if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 0u) { return a_a; } return a_b; @@ -41865,7 +41940,13 @@ wuffs_softfloat__arith__f64_max( return 0; } - if (wuffs_softfloat__arith__f64_cmp(self, a_a, a_b) == 2u) { + if ((a_a | a_b) <= 9218868437227405312u) { + if (a_a > a_b) { + return a_a; + } + return a_b; + } + if (wuffs_softfloat__arith__f64_cmp_slow(self, a_a, a_b) == 2u) { return a_a; } return a_b; @@ -43057,6 +43138,25 @@ wuffs_softfloat__arith__f32_cmp( return 0; } + if ((a_a | a_b) <= 2139095040u) { + if (a_a < a_b) { + return 0u; + } else if (a_a == a_b) { + return 1u; + } + return 2u; + } + return wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b); +} + +// -------- func softfloat.arith.f32_cmp_slow + +WUFFS_BASE__GENERATED_C_CODE +static uint32_t +wuffs_softfloat__arith__f32_cmp_slow( + const wuffs_softfloat__arith* self, + uint32_t a_a, + uint32_t a_b) { uint32_t v_ka = 0; uint32_t v_kb = 0; @@ -43097,7 +43197,13 @@ wuffs_softfloat__arith__f32_eq( return 0; } - if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 1u) { + if ((a_a | a_b) <= 2139095040u) { + if (a_a == a_b) { + return 1u; + } + return 0u; + } + if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 1u) { return 1u; } return 0u; @@ -43119,7 +43225,13 @@ wuffs_softfloat__arith__f32_ne( return 0; } - if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 1u) { + if ((a_a | a_b) <= 2139095040u) { + if (a_a != a_b) { + return 1u; + } + return 0u; + } + if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 1u) { return 0u; } return 1u; @@ -43141,7 +43253,13 @@ wuffs_softfloat__arith__f32_lt( return 0; } - if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 0u) { + if ((a_a | a_b) <= 2139095040u) { + if (a_a < a_b) { + return 1u; + } + return 0u; + } + if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 0u) { return 1u; } return 0u; @@ -43163,7 +43281,13 @@ wuffs_softfloat__arith__f32_le( return 0; } - if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) <= 1u) { + if ((a_a | a_b) <= 2139095040u) { + if (a_a <= a_b) { + return 1u; + } + return 0u; + } + if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) <= 1u) { return 1u; } return 0u; @@ -43185,7 +43309,13 @@ wuffs_softfloat__arith__f32_gt( return 0; } - if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 2u) { + if ((a_a | a_b) <= 2139095040u) { + if (a_a > a_b) { + return 1u; + } + return 0u; + } + if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 2u) { return 1u; } return 0u; @@ -43209,7 +43339,13 @@ wuffs_softfloat__arith__f32_ge( uint32_t v_c = 0; - v_c = wuffs_softfloat__arith__f32_cmp(self, a_a, a_b); + if ((a_a | a_b) <= 2139095040u) { + if (a_a >= a_b) { + return 1u; + } + return 0u; + } + v_c = wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b); if ((v_c == 1u) || (v_c == 2u)) { return 1u; } @@ -43232,7 +43368,13 @@ wuffs_softfloat__arith__f32_min( return 0; } - if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 0u) { + if ((a_a | a_b) <= 2139095040u) { + if (a_a < a_b) { + return a_a; + } + return a_b; + } + if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 0u) { return a_a; } return a_b; @@ -43254,7 +43396,13 @@ wuffs_softfloat__arith__f32_max( return 0; } - if (wuffs_softfloat__arith__f32_cmp(self, a_a, a_b) == 2u) { + if ((a_a | a_b) <= 2139095040u) { + if (a_a > a_b) { + return a_a; + } + return a_b; + } + if (wuffs_softfloat__arith__f32_cmp_slow(self, a_a, a_b) == 2u) { return a_a; } return a_b; diff --git a/std/softfloat/README.md b/std/softfloat/README.md index 84ae6e9b..e9b1dc43 100644 --- a/std/softfloat/README.md +++ b/std/softfloat/README.md @@ -118,6 +118,11 @@ Newsletter, 1995). The tests confirm this against hardware, including for subnormal `f32` results. The fast paths never produce a NaN, so NaN results (and their payloads) are exactly those of the "via `f64`" computation. +The comparison functions (`f64_cmp`, `f64_lt`, `f64_min`, etc. and their `f32` +counterparts) compare the bit patterns directly when neither operand is +negative or a NaN (when `a | b` is at most the bit pattern of `+inf`), and +otherwise call `f64_cmp_slow` or `f32_cmp_slow`. + ## log2 diff --git a/std/softfloat/softfloat.wuffs b/std/softfloat/softfloat.wuffs index 0df236f9..65bd77e5 100644 --- a/std/softfloat/softfloat.wuffs +++ b/std/softfloat/softfloat.wuffs @@ -265,6 +265,21 @@ pub func arith.f64_abs(a: base.u64) base.u64 { // f64_cmp compares a and b, returning 0 if (a < b), 1 if (a == b), 2 if (a // > b) and 3 if they are unordered (either is a NaN). -0 and +0 compare equal. pub func arith.f64_cmp(a: base.u64, b: base.u64) base.u32 { + if (args.a | args.b) <= F64_INF { + // Fast path: neither is negative (the sign bits are clear) or a NaN + // (both are at most +inf), so the bit patterns sort like the values. + if args.a < args.b { + return 0 + } else if args.a == args.b { + return 1 + } + return 2 + } + return this.f64_cmp_slow(a: args.a, b: args.b) +} + +// f64_cmp_slow is f64_cmp without the fast path. +pri func arith.f64_cmp_slow(a: base.u64, b: base.u64) base.u32 { var ka : base.u64 var kb : base.u64 @@ -297,35 +312,65 @@ pub func arith.f64_cmp(a: base.u64, b: base.u64) base.u32 { // true), and -0 equals +0. pub func arith.f64_eq(a: base.u64, b: base.u64) base.u32 { - if this.f64_cmp(a: args.a, b: args.b) == 1 { + if (args.a | args.b) <= F64_INF { + if args.a == args.b { + return 1 + } + return 0 + } + if this.f64_cmp_slow(a: args.a, b: args.b) == 1 { return 1 } return 0 } pub func arith.f64_ne(a: base.u64, b: base.u64) base.u32 { - if this.f64_cmp(a: args.a, b: args.b) == 1 { + if (args.a | args.b) <= F64_INF { + if args.a <> args.b { + return 1 + } + return 0 + } + if this.f64_cmp_slow(a: args.a, b: args.b) == 1 { return 0 } return 1 } pub func arith.f64_lt(a: base.u64, b: base.u64) base.u32 { - if this.f64_cmp(a: args.a, b: args.b) == 0 { + if (args.a | args.b) <= F64_INF { + if args.a < args.b { + return 1 + } + return 0 + } + if this.f64_cmp_slow(a: args.a, b: args.b) == 0 { return 1 } return 0 } pub func arith.f64_le(a: base.u64, b: base.u64) base.u32 { - if this.f64_cmp(a: args.a, b: args.b) <= 1 { + if (args.a | args.b) <= F64_INF { + if args.a <= args.b { + return 1 + } + return 0 + } + if this.f64_cmp_slow(a: args.a, b: args.b) <= 1 { return 1 } return 0 } pub func arith.f64_gt(a: base.u64, b: base.u64) base.u32 { - if this.f64_cmp(a: args.a, b: args.b) == 2 { + if (args.a | args.b) <= F64_INF { + if args.a > args.b { + return 1 + } + return 0 + } + if this.f64_cmp_slow(a: args.a, b: args.b) == 2 { return 1 } return 0 @@ -334,7 +379,13 @@ pub func arith.f64_gt(a: base.u64, b: base.u64) base.u32 { pub func arith.f64_ge(a: base.u64, b: base.u64) base.u32 { var c : base.u32 - c = this.f64_cmp(a: args.a, b: args.b) + if (args.a | args.b) <= F64_INF { + if args.a >= args.b { + return 1 + } + return 0 + } + c = this.f64_cmp_slow(a: args.a, b: args.b) if (c == 1) or (c == 2) { return 1 } @@ -345,7 +396,13 @@ pub func arith.f64_ge(a: base.u64, b: base.u64) base.u32 { // Note that this is not IEEE 754 minNum: f64_min(NaN, x) and f64_min(x, NaN) // both return the second argument, and f64_min(-0, +0) returns +0. pub func arith.f64_min(a: base.u64, b: base.u64) base.u64 { - if this.f64_cmp(a: args.a, b: args.b) == 0 { + if (args.a | args.b) <= F64_INF { + if args.a < args.b { + return args.a + } + return args.b + } + if this.f64_cmp_slow(a: args.a, b: args.b) == 0 { return args.a } return args.b @@ -353,7 +410,13 @@ pub func arith.f64_min(a: base.u64, b: base.u64) base.u64 { // f64_max returns ((a > b) ? a : b), like brotli's BROTLI_MAX(double, a, b). pub func arith.f64_max(a: base.u64, b: base.u64) base.u64 { - if this.f64_cmp(a: args.a, b: args.b) == 2 { + if (args.a | args.b) <= F64_INF { + if args.a > args.b { + return args.a + } + return args.b + } + if this.f64_cmp_slow(a: args.a, b: args.b) == 2 { return args.a } return args.b diff --git a/std/softfloat/softfloat_f32.wuffs b/std/softfloat/softfloat_f32.wuffs index 32ca0e39..c49d64e9 100644 --- a/std/softfloat/softfloat_f32.wuffs +++ b/std/softfloat/softfloat_f32.wuffs @@ -334,6 +334,21 @@ pub func arith.f32_div(a: base.u32, b: base.u32) base.u32 { // f32_cmp compares a and b, returning 0 if (a < b), 1 if (a == b), 2 if (a // > b) and 3 if they are unordered (either is a NaN). -0 and +0 compare equal. pub func arith.f32_cmp(a: base.u32, b: base.u32) base.u32 { + if (args.a | args.b) <= F32_INF { + // Fast path: neither is negative (the sign bits are clear) or a NaN + // (both are at most +inf), so the bit patterns sort like the values. + if args.a < args.b { + return 0 + } else if args.a == args.b { + return 1 + } + return 2 + } + return this.f32_cmp_slow(a: args.a, b: args.b) +} + +// f32_cmp_slow is f32_cmp without the fast path. +pri func arith.f32_cmp_slow(a: base.u32, b: base.u32) base.u32 { var ka : base.u32 var kb : base.u32 @@ -364,35 +379,65 @@ pub func arith.f32_cmp(a: base.u32, b: base.u32) base.u32 { // true), and -0 equals +0. pub func arith.f32_eq(a: base.u32, b: base.u32) base.u32 { - if this.f32_cmp(a: args.a, b: args.b) == 1 { + if (args.a | args.b) <= F32_INF { + if args.a == args.b { + return 1 + } + return 0 + } + if this.f32_cmp_slow(a: args.a, b: args.b) == 1 { return 1 } return 0 } pub func arith.f32_ne(a: base.u32, b: base.u32) base.u32 { - if this.f32_cmp(a: args.a, b: args.b) == 1 { + if (args.a | args.b) <= F32_INF { + if args.a <> args.b { + return 1 + } + return 0 + } + if this.f32_cmp_slow(a: args.a, b: args.b) == 1 { return 0 } return 1 } pub func arith.f32_lt(a: base.u32, b: base.u32) base.u32 { - if this.f32_cmp(a: args.a, b: args.b) == 0 { + if (args.a | args.b) <= F32_INF { + if args.a < args.b { + return 1 + } + return 0 + } + if this.f32_cmp_slow(a: args.a, b: args.b) == 0 { return 1 } return 0 } pub func arith.f32_le(a: base.u32, b: base.u32) base.u32 { - if this.f32_cmp(a: args.a, b: args.b) <= 1 { + if (args.a | args.b) <= F32_INF { + if args.a <= args.b { + return 1 + } + return 0 + } + if this.f32_cmp_slow(a: args.a, b: args.b) <= 1 { return 1 } return 0 } pub func arith.f32_gt(a: base.u32, b: base.u32) base.u32 { - if this.f32_cmp(a: args.a, b: args.b) == 2 { + if (args.a | args.b) <= F32_INF { + if args.a > args.b { + return 1 + } + return 0 + } + if this.f32_cmp_slow(a: args.a, b: args.b) == 2 { return 1 } return 0 @@ -401,7 +446,13 @@ pub func arith.f32_gt(a: base.u32, b: base.u32) base.u32 { pub func arith.f32_ge(a: base.u32, b: base.u32) base.u32 { var c : base.u32 - c = this.f32_cmp(a: args.a, b: args.b) + if (args.a | args.b) <= F32_INF { + if args.a >= args.b { + return 1 + } + return 0 + } + c = this.f32_cmp_slow(a: args.a, b: args.b) if (c == 1) or (c == 2) { return 1 } @@ -412,7 +463,13 @@ pub func arith.f32_ge(a: base.u32, b: base.u32) base.u32 { // Note that this is not IEEE 754 minNum: f32_min(NaN, x) and f32_min(x, NaN) // both return the second argument, and f32_min(-0, +0) returns +0. pub func arith.f32_min(a: base.u32, b: base.u32) base.u32 { - if this.f32_cmp(a: args.a, b: args.b) == 0 { + if (args.a | args.b) <= F32_INF { + if args.a < args.b { + return args.a + } + return args.b + } + if this.f32_cmp_slow(a: args.a, b: args.b) == 0 { return args.a } return args.b @@ -420,7 +477,13 @@ pub func arith.f32_min(a: base.u32, b: base.u32) base.u32 { // f32_max returns ((a > b) ? a : b), like brotli's BROTLI_MAX(float, a, b). pub func arith.f32_max(a: base.u32, b: base.u32) base.u32 { - if this.f32_cmp(a: args.a, b: args.b) == 2 { + if (args.a | args.b) <= F32_INF { + if args.a > args.b { + return args.a + } + return args.b + } + if this.f32_cmp_slow(a: args.a, b: args.b) == 2 { return args.a } return args.b