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.
This commit is contained in:
Claude committed 2026-10-27 10:30:04 +00:00
1 parent ab5930ffbb
commit 44a9ca086c
4 files changed
+311 -32

No files matched your search

+71 -8
View File
@@ -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