From a0a5bd85c913fe5f6c42bc11ef292e575f97ca6d Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Wed, 10 Jul 2019 08:42:28 -0700
Subject: [PATCH] Remove most `#[inline]` annotations

These annotations fall into a few categories

* Some simply aren't needed since functions will always be in the same
  CGU anyway and are already candidates for inlining.
* Many are on massive functions which shouldn't be inlined across crates
  due to code size concerns.
* Others aren't necessary since calls to this crate are rarely inlined
  anyway (since it's lowered through LLVM).

If this crate is called directly and inlining is needed then LTO can
always be turned on, otherwise this will benefit downstream consumers by
avoiding re-codegen'ing so many functions.
---
 src/math/acos.rs           | 2 --
 src/math/acosf.rs          | 2 --
 src/math/asin.rs           | 2 --
 src/math/asinf.rs          | 2 --
 src/math/atan.rs           | 1 -
 src/math/atan2.rs          | 1 -
 src/math/atan2f.rs         | 1 -
 src/math/atanf.rs          | 1 -
 src/math/cbrt.rs           | 1 -
 src/math/cbrtf.rs          | 1 -
 src/math/ceil.rs           | 1 -
 src/math/ceilf.rs          | 1 -
 src/math/cos.rs            | 1 -
 src/math/cosf.rs           | 1 -
 src/math/cosh.rs           | 1 -
 src/math/coshf.rs          | 1 -
 src/math/exp.rs            | 1 -
 src/math/exp2.rs           | 1 -
 src/math/exp2f.rs          | 1 -
 src/math/expf.rs           | 1 -
 src/math/expm1.rs          | 1 -
 src/math/expm1f.rs         | 1 -
 src/math/expo2.rs          | 1 -
 src/math/fabs.rs           | 1 -
 src/math/fabsf.rs          | 1 -
 src/math/fdim.rs           | 1 -
 src/math/fdimf.rs          | 1 -
 src/math/floor.rs          | 1 -
 src/math/floorf.rs         | 1 -
 src/math/fma.rs            | 3 ---
 src/math/fmaf.rs           | 1 -
 src/math/fmax.rs           | 1 -
 src/math/fmaxf.rs          | 1 -
 src/math/fmin.rs           | 1 -
 src/math/fminf.rs          | 1 -
 src/math/fmod.rs           | 1 -
 src/math/fmodf.rs          | 1 -
 src/math/hypot.rs          | 2 --
 src/math/hypotf.rs         | 1 -
 src/math/k_cos.rs          | 1 -
 src/math/k_cosf.rs         | 1 -
 src/math/k_expo2.rs        | 1 -
 src/math/k_expo2f.rs       | 1 -
 src/math/k_sin.rs          | 1 -
 src/math/k_sinf.rs         | 1 -
 src/math/k_tan.rs          | 2 --
 src/math/k_tanf.rs         | 1 -
 src/math/ldexp.rs          | 1 -
 src/math/ldexpf.rs         | 1 -
 src/math/log.rs            | 1 -
 src/math/log10.rs          | 1 -
 src/math/log10f.rs         | 1 -
 src/math/log1p.rs          | 1 -
 src/math/log1pf.rs         | 1 -
 src/math/log2.rs           | 1 -
 src/math/log2f.rs          | 1 -
 src/math/logf.rs           | 1 -
 src/math/nextafter.rs      | 1 -
 src/math/nextafterf.rs     | 1 -
 src/math/pow.rs            | 1 -
 src/math/powf.rs           | 1 -
 src/math/rem_pio2.rs       | 2 --
 src/math/rem_pio2_large.rs | 1 -
 src/math/rem_pio2f.rs      | 1 -
 src/math/remainder.rs      | 1 -
 src/math/remainderf.rs     | 1 -
 src/math/remquo.rs         | 1 +
 src/math/remquof.rs        | 1 +
 src/math/round.rs          | 1 -
 src/math/roundf.rs         | 1 -
 src/math/scalbn.rs         | 1 -
 src/math/scalbnf.rs        | 1 -
 src/math/sin.rs            | 1 -
 src/math/sinf.rs           | 1 -
 src/math/sinh.rs           | 1 -
 src/math/sinhf.rs          | 1 -
 src/math/sqrt.rs           | 1 -
 src/math/sqrtf.rs          | 1 -
 src/math/tan.rs            | 1 -
 src/math/tanf.rs           | 1 -
 src/math/tanh.rs           | 1 -
 src/math/tanhf.rs          | 1 -
 src/math/trunc.rs          | 1 -
 src/math/truncf.rs         | 1 -
 84 files changed, 2 insertions(+), 91 deletions(-)

diff --git a/src/math/acos.rs b/src/math/acos.rs
index d5e1f68..23b1325 100644
--- a/src/math/acos.rs
+++ b/src/math/acos.rs
@@ -48,7 +48,6 @@ const QS2: f64 = 2.02094576023350569471e+00; /* 0x40002AE5, 0x9C598AC8 */
 const QS3: f64 = -6.88283971605453293030e-01; /* 0xBFE6066C, 0x1B8D0159 */
 const QS4: f64 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
 
-#[inline]
 fn r(z: f64) -> f64 {
     let p: f64 = z * (PS0 + z * (PS1 + z * (PS2 + z * (PS3 + z * (PS4 + z * PS5)))));
     let q: f64 = 1.0 + z * (QS1 + z * (QS2 + z * (QS3 + z * QS4)));
@@ -60,7 +59,6 @@ fn r(z: f64) -> f64 {
 /// Computes the inverse cosine (arc cosine) of the input value.
 /// Arguments must be in the range -1 to 1.
 /// Returns values in radians, in the range of 0 to pi.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn acos(x: f64) -> f64 {
     let x1p_120f = f64::from_bits(0x3870000000000000); // 0x1p-120 === 2 ^ -120
diff --git a/src/math/acosf.rs b/src/math/acosf.rs
index d0598e8..1a60479 100644
--- a/src/math/acosf.rs
+++ b/src/math/acosf.rs
@@ -22,7 +22,6 @@ const P_S1: f32 = -4.2743422091e-02;
 const P_S2: f32 = -8.6563630030e-03;
 const Q_S1: f32 = -7.0662963390e-01;
 
-#[inline]
 fn r(z: f32) -> f32 {
     let p = z * (P_S0 + z * (P_S1 + z * P_S2));
     let q = 1. + z * Q_S1;
@@ -34,7 +33,6 @@ fn r(z: f32) -> f32 {
 /// Computes the inverse cosine (arc cosine) of the input value.
 /// Arguments must be in the range -1 to 1.
 /// Returns values in radians, in the range of 0 to pi.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn acosf(x: f32) -> f32 {
     let x1p_120 = f32::from_bits(0x03800000); // 0x1p-120 === 2 ^ (-120)
diff --git a/src/math/asin.rs b/src/math/asin.rs
index 774475e..3e4b7c5 100644
--- a/src/math/asin.rs
+++ b/src/math/asin.rs
@@ -55,7 +55,6 @@ const Q_S2: f64 = 2.02094576023350569471e+00; /* 0x40002AE5, 0x9C598AC8 */
 const Q_S3: f64 = -6.88283971605453293030e-01; /* 0xBFE6066C, 0x1B8D0159 */
 const Q_S4: f64 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
 
-#[inline]
 fn comp_r(z: f64) -> f64 {
     let p = z * (P_S0 + z * (P_S1 + z * (P_S2 + z * (P_S3 + z * (P_S4 + z * P_S5)))));
     let q = 1.0 + z * (Q_S1 + z * (Q_S2 + z * (Q_S3 + z * Q_S4)));
@@ -67,7 +66,6 @@ fn comp_r(z: f64) -> f64 {
 /// Computes the inverse sine (arc sine) of the argument `x`.
 /// Arguments to asin must be in the range -1 to 1.
 /// Returns values in radians, in the range of -pi/2 to pi/2.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn asin(mut x: f64) -> f64 {
     let z: f64;
diff --git a/src/math/asinf.rs b/src/math/asinf.rs
index ce0f4a9..6ec61b6 100644
--- a/src/math/asinf.rs
+++ b/src/math/asinf.rs
@@ -24,7 +24,6 @@ const P_S1: f32 = -4.2743422091e-02;
 const P_S2: f32 = -8.6563630030e-03;
 const Q_S1: f32 = -7.0662963390e-01;
 
-#[inline]
 fn r(z: f32) -> f32 {
     let p = z * (P_S0 + z * (P_S1 + z * P_S2));
     let q = 1. + z * Q_S1;
@@ -36,7 +35,6 @@ fn r(z: f32) -> f32 {
 /// Computes the inverse sine (arc sine) of the argument `x`.
 /// Arguments to asin must be in the range -1 to 1.
 /// Returns values in radians, in the range of -pi/2 to pi/2.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn asinf(mut x: f32) -> f32 {
     let x1p_120 = f64::from_bits(0x3870000000000000); // 0x1p-120 === 2 ^ (-120)
diff --git a/src/math/atan.rs b/src/math/atan.rs
index d2684ec..4259dc7 100644
--- a/src/math/atan.rs
+++ b/src/math/atan.rs
@@ -64,7 +64,6 @@ const AT: [f64; 11] = [
 ///
 /// Computes the inverse tangent (arc tangent) of the input value.
 /// Returns a value in radians, in the range of -pi/2 to pi/2.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn atan(x: f64) -> f64 {
     let mut x = x;
diff --git a/src/math/atan2.rs b/src/math/atan2.rs
index 08385cd..fb2ea4e 100644
--- a/src/math/atan2.rs
+++ b/src/math/atan2.rs
@@ -48,7 +48,6 @@ const PI_LO: f64 = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */
 /// Computes the inverse tangent (arc tangent) of `y/x`.
 /// Produces the correct result even for angles near pi/2 or -pi/2 (that is, when `x` is near 0).
 /// Returns a value in radians, in the range of -pi to pi.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn atan2(y: f64, x: f64) -> f64 {
     if x.is_nan() || y.is_nan() {
diff --git a/src/math/atan2f.rs b/src/math/atan2f.rs
index 7bbe5f1..eae3b00 100644
--- a/src/math/atan2f.rs
+++ b/src/math/atan2f.rs
@@ -24,7 +24,6 @@ const PI_LO: f32 = -8.7422776573e-08; /* 0xb3bbbd2e */
 /// Computes the inverse tangent (arc tangent) of `y/x`.
 /// Produces the correct result even for angles near pi/2 or -pi/2 (that is, when `x` is near 0).
 /// Returns a value in radians, in the range of -pi to pi.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn atan2f(y: f32, x: f32) -> f32 {
     if x.is_nan() || y.is_nan() {
diff --git a/src/math/atanf.rs b/src/math/atanf.rs
index 363e11d..73f3352 100644
--- a/src/math/atanf.rs
+++ b/src/math/atanf.rs
@@ -41,7 +41,6 @@ const A_T: [f32; 5] = [
 ///
 /// Computes the inverse tangent (arc tangent) of the input value.
 /// Returns a value in radians, in the range of -pi/2 to pi/2.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn atanf(mut x: f32) -> f32 {
     let x1p_120 = f32::from_bits(0x03800000); // 0x1p-120 === 2 ^ (-120)
diff --git a/src/math/cbrt.rs b/src/math/cbrt.rs
index 04469b1..b4e77ea 100644
--- a/src/math/cbrt.rs
+++ b/src/math/cbrt.rs
@@ -30,7 +30,6 @@ const P4: f64 = 0.145996192886612446982; /* 0x3fc2b000, 0xd4e4edd7 */
 // Cube root (f64)
 ///
 /// Computes the cube root of the argument.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn cbrt(x: f64) -> f64 {
     let x1p54 = f64::from_bits(0x4350000000000000); // 0x1p54 === 2 ^ 54
diff --git a/src/math/cbrtf.rs b/src/math/cbrtf.rs
index 6e589c0..9d70305 100644
--- a/src/math/cbrtf.rs
+++ b/src/math/cbrtf.rs
@@ -25,7 +25,6 @@ const B2: u32 = 642849266; /* B2 = (127-127.0/3-24/3-0.03306235651)*2**23 */
 /// Cube root (f32)
 ///
 /// Computes the cube root of the argument.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn cbrtf(x: f32) -> f32 {
     let x1p24 = f32::from_bits(0x4b800000); // 0x1p24f === 2 ^ 24
diff --git a/src/math/ceil.rs b/src/math/ceil.rs
index 59883a8..63c1121 100644
--- a/src/math/ceil.rs
+++ b/src/math/ceil.rs
@@ -5,7 +5,6 @@ const TOINT: f64 = 1. / f64::EPSILON;
 /// Ceil (f64)
 ///
 /// Finds the nearest integer greater than or equal to `x`.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn ceil(x: f64) -> f64 {
     // On wasm32 we know that LLVM's intrinsic will compile to an optimized
diff --git a/src/math/ceilf.rs b/src/math/ceilf.rs
index 151a4f2..87d9698 100644
--- a/src/math/ceilf.rs
+++ b/src/math/ceilf.rs
@@ -3,7 +3,6 @@ use core::f32;
 /// Ceil (f32)
 ///
 /// Finds the nearest integer greater than or equal to `x`.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn ceilf(x: f32) -> f32 {
     // On wasm32 we know that LLVM's intrinsic will compile to an optimized
diff --git a/src/math/cos.rs b/src/math/cos.rs
index fe5a899..db8bc49 100644
--- a/src/math/cos.rs
+++ b/src/math/cos.rs
@@ -41,7 +41,6 @@ use super::{k_cos, k_sin, rem_pio2};
 // Accuracy:
 //      TRIG(x) returns trig(x) nearly rounded
 //
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn cos(x: f64) -> f64 {
     let ix = (f64::to_bits(x) >> 32) as u32 & 0x7fffffff;
diff --git a/src/math/cosf.rs b/src/math/cosf.rs
index 48d76c8..424fa42 100644
--- a/src/math/cosf.rs
+++ b/src/math/cosf.rs
@@ -24,7 +24,6 @@ const C2_PIO2: f64 = 2. * FRAC_PI_2; /* 0x400921FB, 0x54442D18 */
 const C3_PIO2: f64 = 3. * FRAC_PI_2; /* 0x4012D97C, 0x7F3321D2 */
 const C4_PIO2: f64 = 4. * FRAC_PI_2; /* 0x401921FB, 0x54442D18 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn cosf(x: f32) -> f32 {
     let x64 = x as f64;
diff --git a/src/math/cosh.rs b/src/math/cosh.rs
index bac8755..2fb568a 100644
--- a/src/math/cosh.rs
+++ b/src/math/cosh.rs
@@ -7,7 +7,6 @@ use super::k_expo2;
 /// Computes the hyperbolic cosine of the argument x.
 /// Is defined as `(exp(x) + exp(-x))/2`
 /// Angles are specified in radians.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn cosh(mut x: f64) -> f64 {
     /* |x| */
diff --git a/src/math/coshf.rs b/src/math/coshf.rs
index bf99e42..e7b6845 100644
--- a/src/math/coshf.rs
+++ b/src/math/coshf.rs
@@ -7,7 +7,6 @@ use super::k_expo2f;
 /// Computes the hyperbolic cosine of the argument x.
 /// Is defined as `(exp(x) + exp(-x))/2`
 /// Angles are specified in radians.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn coshf(mut x: f32) -> f32 {
     let x1p120 = f32::from_bits(0x7b800000); // 0x1p120f === 2 ^ 120
diff --git a/src/math/exp.rs b/src/math/exp.rs
index 5465b56..5b163f9 100644
--- a/src/math/exp.rs
+++ b/src/math/exp.rs
@@ -81,7 +81,6 @@ const P5: f64 = 4.13813679705723846039e-08; /* 0x3E663769, 0x72BEA4D0 */
 ///
 /// Calculate the exponential of `x`, that is, *e* raised to the power `x`
 /// (where *e* is the base of the natural system of logarithms, approximately 2.71828).
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn exp(mut x: f64) -> f64 {
     let x1p1023 = f64::from_bits(0x7fe0000000000000); // 0x1p1023 === 2 ^ 1023
diff --git a/src/math/exp2.rs b/src/math/exp2.rs
index c2192fd..8ea434d 100644
--- a/src/math/exp2.rs
+++ b/src/math/exp2.rs
@@ -322,7 +322,6 @@ static TBL: [u64; TBLSIZE * 2] = [
 /// Exponential, base 2 (f64)
 ///
 /// Calculate `2^x`, that is, 2 raised to the power `x`.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn exp2(mut x: f64) -> f64 {
     let redux = f64::from_bits(0x4338000000000000) / TBLSIZE as f64;
diff --git a/src/math/exp2f.rs b/src/math/exp2f.rs
index 12c9e76..8a890b8 100644
--- a/src/math/exp2f.rs
+++ b/src/math/exp2f.rs
@@ -73,7 +73,6 @@ static EXP2FT: [u64; TBLSIZE] = [
 /// Exponential, base 2 (f32)
 ///
 /// Calculate `2^x`, that is, 2 raised to the power `x`.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn exp2f(mut x: f32) -> f32 {
     let redux = f32::from_bits(0x4b400000) / TBLSIZE as f32;
diff --git a/src/math/expf.rs b/src/math/expf.rs
index 09323ec..47c1b2c 100644
--- a/src/math/expf.rs
+++ b/src/math/expf.rs
@@ -30,7 +30,6 @@ const P2: f32 = -2.7667332906e-3; /* -0xb55215.0p-32 */
 ///
 /// Calculate the exponential of `x`, that is, *e* raised to the power `x`
 /// (where *e* is the base of the natural system of logarithms, approximately 2.71828).
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn expf(mut x: f32) -> f32 {
     let x1p127 = f32::from_bits(0x7f000000); // 0x1p127f === 2 ^ 127
diff --git a/src/math/expm1.rs b/src/math/expm1.rs
index 0d43b4e..4260850 100644
--- a/src/math/expm1.rs
+++ b/src/math/expm1.rs
@@ -30,7 +30,6 @@ const Q5: f64 = -2.01099218183624371326e-07; /* BE8AFDB7 6E09C32D */
 /// system of logarithms, approximately 2.71828).
 /// The result is accurate even for small values of `x`,
 /// where using `exp(x)-1` would lose many significant digits.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn expm1(mut x: f64) -> f64 {
     let hi: f64;
diff --git a/src/math/expm1f.rs b/src/math/expm1f.rs
index 9bb2234..3fc2a24 100644
--- a/src/math/expm1f.rs
+++ b/src/math/expm1f.rs
@@ -32,7 +32,6 @@ const Q2: f32 = 1.5807170421e-3; /*  0xcf3010.0p-33 */
 /// system of logarithms, approximately 2.71828).
 /// The result is accurate even for small values of `x`,
 /// where using `exp(x)-1` would lose many significant digits.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn expm1f(mut x: f32) -> f32 {
     let x1p127 = f32::from_bits(0x7f000000); // 0x1p127f === 2 ^ 127
diff --git a/src/math/expo2.rs b/src/math/expo2.rs
index ae6cc81..82e9b36 100644
--- a/src/math/expo2.rs
+++ b/src/math/expo2.rs
@@ -1,7 +1,6 @@
 use super::{combine_words, exp};
 
 /* exp(x)/2 for x >= log(DBL_MAX), slightly better than 0.5*exp(x/2)*exp(x/2) */
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn expo2(x: f64) -> f64 {
     /* k is such that k*ln2 has minimal relative error and x - kln2 > log(DBL_MIN) */
diff --git a/src/math/fabs.rs b/src/math/fabs.rs
index 52a9adc..5a7f795 100644
--- a/src/math/fabs.rs
+++ b/src/math/fabs.rs
@@ -3,7 +3,6 @@ use core::u64;
 /// Absolute value (magnitude) (f64)
 /// Calculates the absolute value (magnitude) of the argument `x`,
 /// by direct manipulation of the bit representation of `x`.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fabs(x: f64) -> f64 {
     // On wasm32 we know that LLVM's intrinsic will compile to an optimized
diff --git a/src/math/fabsf.rs b/src/math/fabsf.rs
index 5942d98..4955125 100644
--- a/src/math/fabsf.rs
+++ b/src/math/fabsf.rs
@@ -1,7 +1,6 @@
 /// Absolute value (magnitude) (f32)
 /// Calculates the absolute value (magnitude) of the argument `x`,
 /// by direct manipulation of the bit representation of `x`.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fabsf(x: f32) -> f32 {
     // On wasm32 we know that LLVM's intrinsic will compile to an optimized
diff --git a/src/math/fdim.rs b/src/math/fdim.rs
index 06edc99..0149300 100644
--- a/src/math/fdim.rs
+++ b/src/math/fdim.rs
@@ -8,7 +8,6 @@ use core::f64;
 /// * NAN	if either argument is NAN.
 ///
 /// A range error may occur.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fdim(x: f64, y: f64) -> f64 {
     if x.is_nan() {
diff --git a/src/math/fdimf.rs b/src/math/fdimf.rs
index f1ad589..ea0b592 100644
--- a/src/math/fdimf.rs
+++ b/src/math/fdimf.rs
@@ -8,7 +8,6 @@ use core::f32;
 /// * NAN	if either argument is NAN.
 ///
 /// A range error may occur.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fdimf(x: f32, y: f32) -> f32 {
     if x.is_nan() {
diff --git a/src/math/floor.rs b/src/math/floor.rs
index f6068c6..91825e3 100644
--- a/src/math/floor.rs
+++ b/src/math/floor.rs
@@ -5,7 +5,6 @@ const TOINT: f64 = 1. / f64::EPSILON;
 /// Floor (f64)
 ///
 /// Finds the nearest integer less than or equal to `x`.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn floor(x: f64) -> f64 {
     // On wasm32 we know that LLVM's intrinsic will compile to an optimized
diff --git a/src/math/floorf.rs b/src/math/floorf.rs
index c04f18a..6d751b0 100644
--- a/src/math/floorf.rs
+++ b/src/math/floorf.rs
@@ -3,7 +3,6 @@ use core::f32;
 /// Floor (f32)
 ///
 /// Finds the nearest integer less than or equal to `x`.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn floorf(x: f32) -> f32 {
     // On wasm32 we know that LLVM's intrinsic will compile to an optimized
diff --git a/src/math/fma.rs b/src/math/fma.rs
index 07d90f8..5ea0d09 100644
--- a/src/math/fma.rs
+++ b/src/math/fma.rs
@@ -10,7 +10,6 @@ struct Num {
     sign: i32,
 }
 
-#[inline]
 fn normalize(x: f64) -> Num {
     let x1p63: f64 = f64::from_bits(0x43e0000000000000); // 0x1p63 === 2 ^ 63
 
@@ -30,7 +29,6 @@ fn normalize(x: f64) -> Num {
     Num { m: ix, e, sign }
 }
 
-#[inline]
 fn mul(x: u64, y: u64) -> (u64, u64) {
     let t1: u64;
     let t2: u64;
@@ -53,7 +51,6 @@ fn mul(x: u64, y: u64) -> (u64, u64) {
 /// Computes `(x*y)+z`, rounded as one ternary operation:
 /// Computes the value (as if) to infinite precision and rounds once to the result format,
 /// according to the rounding mode characterized by the value of FLT_ROUNDS.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fma(x: f64, y: f64, z: f64) -> f64 {
     let x1p63: f64 = f64::from_bits(0x43e0000000000000); // 0x1p63 === 2 ^ 63
diff --git a/src/math/fmaf.rs b/src/math/fmaf.rs
index e77e0fa..03d371c 100644
--- a/src/math/fmaf.rs
+++ b/src/math/fmaf.rs
@@ -46,7 +46,6 @@ use super::fenv::{
 /// Computes `(x*y)+z`, rounded as one ternary operation:
 /// Computes the value (as if) to infinite precision and rounds once to the result format,
 /// according to the rounding mode characterized by the value of FLT_ROUNDS.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fmaf(x: f32, y: f32, mut z: f32) -> f32 {
     let xy: f64;
diff --git a/src/math/fmax.rs b/src/math/fmax.rs
index 22016d1..93c97bc 100644
--- a/src/math/fmax.rs
+++ b/src/math/fmax.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fmax(x: f64, y: f64) -> f64 {
     // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the
diff --git a/src/math/fmaxf.rs b/src/math/fmaxf.rs
index a883fda..6077466 100644
--- a/src/math/fmaxf.rs
+++ b/src/math/fmaxf.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fmaxf(x: f32, y: f32) -> f32 {
     // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the
diff --git a/src/math/fmin.rs b/src/math/fmin.rs
index d1ccc3a..ab1509f 100644
--- a/src/math/fmin.rs
+++ b/src/math/fmin.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fmin(x: f64, y: f64) -> f64 {
     // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the
diff --git a/src/math/fminf.rs b/src/math/fminf.rs
index 43ec97c..0049e71 100644
--- a/src/math/fminf.rs
+++ b/src/math/fminf.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fminf(x: f32, y: f32) -> f32 {
     // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the
diff --git a/src/math/fmod.rs b/src/math/fmod.rs
index 2cdd8a9..d892ffd 100644
--- a/src/math/fmod.rs
+++ b/src/math/fmod.rs
@@ -1,6 +1,5 @@
 use core::u64;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fmod(x: f64, y: f64) -> f64 {
     let mut uxi = x.to_bits();
diff --git a/src/math/fmodf.rs b/src/math/fmodf.rs
index 3e6779a..c53dc18 100644
--- a/src/math/fmodf.rs
+++ b/src/math/fmodf.rs
@@ -1,7 +1,6 @@
 use core::f32;
 use core::u32;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn fmodf(x: f32, y: f32) -> f32 {
     let mut uxi = x.to_bits();
diff --git a/src/math/hypot.rs b/src/math/hypot.rs
index e53baf5..da458ea 100644
--- a/src/math/hypot.rs
+++ b/src/math/hypot.rs
@@ -4,7 +4,6 @@ use super::sqrt;
 
 const SPLIT: f64 = 134217728. + 1.; // 0x1p27 + 1 === (2 ^ 27) + 1
 
-#[inline]
 fn sq(x: f64) -> (f64, f64) {
     let xh: f64;
     let xl: f64;
@@ -18,7 +17,6 @@ fn sq(x: f64) -> (f64, f64) {
     (hi, lo)
 }
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn hypot(mut x: f64, mut y: f64) -> f64 {
     let x1p700 = f64::from_bits(0x6bb0000000000000); // 0x1p700 === 2 ^ 700
diff --git a/src/math/hypotf.rs b/src/math/hypotf.rs
index 4636b8f..576eebb 100644
--- a/src/math/hypotf.rs
+++ b/src/math/hypotf.rs
@@ -2,7 +2,6 @@ use core::f32;
 
 use super::sqrtf;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn hypotf(mut x: f32, mut y: f32) -> f32 {
     let x1p90 = f32::from_bits(0x6c800000); // 0x1p90f === 2 ^ 90
diff --git a/src/math/k_cos.rs b/src/math/k_cos.rs
index 4687b36..49b2fc6 100644
--- a/src/math/k_cos.rs
+++ b/src/math/k_cos.rs
@@ -51,7 +51,6 @@ const C6: f64 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */
 //         expression for cos().  Retention happens in all cases tested
 //         under FreeBSD, so don't pessimize things by forcibly clipping
 //         any extra precision in w.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn k_cos(x: f64, y: f64) -> f64 {
     let z = x * x;
diff --git a/src/math/k_cosf.rs b/src/math/k_cosf.rs
index 79d0f23..e99f234 100644
--- a/src/math/k_cosf.rs
+++ b/src/math/k_cosf.rs
@@ -20,7 +20,6 @@ const C1: f64 = 0.0416666233237390631894; /*  0x155553e1053a42.0p-57 */
 const C2: f64 = -0.00138867637746099294692; /* -0x16c087e80f1e27.0p-62 */
 const C3: f64 = 0.0000243904487962774090654; /*  0x199342e0ee5069.0p-68 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn k_cosf(x: f64) -> f32 {
     let z = x * x;
diff --git a/src/math/k_expo2.rs b/src/math/k_expo2.rs
index 0a9562e..7345075 100644
--- a/src/math/k_expo2.rs
+++ b/src/math/k_expo2.rs
@@ -4,7 +4,6 @@ use super::exp;
 const K: i32 = 2043;
 
 /* expf(x)/2 for x >= log(FLT_MAX), slightly better than 0.5f*expf(x/2)*expf(x/2) */
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn k_expo2(x: f64) -> f64 {
     let k_ln2 = f64::from_bits(0x40962066151add8b);
diff --git a/src/math/k_expo2f.rs b/src/math/k_expo2f.rs
index de85077..fbd7b27 100644
--- a/src/math/k_expo2f.rs
+++ b/src/math/k_expo2f.rs
@@ -4,7 +4,6 @@ use super::expf;
 const K: i32 = 235;
 
 /* expf(x)/2 for x >= log(FLT_MAX), slightly better than 0.5f*expf(x/2)*expf(x/2) */
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn k_expo2f(x: f32) -> f32 {
     let k_ln2 = f32::from_bits(0x4322e3bc);
diff --git a/src/math/k_sin.rs b/src/math/k_sin.rs
index 5d2bd68..9dd96c9 100644
--- a/src/math/k_sin.rs
+++ b/src/math/k_sin.rs
@@ -43,7 +43,6 @@ const S6: f64 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */
 //              r = x *(S2+x *(S3+x *(S4+x *(S5+x *S6))))
 //         then                   3    2
 //              sin(x) = x + (S1*x + (x *(r-y/2)+y))
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn k_sin(x: f64, y: f64, iy: i32) -> f64 {
     let z = x * x;
diff --git a/src/math/k_sinf.rs b/src/math/k_sinf.rs
index 68fe926..88d10ca 100644
--- a/src/math/k_sinf.rs
+++ b/src/math/k_sinf.rs
@@ -20,7 +20,6 @@ const S2: f64 = 0.0083333293858894631756; /*  0x111110896efbb2.0p-59 */
 const S3: f64 = -0.000198393348360966317347; /* -0x1a00f9e2cae774.0p-65 */
 const S4: f64 = 0.0000027183114939898219064; /*  0x16cd878c3b46a7.0p-71 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn k_sinf(x: f64) -> f32 {
     let z = x * x;
diff --git a/src/math/k_tan.rs b/src/math/k_tan.rs
index ea3c386..d177010 100644
--- a/src/math/k_tan.rs
+++ b/src/math/k_tan.rs
@@ -58,7 +58,6 @@ static T: [f64; 13] = [
 const PIO4: f64 = 7.85398163397448278999e-01; /* 3FE921FB, 54442D18 */
 const PIO4_LO: f64 = 3.06161699786838301793e-17; /* 3C81A626, 33145C07 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn k_tan(mut x: f64, mut y: f64, odd: i32) -> f64 {
     let hx = (f64::to_bits(x) >> 32) as u32;
@@ -101,7 +100,6 @@ pub(crate) fn k_tan(mut x: f64, mut y: f64, odd: i32) -> f64 {
     a0 + a * (1.0 + a0 * w0 + a0 * v)
 }
 
-#[inline]
 fn zero_low_word(x: f64) -> f64 {
     f64::from_bits(f64::to_bits(x) & 0xFFFF_FFFF_0000_0000)
 }
diff --git a/src/math/k_tanf.rs b/src/math/k_tanf.rs
index 5265137..af8db53 100644
--- a/src/math/k_tanf.rs
+++ b/src/math/k_tanf.rs
@@ -19,7 +19,6 @@ const T: [f64; 6] = [
     0.00946564784943673166728, /* 0x1362b9bf971bcd.0p-59 */
 ];
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn k_tanf(x: f64, odd: bool) -> f32 {
     let z = x * x;
diff --git a/src/math/ldexp.rs b/src/math/ldexp.rs
index 780ddfc..e46242e 100644
--- a/src/math/ldexp.rs
+++ b/src/math/ldexp.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn ldexp(x: f64, n: i32) -> f64 {
     super::scalbn(x, n)
diff --git a/src/math/ldexpf.rs b/src/math/ldexpf.rs
index 70935a0..95b27fc 100644
--- a/src/math/ldexpf.rs
+++ b/src/math/ldexpf.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn ldexpf(x: f32, n: i32) -> f32 {
     super::scalbnf(x, n)
diff --git a/src/math/log.rs b/src/math/log.rs
index 4126e41..27a26da 100644
--- a/src/math/log.rs
+++ b/src/math/log.rs
@@ -70,7 +70,6 @@ const LG5: f64 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */
 const LG6: f64 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */
 const LG7: f64 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn log(mut x: f64) -> f64 {
     let x1p54 = f64::from_bits(0x4350000000000000); // 0x1p54 === 2 ^ 54
diff --git a/src/math/log10.rs b/src/math/log10.rs
index c996960..40dacf2 100644
--- a/src/math/log10.rs
+++ b/src/math/log10.rs
@@ -31,7 +31,6 @@ const LG5: f64 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */
 const LG6: f64 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */
 const LG7: f64 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn log10(mut x: f64) -> f64 {
     let x1p54 = f64::from_bits(0x4350000000000000); // 0x1p54 === 2 ^ 54
diff --git a/src/math/log10f.rs b/src/math/log10f.rs
index 9845cda..108dfa8 100644
--- a/src/math/log10f.rs
+++ b/src/math/log10f.rs
@@ -25,7 +25,6 @@ const LG2: f32 = 0.40000972152; /* 0xccce13.0p-25 */
 const LG3: f32 = 0.28498786688; /* 0x91e9ee.0p-25 */
 const LG4: f32 = 0.24279078841; /* 0xf89e26.0p-26 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn log10f(mut x: f32) -> f32 {
     let x1p25f = f32::from_bits(0x4c000000); // 0x1p25f === 2 ^ 25
diff --git a/src/math/log1p.rs b/src/math/log1p.rs
index cd7045a..4fd1c73 100644
--- a/src/math/log1p.rs
+++ b/src/math/log1p.rs
@@ -65,7 +65,6 @@ const LG5: f64 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */
 const LG6: f64 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */
 const LG7: f64 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn log1p(x: f64) -> f64 {
     let mut ui: u64 = x.to_bits();
diff --git a/src/math/log1pf.rs b/src/math/log1pf.rs
index 8e96513..500e8ee 100644
--- a/src/math/log1pf.rs
+++ b/src/math/log1pf.rs
@@ -20,7 +20,6 @@ const LG2: f32 = 0.40000972152; /* 0xccce13.0p-25 */
 const LG3: f32 = 0.28498786688; /* 0x91e9ee.0p-25 */
 const LG4: f32 = 0.24279078841; /* 0xf89e26.0p-26 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn log1pf(x: f32) -> f32 {
     let mut ui: u32 = x.to_bits();
diff --git a/src/math/log2.rs b/src/math/log2.rs
index a3d43e5..83da3a1 100644
--- a/src/math/log2.rs
+++ b/src/math/log2.rs
@@ -29,7 +29,6 @@ const LG5: f64 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */
 const LG6: f64 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */
 const LG7: f64 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn log2(mut x: f64) -> f64 {
     let x1p54 = f64::from_bits(0x4350000000000000); // 0x1p54 === 2 ^ 54
diff --git a/src/math/log2f.rs b/src/math/log2f.rs
index 53a37e5..3a20fb1 100644
--- a/src/math/log2f.rs
+++ b/src/math/log2f.rs
@@ -23,7 +23,6 @@ const LG2: f32 = 0.40000972152; /* 0xccce13.0p-25 */
 const LG3: f32 = 0.28498786688; /* 0x91e9ee.0p-25 */
 const LG4: f32 = 0.24279078841; /* 0xf89e26.0p-26 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn log2f(mut x: f32) -> f32 {
     let x1p25f = f32::from_bits(0x4c000000); // 0x1p25f === 2 ^ 25
diff --git a/src/math/logf.rs b/src/math/logf.rs
index 9519560..2b57b93 100644
--- a/src/math/logf.rs
+++ b/src/math/logf.rs
@@ -21,7 +21,6 @@ const LG2: f32 = 0.40000972152; /*  0xccce13.0p-25 */
 const LG3: f32 = 0.28498786688; /*  0x91e9ee.0p-25 */
 const LG4: f32 = 0.24279078841; /*  0xf89e26.0p-26 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn logf(mut x: f32) -> f32 {
     let x1p25 = f32::from_bits(0x4c000000); // 0x1p25f === 2 ^ 25
diff --git a/src/math/nextafter.rs b/src/math/nextafter.rs
index 4c1257e..13094a1 100644
--- a/src/math/nextafter.rs
+++ b/src/math/nextafter.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn nextafter(x: f64, y: f64) -> f64 {
     if x.is_nan() || y.is_nan() {
diff --git a/src/math/nextafterf.rs b/src/math/nextafterf.rs
index a48bce9..df9b108 100644
--- a/src/math/nextafterf.rs
+++ b/src/math/nextafterf.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn nextafterf(x: f32, y: f32) -> f32 {
     if x.is_nan() || y.is_nan() {
diff --git a/src/math/pow.rs b/src/math/pow.rs
index 068a4ec..ce8e83e 100644
--- a/src/math/pow.rs
+++ b/src/math/pow.rs
@@ -89,7 +89,6 @@ const IVLN2: f64 = 1.44269504088896338700e+00; /* 0x3ff71547_652b82fe =1/ln2 */
 const IVLN2_H: f64 = 1.44269502162933349609e+00; /* 0x3ff71547_60000000 =24b 1/ln2*/
 const IVLN2_L: f64 = 1.92596299112661746887e-08; /* 0x3e54ae0b_f85ddf44 =1/ln2 tail*/
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn pow(x: f64, y: f64) -> f64 {
     let t1: f64;
diff --git a/src/math/powf.rs b/src/math/powf.rs
index 015bade..f3cf76f 100644
--- a/src/math/powf.rs
+++ b/src/math/powf.rs
@@ -43,7 +43,6 @@ const IVLN2: f32 = 1.4426950216e+00;
 const IVLN2_H: f32 = 1.4426879883e+00;
 const IVLN2_L: f32 = 7.0526075433e-06;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn powf(x: f32, y: f32) -> f32 {
     let mut z: f32;
diff --git a/src/math/rem_pio2.rs b/src/math/rem_pio2.rs
index dc6b329..6b7dbd3 100644
--- a/src/math/rem_pio2.rs
+++ b/src/math/rem_pio2.rs
@@ -41,7 +41,6 @@ const PIO2_3T: f64 = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */
 // use rem_pio2_large() for large x
 //
 // caller must handle the case when reduction is not needed: |x| ~<= pi/4 */
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn rem_pio2(x: f64) -> (i32, f64, f64) {
     let x1p24 = f64::from_bits(0x4170000000000000);
@@ -49,7 +48,6 @@ pub(crate) fn rem_pio2(x: f64) -> (i32, f64, f64) {
     let sign = (f64::to_bits(x) >> 63) as i32;
     let ix = (f64::to_bits(x) >> 32) as u32 & 0x7fffffff;
 
-    #[inline]
     fn medium(x: f64, ix: u32) -> (i32, f64, f64) {
         /* rint(x/(pi/2)), Assume round-to-nearest. */
         let f_n = x as f64 * INV_PIO2 + TO_INT - TO_INT;
diff --git a/src/math/rem_pio2_large.rs b/src/math/rem_pio2_large.rs
index 5336a97..8533dc2 100644
--- a/src/math/rem_pio2_large.rs
+++ b/src/math/rem_pio2_large.rs
@@ -222,7 +222,6 @@ const PIO2: [f64; 8] = [
 /// skip the part of the product that are known to be a huge integer (
 /// more accurately, = 0 mod 8 ). Thus the number of operations are
 /// independent of the exponent of the input.
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn rem_pio2_large(x: &[f64], y: &mut [f64], e0: i32, prec: usize) -> i32 {
     let x1p24 = f64::from_bits(0x4170000000000000); // 0x1p24 === 2 ^ 24
diff --git a/src/math/rem_pio2f.rs b/src/math/rem_pio2f.rs
index af2745d..5d392ba 100644
--- a/src/math/rem_pio2f.rs
+++ b/src/math/rem_pio2f.rs
@@ -31,7 +31,6 @@ const PIO2_1T: f64 = 1.58932547735281966916e-08; /* 0x3E5110b4, 0x611A6263 */
 ///
 /// use double precision for everything except passing x
 /// use __rem_pio2_large() for large x
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub(crate) fn rem_pio2f(x: f32) -> (i32, f64) {
     let x64 = x as f64;
diff --git a/src/math/remainder.rs b/src/math/remainder.rs
index 7ce8950..9e966c9 100644
--- a/src/math/remainder.rs
+++ b/src/math/remainder.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn remainder(x: f64, y: f64) -> f64 {
     let (result, _) = super::remquo(x, y);
diff --git a/src/math/remainderf.rs b/src/math/remainderf.rs
index 8b2aa5a..b1407cf 100644
--- a/src/math/remainderf.rs
+++ b/src/math/remainderf.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn remainderf(x: f32, y: f32) -> f32 {
     let (result, _) = super::remquof(x, y);
diff --git a/src/math/remquo.rs b/src/math/remquo.rs
index c72c8f1..0afd1f7 100644
--- a/src/math/remquo.rs
+++ b/src/math/remquo.rs
@@ -1,3 +1,4 @@
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn remquo(mut x: f64, mut y: f64) -> (f64, i32) {
     let ux: u64 = x.to_bits();
     let mut uy: u64 = y.to_bits();
diff --git a/src/math/remquof.rs b/src/math/remquof.rs
index 871d0c7..d71bd38 100644
--- a/src/math/remquof.rs
+++ b/src/math/remquof.rs
@@ -1,3 +1,4 @@
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn remquof(mut x: f32, mut y: f32) -> (f32, i32) {
     let ux: u32 = x.to_bits();
     let mut uy: u32 = y.to_bits();
diff --git a/src/math/round.rs b/src/math/round.rs
index 67590d2..bf72f5b 100644
--- a/src/math/round.rs
+++ b/src/math/round.rs
@@ -2,7 +2,6 @@ use core::f64;
 
 const TOINT: f64 = 1.0 / f64::EPSILON;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn round(mut x: f64) -> f64 {
     let i = x.to_bits();
diff --git a/src/math/roundf.rs b/src/math/roundf.rs
index 85114be..497e88d 100644
--- a/src/math/roundf.rs
+++ b/src/math/roundf.rs
@@ -2,7 +2,6 @@ use core::f32;
 
 const TOINT: f32 = 1.0 / f32::EPSILON;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn roundf(mut x: f32) -> f32 {
     let i = x.to_bits();
diff --git a/src/math/scalbn.rs b/src/math/scalbn.rs
index d8c8409..00c455a 100644
--- a/src/math/scalbn.rs
+++ b/src/math/scalbn.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn scalbn(x: f64, mut n: i32) -> f64 {
     let x1p1023 = f64::from_bits(0x7fe0000000000000); // 0x1p1023 === 2 ^ 1023
diff --git a/src/math/scalbnf.rs b/src/math/scalbnf.rs
index 4e97711..73f4bb5 100644
--- a/src/math/scalbnf.rs
+++ b/src/math/scalbnf.rs
@@ -1,4 +1,3 @@
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn scalbnf(mut x: f32, mut n: i32) -> f32 {
     let x1p127 = f32::from_bits(0x7f000000); // 0x1p127f === 2 ^ 127
diff --git a/src/math/sin.rs b/src/math/sin.rs
index 51aed88..1329b41 100644
--- a/src/math/sin.rs
+++ b/src/math/sin.rs
@@ -40,7 +40,6 @@ use super::{k_cos, k_sin, rem_pio2};
 //
 // Accuracy:
 //      TRIG(x) returns trig(x) nearly rounded
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn sin(x: f64) -> f64 {
     let x1p120 = f64::from_bits(0x4770000000000000); // 0x1p120f === 2 ^ 120
diff --git a/src/math/sinf.rs b/src/math/sinf.rs
index 0c31099..6e20be2 100644
--- a/src/math/sinf.rs
+++ b/src/math/sinf.rs
@@ -24,7 +24,6 @@ const S2_PIO2: f64 = 2. * FRAC_PI_2; /* 0x400921FB, 0x54442D18 */
 const S3_PIO2: f64 = 3. * FRAC_PI_2; /* 0x4012D97C, 0x7F3321D2 */
 const S4_PIO2: f64 = 4. * FRAC_PI_2; /* 0x401921FB, 0x54442D18 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn sinf(x: f32) -> f32 {
     let x64 = x as f64;
diff --git a/src/math/sinh.rs b/src/math/sinh.rs
index d36de66..fd24fd2 100644
--- a/src/math/sinh.rs
+++ b/src/math/sinh.rs
@@ -4,7 +4,6 @@ use super::{expm1, expo2};
 //         = (exp(x)-1 + (exp(x)-1)/exp(x))/2
 //         = x + x^3/6 + o(x^5)
 //
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn sinh(x: f64) -> f64 {
     // union {double f; uint64_t i;} u = {.f = x};
diff --git a/src/math/sinhf.rs b/src/math/sinhf.rs
index fd0b2bf..24f863c 100644
--- a/src/math/sinhf.rs
+++ b/src/math/sinhf.rs
@@ -1,7 +1,6 @@
 use super::expm1f;
 use super::k_expo2f;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn sinhf(x: f32) -> f32 {
     let mut h = 0.5f32;
diff --git a/src/math/sqrt.rs b/src/math/sqrt.rs
index 14404d4..58cf00e 100644
--- a/src/math/sqrt.rs
+++ b/src/math/sqrt.rs
@@ -81,7 +81,6 @@ use core::num::Wrapping;
 
 const TINY: f64 = 1.0e-300;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn sqrt(x: f64) -> f64 {
     // On wasm32 we know that LLVM's intrinsic will compile to an optimized
diff --git a/src/math/sqrtf.rs b/src/math/sqrtf.rs
index b9365c6..889b525 100644
--- a/src/math/sqrtf.rs
+++ b/src/math/sqrtf.rs
@@ -15,7 +15,6 @@
 
 const TINY: f32 = 1.0e-30;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn sqrtf(x: f32) -> f32 {
     // On wasm32 we know that LLVM's intrinsic will compile to an optimized
diff --git a/src/math/tan.rs b/src/math/tan.rs
index e5c94cb..5a72f68 100644
--- a/src/math/tan.rs
+++ b/src/math/tan.rs
@@ -39,7 +39,6 @@ use super::{k_tan, rem_pio2};
 //
 // Accuracy:
 //      TRIG(x) returns trig(x) nearly rounded
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn tan(x: f64) -> f64 {
     let x1p120 = f32::from_bits(0x7b800000); // 0x1p120f === 2 ^ 120
diff --git a/src/math/tanf.rs b/src/math/tanf.rs
index c286cde..10de59c 100644
--- a/src/math/tanf.rs
+++ b/src/math/tanf.rs
@@ -24,7 +24,6 @@ const T2_PIO2: f64 = 2. * FRAC_PI_2; /* 0x400921FB, 0x54442D18 */
 const T3_PIO2: f64 = 3. * FRAC_PI_2; /* 0x4012D97C, 0x7F3321D2 */
 const T4_PIO2: f64 = 4. * FRAC_PI_2; /* 0x401921FB, 0x54442D18 */
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn tanf(x: f32) -> f32 {
     let x64 = x as f64;
diff --git a/src/math/tanh.rs b/src/math/tanh.rs
index 75d695c..980c685 100644
--- a/src/math/tanh.rs
+++ b/src/math/tanh.rs
@@ -4,7 +4,6 @@ use super::expm1;
  *         = (exp(2*x) - 1)/(exp(2*x) - 1 + 2)
  *         = (1 - exp(-2*x))/(exp(-2*x) - 1 + 2)
  */
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn tanh(mut x: f64) -> f64 {
     let mut uf: f64 = x;
diff --git a/src/math/tanhf.rs b/src/math/tanhf.rs
index ac4657b..fc94e3d 100644
--- a/src/math/tanhf.rs
+++ b/src/math/tanhf.rs
@@ -1,6 +1,5 @@
 use super::expm1f;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn tanhf(mut x: f32) -> f32 {
     /* x = |x| */
diff --git a/src/math/trunc.rs b/src/math/trunc.rs
index 1ee46fc..f7892a2 100644
--- a/src/math/trunc.rs
+++ b/src/math/trunc.rs
@@ -1,6 +1,5 @@
 use core::f64;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn trunc(x: f64) -> f64 {
     // On wasm32 we know that LLVM's intrinsic will compile to an optimized
diff --git a/src/math/truncf.rs b/src/math/truncf.rs
index f933832..a4c0016 100644
--- a/src/math/truncf.rs
+++ b/src/math/truncf.rs
@@ -1,6 +1,5 @@
 use core::f32;
 
-#[inline]
 #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
 pub fn truncf(x: f32) -> f32 {
     // On wasm32 we know that LLVM's intrinsic will compile to an optimized