From 2ff14448863ac1a1dd9533461708e29aae170c2d Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Wed, 17 Apr 2024 14:06:31 +0200
Subject: Adding debian version 1.65.0+dfsg1-2.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 vendor/compiler_builtins/libm/src/math/acosh.rs    |  1 +
 vendor/compiler_builtins/libm/src/math/acoshf.rs   |  1 +
 vendor/compiler_builtins/libm/src/math/asinh.rs    |  1 +
 vendor/compiler_builtins/libm/src/math/asinhf.rs   |  1 +
 vendor/compiler_builtins/libm/src/math/atanh.rs    |  1 +
 vendor/compiler_builtins/libm/src/math/atanhf.rs   |  1 +
 vendor/compiler_builtins/libm/src/math/copysign.rs |  1 +
 .../compiler_builtins/libm/src/math/copysignf.rs   |  1 +
 vendor/compiler_builtins/libm/src/math/erf.rs      |  1 +
 vendor/compiler_builtins/libm/src/math/erff.rs     |  1 +
 vendor/compiler_builtins/libm/src/math/exp10.rs    |  5 ++--
 vendor/compiler_builtins/libm/src/math/exp10f.rs   |  5 ++--
 vendor/compiler_builtins/libm/src/math/fenv.rs     |  6 ----
 vendor/compiler_builtins/libm/src/math/fmaf.rs     | 35 ++++++++++++++--------
 vendor/compiler_builtins/libm/src/math/ilogb.rs    |  1 +
 vendor/compiler_builtins/libm/src/math/ilogbf.rs   |  1 +
 vendor/compiler_builtins/libm/src/math/lgamma.rs   |  1 +
 vendor/compiler_builtins/libm/src/math/lgamma_r.rs |  3 +-
 vendor/compiler_builtins/libm/src/math/lgammaf.rs  |  1 +
 .../compiler_builtins/libm/src/math/lgammaf_r.rs   |  3 +-
 .../libm/src/math/rem_pio2_large.rs                |  2 +-
 vendor/compiler_builtins/libm/src/math/sincos.rs   |  1 +
 vendor/compiler_builtins/libm/src/math/sincosf.rs  |  1 +
 vendor/compiler_builtins/libm/src/math/tgamma.rs   | 13 ++++----
 vendor/compiler_builtins/libm/src/math/tgammaf.rs  |  1 +
 25 files changed, 58 insertions(+), 31 deletions(-)

(limited to 'vendor/compiler_builtins/libm/src')

diff --git a/vendor/compiler_builtins/libm/src/math/acosh.rs b/vendor/compiler_builtins/libm/src/math/acosh.rs
index ac7a5f1c6..d1f5b9fa9 100644
--- a/vendor/compiler_builtins/libm/src/math/acosh.rs
+++ b/vendor/compiler_builtins/libm/src/math/acosh.rs
@@ -7,6 +7,7 @@ const LN2: f64 = 0.693147180559945309417232121458176568; /* 0x3fe62e42,  0xfefa3
 /// Calculates the inverse hyperbolic cosine of `x`.
 /// Is defined as `log(x + sqrt(x*x-1))`.
 /// `x` must be a number greater than or equal to 1.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn acosh(x: f64) -> f64 {
     let u = x.to_bits();
     let e = ((u >> 52) as usize) & 0x7ff;
diff --git a/vendor/compiler_builtins/libm/src/math/acoshf.rs b/vendor/compiler_builtins/libm/src/math/acoshf.rs
index 0879e1edb..ad3455fdd 100644
--- a/vendor/compiler_builtins/libm/src/math/acoshf.rs
+++ b/vendor/compiler_builtins/libm/src/math/acoshf.rs
@@ -7,6 +7,7 @@ const LN2: f32 = 0.693147180559945309417232121458176568;
 /// Calculates the inverse hyperbolic cosine of `x`.
 /// Is defined as `log(x + sqrt(x*x-1))`.
 /// `x` must be a number greater than or equal to 1.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn acoshf(x: f32) -> f32 {
     let u = x.to_bits();
     let a = u & 0x7fffffff;
diff --git a/vendor/compiler_builtins/libm/src/math/asinh.rs b/vendor/compiler_builtins/libm/src/math/asinh.rs
index 14295357a..0abd80c2f 100644
--- a/vendor/compiler_builtins/libm/src/math/asinh.rs
+++ b/vendor/compiler_builtins/libm/src/math/asinh.rs
@@ -7,6 +7,7 @@ const LN2: f64 = 0.693147180559945309417232121458176568; /* 0x3fe62e42,  0xfefa3
 ///
 /// Calculates the inverse hyperbolic sine of `x`.
 /// Is defined as `sgn(x)*log(|x|+sqrt(x*x+1))`.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn asinh(mut x: f64) -> f64 {
     let mut u = x.to_bits();
     let e = ((u >> 52) as usize) & 0x7ff;
diff --git a/vendor/compiler_builtins/libm/src/math/asinhf.rs b/vendor/compiler_builtins/libm/src/math/asinhf.rs
index e22a29132..09c77823e 100644
--- a/vendor/compiler_builtins/libm/src/math/asinhf.rs
+++ b/vendor/compiler_builtins/libm/src/math/asinhf.rs
@@ -7,6 +7,7 @@ const LN2: f32 = 0.693147180559945309417232121458176568;
 ///
 /// Calculates the inverse hyperbolic sine of `x`.
 /// Is defined as `sgn(x)*log(|x|+sqrt(x*x+1))`.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn asinhf(mut x: f32) -> f32 {
     let u = x.to_bits();
     let i = u & 0x7fffffff;
diff --git a/vendor/compiler_builtins/libm/src/math/atanh.rs b/vendor/compiler_builtins/libm/src/math/atanh.rs
index 79a989c42..b984c4ac6 100644
--- a/vendor/compiler_builtins/libm/src/math/atanh.rs
+++ b/vendor/compiler_builtins/libm/src/math/atanh.rs
@@ -5,6 +5,7 @@ use super::log1p;
 ///
 /// Calculates the inverse hyperbolic tangent of `x`.
 /// Is defined as `log((1+x)/(1-x))/2 = log1p(2x/(1-x))/2`.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn atanh(x: f64) -> f64 {
     let u = x.to_bits();
     let e = ((u >> 52) as usize) & 0x7ff;
diff --git a/vendor/compiler_builtins/libm/src/math/atanhf.rs b/vendor/compiler_builtins/libm/src/math/atanhf.rs
index 7b2f34d97..a1aa314a5 100644
--- a/vendor/compiler_builtins/libm/src/math/atanhf.rs
+++ b/vendor/compiler_builtins/libm/src/math/atanhf.rs
@@ -5,6 +5,7 @@ use super::log1pf;
 ///
 /// Calculates the inverse hyperbolic tangent of `x`.
 /// Is defined as `log((1+x)/(1-x))/2 = log1p(2x/(1-x))/2`.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn atanhf(mut x: f32) -> f32 {
     let mut u = x.to_bits();
     let sign = (u >> 31) != 0;
diff --git a/vendor/compiler_builtins/libm/src/math/copysign.rs b/vendor/compiler_builtins/libm/src/math/copysign.rs
index 1527fb6ea..1f4a35a33 100644
--- a/vendor/compiler_builtins/libm/src/math/copysign.rs
+++ b/vendor/compiler_builtins/libm/src/math/copysign.rs
@@ -2,6 +2,7 @@
 ///
 /// Constructs a number with the magnitude (absolute value) of its
 /// first argument, `x`, and the sign of its second argument, `y`.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn copysign(x: f64, y: f64) -> f64 {
     let mut ux = x.to_bits();
     let uy = y.to_bits();
diff --git a/vendor/compiler_builtins/libm/src/math/copysignf.rs b/vendor/compiler_builtins/libm/src/math/copysignf.rs
index 35148561a..6c346e3a5 100644
--- a/vendor/compiler_builtins/libm/src/math/copysignf.rs
+++ b/vendor/compiler_builtins/libm/src/math/copysignf.rs
@@ -2,6 +2,7 @@
 ///
 /// Constructs a number with the magnitude (absolute value) of its
 /// first argument, `x`, and the sign of its second argument, `y`.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn copysignf(x: f32, y: f32) -> f32 {
     let mut ux = x.to_bits();
     let uy = y.to_bits();
diff --git a/vendor/compiler_builtins/libm/src/math/erf.rs b/vendor/compiler_builtins/libm/src/math/erf.rs
index a2c617d34..5e21ba578 100644
--- a/vendor/compiler_builtins/libm/src/math/erf.rs
+++ b/vendor/compiler_builtins/libm/src/math/erf.rs
@@ -219,6 +219,7 @@ fn erfc2(ix: u32, mut x: f64) -> f64 {
 /// Calculates an approximation to the “error function”, which estimates
 /// the probability that an observation will fall within x standard
 /// deviations of the mean (assuming a normal distribution).
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn erf(x: f64) -> f64 {
     let r: f64;
     let s: f64;
diff --git a/vendor/compiler_builtins/libm/src/math/erff.rs b/vendor/compiler_builtins/libm/src/math/erff.rs
index 384052293..f74d4b632 100644
--- a/vendor/compiler_builtins/libm/src/math/erff.rs
+++ b/vendor/compiler_builtins/libm/src/math/erff.rs
@@ -130,6 +130,7 @@ fn erfc2(mut ix: u32, mut x: f32) -> f32 {
 /// Calculates an approximation to the “error function”, which estimates
 /// the probability that an observation will fall within x standard
 /// deviations of the mean (assuming a normal distribution).
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn erff(x: f32) -> f32 {
     let r: f32;
     let s: f32;
diff --git a/vendor/compiler_builtins/libm/src/math/exp10.rs b/vendor/compiler_builtins/libm/src/math/exp10.rs
index 9537f76f1..559930e10 100644
--- a/vendor/compiler_builtins/libm/src/math/exp10.rs
+++ b/vendor/compiler_builtins/libm/src/math/exp10.rs
@@ -6,16 +6,17 @@ const P10: &[f64] = &[
     1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
 ];
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn exp10(x: f64) -> f64 {
     let (mut y, n) = modf(x);
     let u: u64 = n.to_bits();
     /* fabs(n) < 16 without raising invalid on nan */
     if (u >> 52 & 0x7ff) < 0x3ff + 4 {
         if y == 0.0 {
-            return P10[((n as isize) + 15) as usize];
+            return i!(P10, ((n as isize) + 15) as usize);
         }
         y = exp2(LN10 * y);
-        return y * P10[((n as isize) + 15) as usize];
+        return y * i!(P10, ((n as isize) + 15) as usize);
     }
     return pow(10.0, x);
 }
diff --git a/vendor/compiler_builtins/libm/src/math/exp10f.rs b/vendor/compiler_builtins/libm/src/math/exp10f.rs
index d45fff36e..1279bc6c5 100644
--- a/vendor/compiler_builtins/libm/src/math/exp10f.rs
+++ b/vendor/compiler_builtins/libm/src/math/exp10f.rs
@@ -6,16 +6,17 @@ const P10: &[f32] = &[
     1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7,
 ];
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn exp10f(x: f32) -> f32 {
     let (mut y, n) = modff(x);
     let u = n.to_bits();
     /* fabsf(n) < 8 without raising invalid on nan */
     if (u >> 23 & 0xff) < 0x7f + 3 {
         if y == 0.0 {
-            return P10[((n as isize) + 7) as usize];
+            return i!(P10, ((n as isize) + 7) as usize);
         }
         y = exp2f(LN10_F32 * y);
-        return y * P10[((n as isize) + 7) as usize];
+        return y * i!(P10, ((n as isize) + 7) as usize);
     }
     return exp2(LN10_F64 * (x as f64)) as f32;
 }
diff --git a/vendor/compiler_builtins/libm/src/math/fenv.rs b/vendor/compiler_builtins/libm/src/math/fenv.rs
index 652e60324..c91272e82 100644
--- a/vendor/compiler_builtins/libm/src/math/fenv.rs
+++ b/vendor/compiler_builtins/libm/src/math/fenv.rs
@@ -5,7 +5,6 @@ pub(crate) const FE_UNDERFLOW: i32 = 0;
 pub(crate) const FE_INEXACT: i32 = 0;
 
 pub(crate) const FE_TONEAREST: i32 = 0;
-pub(crate) const FE_TOWARDZERO: i32 = 0;
 
 #[inline]
 pub(crate) fn feclearexcept(_mask: i32) -> i32 {
@@ -26,8 +25,3 @@ pub(crate) fn fetestexcept(_mask: i32) -> i32 {
 pub(crate) fn fegetround() -> i32 {
     FE_TONEAREST
 }
-
-#[inline]
-pub(crate) fn fesetround(_r: i32) -> i32 {
-    0
-}
diff --git a/vendor/compiler_builtins/libm/src/math/fmaf.rs b/vendor/compiler_builtins/libm/src/math/fmaf.rs
index 03d371c55..2848f2aee 100644
--- a/vendor/compiler_builtins/libm/src/math/fmaf.rs
+++ b/vendor/compiler_builtins/libm/src/math/fmaf.rs
@@ -29,8 +29,7 @@ use core::f32;
 use core::ptr::read_volatile;
 
 use super::fenv::{
-    feclearexcept, fegetround, feraiseexcept, fesetround, fetestexcept, FE_INEXACT, FE_TONEAREST,
-    FE_TOWARDZERO, FE_UNDERFLOW,
+    feclearexcept, fegetround, feraiseexcept, fetestexcept, FE_INEXACT, FE_TONEAREST, FE_UNDERFLOW,
 };
 
 /*
@@ -91,16 +90,28 @@ pub fn fmaf(x: f32, y: f32, mut z: f32) -> f32 {
      * If result is inexact, and exactly halfway between two float values,
      * we need to adjust the low-order bit in the direction of the error.
      */
-    fesetround(FE_TOWARDZERO);
-    // prevent `vxy + z` from being CSE'd with `xy + z` above
-    let vxy: f64 = unsafe { read_volatile(&xy) };
-    let mut adjusted_result: f64 = vxy + z as f64;
-    fesetround(FE_TONEAREST);
-    if result == adjusted_result {
-        ui = adjusted_result.to_bits();
+    let neg = ui >> 63 != 0;
+    let err = if neg == (z as f64 > xy) {
+        xy - result + z as f64
+    } else {
+        z as f64 - result + xy
+    };
+    if neg == (err < 0.0) {
         ui += 1;
-        adjusted_result = f64::from_bits(ui);
+    } else {
+        ui -= 1;
+    }
+    f64::from_bits(ui) as f32
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn issue_263() {
+        let a = f32::from_bits(1266679807);
+        let b = f32::from_bits(1300234242);
+        let c = f32::from_bits(1115553792);
+        let expected = f32::from_bits(1501560833);
+        assert_eq!(super::fmaf(a, b, c), expected);
     }
-    z = adjusted_result as f32;
-    z
 }
diff --git a/vendor/compiler_builtins/libm/src/math/ilogb.rs b/vendor/compiler_builtins/libm/src/math/ilogb.rs
index 0a380b7ef..7d74dcfb6 100644
--- a/vendor/compiler_builtins/libm/src/math/ilogb.rs
+++ b/vendor/compiler_builtins/libm/src/math/ilogb.rs
@@ -1,6 +1,7 @@
 const FP_ILOGBNAN: i32 = -1 - 0x7fffffff;
 const FP_ILOGB0: i32 = FP_ILOGBNAN;
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn ilogb(x: f64) -> i32 {
     let mut i: u64 = x.to_bits();
     let e = ((i >> 52) & 0x7ff) as i32;
diff --git a/vendor/compiler_builtins/libm/src/math/ilogbf.rs b/vendor/compiler_builtins/libm/src/math/ilogbf.rs
index b384fa4b2..0fa58748c 100644
--- a/vendor/compiler_builtins/libm/src/math/ilogbf.rs
+++ b/vendor/compiler_builtins/libm/src/math/ilogbf.rs
@@ -1,6 +1,7 @@
 const FP_ILOGBNAN: i32 = -1 - 0x7fffffff;
 const FP_ILOGB0: i32 = FP_ILOGBNAN;
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn ilogbf(x: f32) -> i32 {
     let mut i = x.to_bits();
     let e = ((i >> 23) & 0xff) as i32;
diff --git a/vendor/compiler_builtins/libm/src/math/lgamma.rs b/vendor/compiler_builtins/libm/src/math/lgamma.rs
index 5bc87e85e..a08bc5b64 100644
--- a/vendor/compiler_builtins/libm/src/math/lgamma.rs
+++ b/vendor/compiler_builtins/libm/src/math/lgamma.rs
@@ -1,5 +1,6 @@
 use super::lgamma_r;
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn lgamma(x: f64) -> f64 {
     lgamma_r(x).0
 }
diff --git a/vendor/compiler_builtins/libm/src/math/lgamma_r.rs b/vendor/compiler_builtins/libm/src/math/lgamma_r.rs
index 9533e882c..b26177e6e 100644
--- a/vendor/compiler_builtins/libm/src/math/lgamma_r.rs
+++ b/vendor/compiler_builtins/libm/src/math/lgamma_r.rs
@@ -152,7 +152,7 @@ fn sin_pi(mut x: f64) -> f64 {
     x = 2.0 * (x * 0.5 - floor(x * 0.5)); /* x mod 2.0 */
 
     n = (x * 4.0) as i32;
-    n = (n + 1) / 2;
+    n = div!(n + 1, 2);
     x -= (n as f64) * 0.5;
     x *= PI;
 
@@ -164,6 +164,7 @@ fn sin_pi(mut x: f64) -> f64 {
     }
 }
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn lgamma_r(mut x: f64) -> (f64, i32) {
     let u: u64 = x.to_bits();
     let mut t: f64;
diff --git a/vendor/compiler_builtins/libm/src/math/lgammaf.rs b/vendor/compiler_builtins/libm/src/math/lgammaf.rs
index dfdc87f96..a9c2da75b 100644
--- a/vendor/compiler_builtins/libm/src/math/lgammaf.rs
+++ b/vendor/compiler_builtins/libm/src/math/lgammaf.rs
@@ -1,5 +1,6 @@
 use super::lgammaf_r;
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn lgammaf(x: f32) -> f32 {
     lgammaf_r(x).0
 }
diff --git a/vendor/compiler_builtins/libm/src/math/lgammaf_r.rs b/vendor/compiler_builtins/libm/src/math/lgammaf_r.rs
index c5e559f46..723c90daf 100644
--- a/vendor/compiler_builtins/libm/src/math/lgammaf_r.rs
+++ b/vendor/compiler_builtins/libm/src/math/lgammaf_r.rs
@@ -88,7 +88,7 @@ fn sin_pi(mut x: f32) -> f32 {
     x = 2.0 * (x * 0.5 - floorf(x * 0.5)); /* x mod 2.0 */
 
     n = (x * 4.0) as isize;
-    n = (n + 1) / 2;
+    n = div!(n + 1, 2);
     y = (x as f64) - (n as f64) * 0.5;
     y *= 3.14159265358979323846;
     match n {
@@ -99,6 +99,7 @@ fn sin_pi(mut x: f32) -> f32 {
     }
 }
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn lgammaf_r(mut x: f32) -> (f32, i32) {
     let u = x.to_bits();
     let mut t: f32;
diff --git a/vendor/compiler_builtins/libm/src/math/rem_pio2_large.rs b/vendor/compiler_builtins/libm/src/math/rem_pio2_large.rs
index 65473f0ab..db97a39d4 100644
--- a/vendor/compiler_builtins/libm/src/math/rem_pio2_large.rs
+++ b/vendor/compiler_builtins/libm/src/math/rem_pio2_large.rs
@@ -27,7 +27,7 @@ const INIT_JK: [usize; 4] = [3, 4, 4, 6];
 //
 // NB: This table must have at least (e0-3)/24 + jk terms.
 //     For quad precision (e0 <= 16360, jk = 6), this is 686.
-#[cfg(target_pointer_width = "32")]
+#[cfg(any(target_pointer_width = "32", target_pointer_width = "16"))]
 const IPIO2: [i32; 66] = [
     0xA2F983, 0x6E4E44, 0x1529FC, 0x2757D1, 0xF534DD, 0xC0DB62, 0x95993C, 0x439041, 0xFE5163,
     0xABDEBB, 0xC561B7, 0x246E3A, 0x424DD2, 0xE00649, 0x2EEA09, 0xD1921C, 0xFE1DEB, 0x1CB129,
diff --git a/vendor/compiler_builtins/libm/src/math/sincos.rs b/vendor/compiler_builtins/libm/src/math/sincos.rs
index 4ab588412..ff5d87a1c 100644
--- a/vendor/compiler_builtins/libm/src/math/sincos.rs
+++ b/vendor/compiler_builtins/libm/src/math/sincos.rs
@@ -12,6 +12,7 @@
 
 use super::{get_high_word, k_cos, k_sin, rem_pio2};
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn sincos(x: f64) -> (f64, f64) {
     let s: f64;
     let c: f64;
diff --git a/vendor/compiler_builtins/libm/src/math/sincosf.rs b/vendor/compiler_builtins/libm/src/math/sincosf.rs
index 5304e8ca0..9a4c36104 100644
--- a/vendor/compiler_builtins/libm/src/math/sincosf.rs
+++ b/vendor/compiler_builtins/libm/src/math/sincosf.rs
@@ -23,6 +23,7 @@ const S2PIO2: f32 = 2.0 * PI_2; /* 0x400921FB, 0x54442D18 */
 const S3PIO2: f32 = 3.0 * PI_2; /* 0x4012D97C, 0x7F3321D2 */
 const S4PIO2: f32 = 4.0 * PI_2; /* 0x401921FB, 0x54442D18 */
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn sincosf(x: f32) -> (f32, f32) {
     let s: f32;
     let c: f32;
diff --git a/vendor/compiler_builtins/libm/src/math/tgamma.rs b/vendor/compiler_builtins/libm/src/math/tgamma.rs
index f8ccf669a..e64eff61f 100644
--- a/vendor/compiler_builtins/libm/src/math/tgamma.rs
+++ b/vendor/compiler_builtins/libm/src/math/tgamma.rs
@@ -38,7 +38,7 @@ fn sinpi(mut x: f64) -> f64 {
 
     /* reduce x into [-.25,.25] */
     n = (4.0 * x) as isize;
-    n = (n + 1) / 2;
+    n = div!(n + 1, 2);
     x -= (n as f64) * 0.5;
 
     x *= PI;
@@ -118,18 +118,19 @@ fn s(x: f64) -> f64 {
     /* to avoid overflow handle large x differently */
     if x < 8.0 {
         for i in (0..=N).rev() {
-            num = num * x + SNUM[i];
-            den = den * x + SDEN[i];
+            num = num * x + i!(SNUM, i);
+            den = den * x + i!(SDEN, i);
         }
     } else {
         for i in 0..=N {
-            num = num / x + SNUM[i];
-            den = den / x + SDEN[i];
+            num = num / x + i!(SNUM, i);
+            den = den / x + i!(SDEN, i);
         }
     }
     return num / den;
 }
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn tgamma(mut x: f64) -> f64 {
     let u: u64 = x.to_bits();
     let absx: f64;
@@ -157,7 +158,7 @@ pub fn tgamma(mut x: f64) -> f64 {
             return 0.0 / 0.0;
         }
         if x <= FACT.len() as f64 {
-            return FACT[(x as usize) - 1];
+            return i!(FACT, (x as usize) - 1);
         }
     }
 
diff --git a/vendor/compiler_builtins/libm/src/math/tgammaf.rs b/vendor/compiler_builtins/libm/src/math/tgammaf.rs
index a8f161f0c..23e3814f9 100644
--- a/vendor/compiler_builtins/libm/src/math/tgammaf.rs
+++ b/vendor/compiler_builtins/libm/src/math/tgammaf.rs
@@ -1,5 +1,6 @@
 use super::tgamma;
 
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn tgammaf(x: f32) -> f32 {
     tgamma(x as f64) as f32
 }
-- 
cgit v1.2.3