fix(math): log1p/log1pf raise FE_DIVBYZERO at the x=-1 pole (glibc parity)

Differential probe of the pole cases I'd missed: log1p(-1) = log(0) = -inf is a
pole where glibc raises FE_DIVBYZERO, but libm::log1p returns -inf without the
flag (same omit-pattern as the earlier log/tgamma fixes). atanh(±1) poles and
log1p(x<-1) domain errors were already correct (libm raises those).

Fix: re-raise FE_DIVBYZERO when x == -1.0 via the force_eval idiom (-1.0/0.0 ->
-inf + DIVBYZERO); the value is unchanged. f32 log1pf likewise.

Gate: conformance_diff_fp_exceptions extended with the atanh/log1p pole+domain
cases (incl. the verified-correct atanh poles and log1p domain, pinned). All 155
math lib tests pass; 0 divergences vs host glibc.

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

Author: Dicklesworthstone

crates/frankenlibc-abi/tests/conformance_diff_fp_exceptions.rs

@@ -19,6 +19,7 @@ unsafe extern "C" {
     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;
     fn lgamma(x: f64)->f64; fn lgammaf(x: f32)->f32; fn exp2(x: f64)->f64; fn expm1(x: f64)->f64;
+    fn atanhf(x: f32)->f32; fn log1p(x: f64)->f64; fn log1pf(x: 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 } }
@@ -124,5 +125,18 @@ fn fp_exception_and_value_parity_vs_glibc() {
     chk2!("expm1(1000)", fl::expm1(1000.0), expm1(1000.0));
     chk2!("pow(10,400)", fl::pow(10.0,400.0), pow(10.0,400.0));
     chk2!("pow(0.1,400)", fl::pow(0.1,400.0), pow(0.1,400.0));
+
+    // atanh / log1p poles (DIVBYZERO) + domain (INVALID): log1p(-1)/log1pf(-1)
+    // were under-raising the pole flag (fixed); the rest pin currently-correct
+    // behavior (libm raises atanh poles + log1p domain).
+    chk2!("atanh(1)", fl::atanh(1.0), atanh(1.0));
+    chk2!("atanh(-1)", fl::atanh(-1.0), atanh(-1.0));
+    chk2!("atanh(2)", fl::atanh(2.0), atanh(2.0));
+    chk2!("atanhf(1)", fl::atanhf(1.0), atanhf(1.0));
+    chk2!("log1p(-1)", fl::log1p(-1.0), log1p(-1.0));
+    chk2!("log1p(-2)", fl::log1p(-2.0), log1p(-2.0));
+    chk2!("log1p(-1.5)", fl::log1p(-1.5), log1p(-1.5));
+    chk2!("log1pf(-1)", fl::log1pf(-1.0), log1pf(-1.0));
+    chk2!("log1pf(-2)", fl::log1pf(-2.0), log1pf(-2.0));
     assert!(div.is_empty(), "fp-exception/value divergences vs glibc:\n  {}", div.join("\n  "));
 }

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

@@ -481,6 +481,11 @@ pub fn log10(x: f64) -> f64 {
 
 #[inline]
 pub fn log1p(x: f64) -> f64 {
+    // log1p(-1) = log(0) = -inf is a pole: glibc raises FE_DIVBYZERO, libm omits
+    // it. (x < -1 domain errors raise FE_INVALID, which libm already does.)
+    if x == -1.0 {
+        let _ = core::hint::black_box(core::hint::black_box(-1.0_f64) / core::hint::black_box(0.0_f64));
+    }
     libm::log1p(x)
 }
 

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

@@ -427,6 +427,10 @@ pub fn expm1f(x: f32) -> f32 {
 
 #[inline]
 pub fn log1pf(x: f32) -> f32 {
+    // log1pf(-1) = -inf is a pole: glibc raises FE_DIVBYZERO, libm omits it.
+    if x == -1.0 {
+        fe_divbyzero_f32();
+    }
     libm::log1pf(x)
 }