fix(math): nextafter/nextafterf raise FE_OVERFLOW/FE_UNDERFLOW (glibc parity)

Differential probe of over/underflow exception cases found nextafter/nextafterf
omit the C99/IEEE F.10.8.3 flags glibc raises (scalbn/ldexp were already correct):
  nextafter(MAX, INF)        -> FE_OVERFLOW  (finite x, infinite result)
  nextafter(0, ±1)           -> FE_UNDERFLOW (result smallest subnormal)
  nextafter(MIN_POSITIVE, 0) -> FE_UNDERFLOW (result subnormal)
  (+ f32 nextafterf, same)

Per the spec: nextafter raises OVERFLOW(+INEXACT) when x is finite and the result
is infinite, and UNDERFLOW(+INEXACT) when the result is subnormal or zero and
differs from x. libm returns the correct value but omits the flags. Fix: re-raise
via a hardware op (MAX*MAX -> inf+OVERFLOW; MIN_POSITIVE^2 -> 0+UNDERFLOW) on the
boundary results only; x==y and normal results raise nothing.

Gate: conformance_diff_fp_exceptions extended with the nextafter cases (flags
exact vs host glibc). Value unchanged (libm's result returned as-is). All 155
math lib tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: Dicklesworthstone

crates/frankenlibc-abi/tests/conformance_diff_fp_exceptions.rs

@@ -17,6 +17,7 @@ unsafe extern "C" {
     fn acosh(x: f64) -> f64; fn atanh(x: f64) -> f64; fn tgamma(x: f64) -> f64; fn fmod(x: f64, y: f64) -> f64;
     fn logf(x: f32)->f32; fn log2f(x: f32)->f32; fn log10f(x: f32)->f32; fn sqrtf(x: f32)->f32;
     fn acosf(x: f32)->f32; fn acoshf(x: f32)->f32; fn tgammaf(x: f32)->f32; fn powf(x: f32,y: f32)->f32;
+    fn nextafter(x: f64, y: f64) -> f64; fn nextafterf(x: f32, y: f32) -> f32;
 }
 const HARD: c_int = 0x1D; // INVALID|DIVBYZERO|OVERFLOW|UNDERFLOW (drop noisy INEXACT)
 fn key(x: f64) -> i64 { let b = x.to_bits() as i64; if b < 0 { i64::MIN - b } else { b } }
@@ -89,5 +90,23 @@ fn fp_exception_and_value_parity_vs_glibc() {
     chkf!("tgammaf(-1)", fl::tgammaf(-1.0), tgammaf(-1.0));
     chkf!("tgammaf(-5)", fl::tgammaf(-5.0), tgammaf(-5.0));
     chkf!("powf(0,-1)", fl::powf(0.0,-1.0), powf(0.0,-1.0));
+
+    // nextafter / nextafterf: C99 F.10.8.3 OVERFLOW (finite->inf) + UNDERFLOW
+    // (result subnormal/zero). The flag-only macros reuse chkf; for f64 wrap via
+    // a closure-free direct call.
+    macro_rules! chk2 { ($lbl:literal, $flf:expr, $gf:expr) => {{
+        unsafe { feclearexcept(HARD); } let _ = std::hint::black_box($flf); let ff = unsafe { fetestexcept(HARD) };
+        unsafe { feclearexcept(HARD); } let _ = std::hint::black_box(unsafe { $gf }); let gf = unsafe { fetestexcept(HARD) };
+        if (ff & HARD) != (gf & HARD) { div.push(format!("{} flags: fl={:#x} glibc={:#x}", $lbl, ff & HARD, gf & HARD)); }
+    }}; }
+    chk2!("nextafter(0,1)", fl::nextafter(0.0,1.0), nextafter(0.0,1.0));
+    chk2!("nextafter(0,-1)", fl::nextafter(0.0,-1.0), nextafter(0.0,-1.0));
+    chk2!("nextafter(MAX,INF)", fl::nextafter(f64::MAX,f64::INFINITY), nextafter(f64::MAX,f64::INFINITY));
+    chk2!("nextafter(minpos,0)", fl::nextafter(f64::MIN_POSITIVE,0.0), nextafter(f64::MIN_POSITIVE,0.0));
+    chk2!("nextafter(5,5)", fl::nextafter(5.0,5.0), nextafter(5.0,5.0));
+    chk2!("nextafter(1,2)", fl::nextafter(1.0,2.0), nextafter(1.0,2.0));
+    chk2!("nextafterf(0,1)", fl::nextafterf(0.0,1.0), nextafterf(0.0,1.0));
+    chk2!("nextafterf(MAX,INF)", fl::nextafterf(f32::MAX,f32::INFINITY), nextafterf(f32::MAX,f32::INFINITY));
+    chk2!("nextafterf(minpos,0)", fl::nextafterf(f32::MIN_POSITIVE,0.0), nextafterf(f32::MIN_POSITIVE,0.0));
     assert!(div.is_empty(), "fp-exception/value divergences vs glibc:\n  {}", div.join("\n  "));
 }

crates/frankenlibc-core/src/math/float.rs

@@ -174,7 +174,19 @@ pub fn scalbln(x: f64, n: i64) -> f64 {
 /// Return the next representable float after `x` toward `y`.
 #[inline]
 pub fn nextafter(x: f64, y: f64) -> f64 {
-    libm::nextafter(x, y)
+    let r = libm::nextafter(x, y);
+    // C99/IEEE F.10.8.3: nextafter raises FE_OVERFLOW (+INEXACT) when x is finite
+    // and the result is infinite, and FE_UNDERFLOW (+INEXACT) when the result is
+    // subnormal or zero (and differs from x). libm omits these flags; re-raise via
+    // a hardware op (safe; only on these boundary results).
+    if x.is_finite() && r.is_infinite() {
+        let _ = core::hint::black_box(core::hint::black_box(f64::MAX) * core::hint::black_box(f64::MAX));
+    } else if r != x && r.abs() < f64::MIN_POSITIVE {
+        let _ = core::hint::black_box(
+            core::hint::black_box(f64::MIN_POSITIVE) * core::hint::black_box(f64::MIN_POSITIVE),
+        );
+    }
+    r
 }
 
 /// Return the next representable `f64` after `x` toward `y` (long double direction).

crates/frankenlibc-core/src/math/float32.rs

@@ -577,7 +577,17 @@ pub fn scalblnf(x: f32, n: i64) -> f32 {
 
 #[inline]
 pub fn nextafterf(x: f32, y: f32) -> f32 {
-    libm::nextafterf(x, y)
+    let r = libm::nextafterf(x, y);
+    // C99/IEEE: FE_OVERFLOW when finite -> infinite; FE_UNDERFLOW when the result
+    // is subnormal/zero and differs from x. libm omits these; re-raise.
+    if x.is_finite() && r.is_infinite() {
+        let _ = core::hint::black_box(core::hint::black_box(f32::MAX) * core::hint::black_box(f32::MAX));
+    } else if r != x && r.abs() < f32::MIN_POSITIVE {
+        let _ = core::hint::black_box(
+            core::hint::black_box(f32::MIN_POSITIVE) * core::hint::black_box(f32::MIN_POSITIVE),
+        );
+    }
+    r
 }
 
 /// Return the next representable `f32` after `x` toward `y` (long double direction).