more fixes

Author: tgross35

ci/run.sh

@@ -66,10 +66,10 @@ if [ "$(uname -a)" = "Linux" ]; then
     extra_flags="$extra_flags --features libm-test/test-musl-serialized"
 fi
 
-# Make sure we can build with overriding features. We test the indibidual
+# Make sure we can build with overriding features. We test the individual
 # features it controls separately.
 cargo check --no-default-features
-cargo check --features "force-soft-floats"
+cargo check --all --target "$target" $extra_flags --features "force-soft-floats"
 
 if [ "${BUILD_ONLY:-}" = "1" ]; then
     cmd="cargo build --target $target --package libm"

crates/libm-macros/tests/basic.rs

@@ -88,6 +88,7 @@ macro_rules! specified_types {
         fn_name: $fn_name:ident,
         RustFn: $RustFn:ty,
         RustArgs: $RustArgs:ty,
+        attrs: [$($meta:meta),*],
     ) => {
         mod $fn_name {
             #[allow(unused)]

crates/libm-test/benches/random.rs

@@ -18,15 +18,16 @@ struct MuslExtra<F> {
 macro_rules! musl_rand_benches {
     (
         fn_name: $fn_name:ident,
-        fn_extra: $skip_on_i586:expr,
+        attrs: [$($meta:meta)*],
+        fn_extra: ($skip_on_i586:expr, $musl_fn:expr),
     ) => {
         paste::paste! {
             fn [< musl_bench_ $fn_name >](c: &mut Criterion) {
                 type Op = libm_test::op::$fn_name::Routine;
 
                 #[cfg(feature = "build-musl")]
                 let musl_extra = MuslExtra {
-                    musl_fn: Some(musl_math_sys::$fn_name as <Op as MathOp>::CFn),
+                    musl_fn: $musl_fn,
                     skip_on_i586: $skip_on_i586
                 };
 
@@ -64,7 +65,10 @@ where
             break;
         }
 
-        let musl_res = input.call(musl_extra.musl_fn.unwrap());
+        let Some(musl_fn) = musl_extra.musl_fn else {
+            continue;
+        };
+        let musl_res = input.call(musl_fn);
         let crate_res = input.call(Op::ROUTINE);
 
         crate_res.validate(musl_res, input, &ctx).context(name).unwrap();
@@ -88,31 +92,39 @@ where
     // Don't test against musl if it is not available
     #[cfg(feature = "build-musl")]
     {
-        let musl_fn = musl_extra.musl_fn.unwrap();
-        group.bench_function("musl", |b| {
-            b.iter(|| {
-                let f = black_box(musl_fn);
-                for input in benchvec.iter().copied() {
-                    input.call(f);
-                }
-            })
-        });
+        if let Some(musl_fn) = musl_extra.musl_fn {
+            group.bench_function("musl", |b| {
+                b.iter(|| {
+                    let f = black_box(musl_fn);
+                    for input in benchvec.iter().copied() {
+                        input.call(f);
+                    }
+                })
+            });
+        }
     }
 }
 
 libm_macros::for_each_function! {
     callback: musl_rand_benches,
     skip: [],
     fn_extra: match MACRO_FN_NAME {
-        // FIXME(correctness): wrong result on i586
-        exp10 | exp10f | exp2 | exp2f => true,
-        _ => false
+        // We pass a tuple of `(skip_on_i586, musl_fn)`. By default we never skip (false) and
+        // we do pass a function, but there are a couple exceptions.
+        // FIXME(correctness): exp functions have the wrong result on i586
+        exp10 | exp10f | exp2 | exp2f => (
+            true, Some(musl_math_sys::MACRO_FN_NAME as <Op as MathOp>::CFn)
+        ),
+        // Musl does not provide `f16` and `f128` functions
+        copysignf16 | copysignf128 | fabsf16 | fabsf128 => (false, None),
+        _ => (false, Some(musl_math_sys::MACRO_FN_NAME as <Op as MathOp>::CFn))
     }
 }
 
 macro_rules! run_callback {
     (
         fn_name: $fn_name:ident,
+        attrs: [$($meta:meta)*],
         extra: [$criterion:ident],
     ) => {
         paste::paste! {

crates/libm-test/src/mpfloat.rs

@@ -157,19 +157,23 @@ libm_macros::for_each_function! {
 
 /// Implement unary functions that don't have a `_round` version
 macro_rules! impl_no_round {
-    // Unary matcher
-    ($($fn_name:ident, $rug_name:ident;)*) => {
+    ($($fn_name:ident, $rug_name:ident $(, @include $f16_ty:ty, $f128_ty:ty )?;)*) => {
         paste::paste! {
             // Implement for both f32 and f64
             $(
-                #[cfg(f16_enabled)]
-                impl_no_round!{ @inner_unary [< $fn_name f16 >], $rug_name }
-            )*
-            $( impl_no_round!{ @inner_unary [< $fn_name f >], $rug_name } )*
-            $( impl_no_round!{ @inner_unary $fn_name, $rug_name } )*
-            $(
-                #[cfg(f128_enabled)]
-                impl_no_round!{ @inner_unary [< $fn_name f128 >], $rug_name }
+
+                impl_no_round!{ @inner_unary [< $fn_name f >], $rug_name }
+                impl_no_round!{ @inner_unary $fn_name, $rug_name }
+
+                $(
+                    // Possibly implement for `f16` and `f128`. We shouldn't need to match
+                    // `f16_ty` and `f128_ty` (we know what they are...) but this gets us around
+                    // the "repeat an expression containing no syntax variables" error.
+                    #[cfg(f16_enabled)]
+                    impl_no_round!{ @inner_unary [< $fn_name $f16_ty >], $rug_name }
+                    #[cfg(f128_enabled)]
+                    impl_no_round!{ @inner_unary [< $fn_name $f128_ty >], $rug_name }
+                )?
             )*
         }
     };
@@ -192,7 +196,7 @@ macro_rules! impl_no_round {
 }
 
 impl_no_round! {
-    fabs, abs_mut;
+    fabs, abs_mut, @include f16, f128;
     ceil, ceil_mut;
     floor, floor_mut;
     rint, round_even_mut; // FIXME: respect rounding mode
@@ -322,45 +326,33 @@ impl MpOp for crate::op::lgammaf_r::Routine {
 // Not all `f16` and `f128` functions exist yet so we can't easily use the macros.
 
 #[cfg(f16_enabled)]
-pub mod copysignf16 {
-    use super::*;
-    pub struct Operation(MpFloat, MpFloat);
-
-    impl MpOp for Operation {
-        type Input = (f16, f16);
-        type Output = f16;
+impl MpOp for crate::op::copysignf16::Routine {
+    type MpTy = (MpFloat, MpFloat);
 
-        fn new() -> Self {
-            Self(new_mpfloat::<f16>(), new_mpfloat::<f16>())
-        }
+    fn new_mp() -> Self::MpTy {
+        (new_mpfloat::<f16>(), new_mpfloat::<f16>())
+    }
 
-        fn run(&mut self, input: Self::Input) -> Self::Output {
-            self.0.assign(input.0);
-            self.1.assign(input.1);
-            self.0.copysign_mut(&self.1);
-            prep_retval::<Self::Output>(&mut self.0, Ordering::Equal)
-        }
+    fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
+        this.0.assign(input.0);
+        this.1.assign(input.1);
+        this.0.copysign_mut(&this.1);
+        prep_retval::<Self::RustRet>(&mut this.0, Ordering::Equal)
     }
 }
 
 #[cfg(f128_enabled)]
-pub mod copysignf128 {
-    use super::*;
-    pub struct Operation(MpFloat, MpFloat);
-
-    impl MpOp for Operation {
-        type Input = (f128, f128);
-        type Output = f128;
+impl MpOp for crate::op::copysignf128::Routine {
+    type MpTy = (MpFloat, MpFloat);
 
-        fn new() -> Self {
-            Self(new_mpfloat::<f128>(), new_mpfloat::<f128>())
-        }
+    fn new_mp() -> Self::MpTy {
+        (new_mpfloat::<f128>(), new_mpfloat::<f128>())
+    }
 
-        fn run(&mut self, input: Self::Input) -> Self::Output {
-            self.0.assign(input.0);
-            self.1.assign(input.1);
-            self.0.copysign_mut(&self.1);
-            prep_retval::<Self::Output>(&mut self.0, Ordering::Equal)
-        }
+    fn run(this: &mut Self::MpTy, input: Self::RustArgs) -> Self::RustRet {
+        this.0.assign(input.0);
+        this.1.assign(input.1);
+        this.0.copysign_mut(&this.1);
+        prep_retval::<Self::RustRet>(&mut this.0, Ordering::Equal)
     }
 }

crates/libm-test/src/op.rs

@@ -81,6 +81,7 @@ macro_rules! do_thing {
         RustFn: $RustFn:ty,
         RustArgs: $RustArgs:ty,
         RustRet: $RustRet:ty,
+        attrs: [$($meta:meta)*],
     ) => {
         paste::paste! {
             pub mod $fn_name {

crates/libm-test/src/test_traits.rs

@@ -349,6 +349,12 @@ where
 
 impl_float!(f32, f64);
 
+#[cfg(f16_enabled)]
+impl_float!(f16);
+
+#[cfg(f128_enabled)]
+impl_float!(f128);
+
 /* trait implementations for compound types */
 
 /// Implement `CheckOutput` for combinations of types.