WIP

wip

Fixup features

Fix things that should be cfg disabled

Author: tgross35

Cargo.toml

@@ -40,13 +40,6 @@ unstable-float = []
 # hard float operations.
 force-soft-floats = []
 
-# Workaround for codegen backends which haven't yet implemented `f16` and
-# `f128` support. Disables any functions which use those types.
-#
-# HACK: like the above, this is a negative feature that we would rather not
-# have, but we need to be consistent with compiler-builtins.
-no-f16-f128 = []
-
 [workspace]
 resolver = "2"
 members = [

ci/run.sh

@@ -6,6 +6,10 @@ export RUST_BACKTRACE="${RUST_BACKTRACE:-full}"
 # Needed for no-panic to correct detect a lack of panics
 export RUSTFLAGS="${RUSTFLAGS:-} -Ccodegen-units=1"
 
+# MPFR tests consume a lot of stack and often overflow. Default to 20 MiB (10x
+# the default)
+export RUST_MIN_STACK="${RUST_MIN_STACK:-20971520}"
+
 target="${1:-}"
 
 if [ -z "$target" ]; then
@@ -57,7 +61,7 @@ case "$target" in
     *windows-gnu) extra_flags="$extra_flags --exclude libm-macros" ;;
 esac
 
-# 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"
@@ -69,6 +73,10 @@ if [ "${BUILD_ONLY:-}" = "1" ]; then
 
     echo "can't run tests on $target; skipping"
 else
+    # Check `force-soft-floats` again, this time including test crates.
+    cargo check --all --target "$target" $extra_flags \
+        --features "force-soft-floats" --all-targets
+
     cmd="cargo test --all --target $target $extra_flags"
 
     # stable by default

configure.rs

@@ -43,17 +43,17 @@ impl Config {
 pub fn emit_libm_config(cfg: &Config) {
     emit_intrinsics_cfg();
     emit_arch_cfg();
-    emit_optimization_cfg(&cfg);
-    emit_cfg_shorthands(&cfg);
-    emit_f16_f128_cfg(&cfg);
+    emit_optimization_cfg(cfg);
+    emit_cfg_shorthands(cfg);
+    emit_f16_f128_cfg(cfg);
 }
 
 /// Tests don't need most feature-related config.
 #[allow(dead_code)]
 pub fn emit_test_config(cfg: &Config) {
-    emit_optimization_cfg(&cfg);
-    emit_cfg_shorthands(&cfg);
-    emit_f16_f128_cfg(&cfg);
+    emit_optimization_cfg(cfg);
+    emit_cfg_shorthands(cfg);
+    emit_f16_f128_cfg(cfg);
 }
 
 /// Simplify the feature logic for enabling intrinsics so code only needs to use
@@ -102,11 +102,8 @@ fn emit_f16_f128_cfg(cfg: &Config) {
     println!("cargo:rustc-check-cfg=cfg(f16_enabled)");
     println!("cargo:rustc-check-cfg=cfg(f128_enabled)");
 
-    // `unstable-float` enables these features. Either `no-f16-f128` or `force-soft-floats`
-    // will disable them.
-    if !cfg!(feature = "unstable-float")
-        && (cfg!(feature = "no-f16-f128") || cfg!(feature = "force-soft-floats"))
-    {
+    // `unstable-float` enables these features.
+    if !cfg!(feature = "unstable-float") {
         return;
     }
 

crates/libm-macros/Cargo.toml

@@ -12,3 +12,10 @@ heck = "0.5.0"
 proc-macro2 = "1.0.88"
 quote = "1.0.37"
 syn = { version = "2.0.79", features = ["full", "extra-traits", "visit-mut"] }
+
+[lints.rust]
+# Values used during testing
+unexpected_cfgs = { level = "warn", check-cfg = [
+  'cfg(f16_enabled)',
+  'cfg(f128_enabled)',
+] }

crates/libm-macros/src/lib.rs

@@ -218,7 +218,7 @@ const KNOWN_TYPES: &[&str] = &["FTy", "CFn", "CArgs", "CRet", "RustFn", "RustArg
 
 /// A type used in a function signature.
 #[allow(dead_code)]
-#[derive(Debug, Clone, Copy)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum Ty {
     F16,
     F32,
@@ -359,7 +359,7 @@ pub fn base_name_enum(attributes: pm::TokenStream, tokens: pm::TokenStream) -> p
 ///         // The Rust version's return type (e.g. `(f32, f32)`)
 ///         RustRet: $RustRet:ty,
 ///         // Attributes for the current function, if any
-///         attrs: [$($meta:meta)*]
+///         attrs: [$($meta:meta),*],
 ///         // Extra tokens passed directly (if any)
 ///         extra: [$extra:ident],
 ///         // Extra function-tokens passed directly (if any)
@@ -377,6 +377,8 @@ pub fn base_name_enum(attributes: pm::TokenStream, tokens: pm::TokenStream) -> p
 ///     skip: [sin, cos],
 ///     // Attributes passed as `attrs` for specific functions. For example, here the invocation
 ///     // with `sinf` and that with `cosf` will both get `meta1` and `meta2`, but no others will.
+///     // Note that `f16_enabled` and `f128_enabled` will always get emitted regardless of whether
+///     // or not this is specified.
 ///     attributes: [
 ///         #[meta1]
 ///         #[meta2]
@@ -535,16 +537,28 @@ fn expand(input: StructuredInput, fn_list: &[&FunctionInfo]) -> syn::Result<pm2:
         let fn_name = Ident::new(func.name, Span::call_site());
 
         // Prepare attributes in an `attrs: ...` field
-        let meta_field = match &input.attributes {
-            Some(attrs) => {
-                let meta = attrs
-                    .iter()
-                    .filter(|map| map.names.contains(&fn_name))
-                    .flat_map(|map| &map.meta);
-                quote! { attrs: [ #( #meta )* ]  }
-            }
-            None => pm2::TokenStream::new(),
-        };
+        let mut meta_fields = Vec::new();
+        if let Some(attrs) = &input.attributes {
+            let meta_iter = attrs
+                .iter()
+                .filter(|map| map.names.contains(&fn_name))
+                .flat_map(|map| &map.meta)
+                .map(|v| v.into_token_stream());
+
+            meta_fields.extend(meta_iter);
+        }
+
+        // Always emit f16 and f128 meta so this doesn't need to be repeated everywhere
+        if func.rust_sig.args.contains(&Ty::F16) || func.rust_sig.returns.contains(&Ty::F16) {
+            let ts = quote! { cfg(f16_enabled) };
+            meta_fields.push(ts);
+        }
+        if func.rust_sig.args.contains(&Ty::F128) || func.rust_sig.returns.contains(&Ty::F128) {
+            let ts = quote! { cfg(f128_enabled) };
+            meta_fields.push(ts);
+        }
+
+        let meta_field = quote! { attrs: [ #( #meta_fields ),* ], };
 
         // Prepare extra in an `extra: ...` field, running the replacer
         let extra_field = match input.extra.clone() {

crates/libm-macros/tests/basic.rs

@@ -1,4 +1,6 @@
 // `STATUS_DLL_NOT_FOUND` on i686 MinGW, not worth looking into.
+#![feature(f16)]
+#![feature(f128)]
 #![cfg(not(all(target_arch = "x86", target_os = "windows", target_env = "gnu")))]
 
 macro_rules! basic {
@@ -11,7 +13,7 @@ macro_rules! basic {
         RustFn: $RustFn:ty,
         RustArgs: $RustArgs:ty,
         RustRet: $RustRet:ty,
-        attrs: [$($meta:meta)*]
+        attrs: [$($meta:meta),*],
         extra: [$($extra_tt:tt)*],
         fn_extra: $fn_extra:expr,
     ) => {
@@ -60,6 +62,7 @@ mod test_basic {
 macro_rules! basic_no_extra {
     (
         fn_name: $fn_name:ident,
+        attrs: [$($meta:meta),*],
     ) => {
         mod $fn_name {}
     };
@@ -85,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/Cargo.toml

@@ -8,7 +8,7 @@ publish = false
 default = ["unstable-float"]
 
 # Propagated from libm because this affects which functions we test.
-unstable-float = ["libm/unstable-float"]
+unstable-float = ["libm/unstable-float", "rug?/nightly-float"]
 
 # Generate tests which are random inputs and the outputs are calculated with
 # musl libc.
@@ -51,5 +51,5 @@ harness = false
 [lints.rust]
 # Values from the chared config.rs used by `libm` but not the test crate
 unexpected_cfgs = { level = "warn", check-cfg = [
-  'cfg(feature, values("arch", "force-soft-floats", "no-f16-f128", "unstable-intrinsics"))',
+  'cfg(feature, values("arch", "force-soft-floats", "unstable-intrinsics"))',
 ] }

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 libm_test::OpCFn<Op>),
+                    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/gen.rs

@@ -6,11 +6,29 @@ pub mod random;
 /// Helper type to turn any reusable input into a generator.
 #[derive(Clone, Debug, Default)]
 pub struct CachedInput {
+    #[cfg(f16_enabled)]
+    pub inputs_f16: Vec<(f16, f16, f16)>,
     pub inputs_f32: Vec<(f32, f32, f32)>,
     pub inputs_f64: Vec<(f64, f64, f64)>,
+    #[cfg(f128_enabled)]
+    pub inputs_f128: Vec<(f128, f128, f128)>,
     pub inputs_i32: Vec<(i32, i32, i32)>,
 }
 
+#[cfg(f16_enabled)]
+impl GenerateInput<(f16,)> for CachedInput {
+    fn get_cases(&self) -> impl Iterator<Item = (f16,)> {
+        self.inputs_f16.iter().map(|f| (f.0,))
+    }
+}
+
+#[cfg(f16_enabled)]
+impl GenerateInput<(f16, f16)> for CachedInput {
+    fn get_cases(&self) -> impl Iterator<Item = (f16, f16)> {
+        self.inputs_f16.iter().map(|f| (f.0, f.1))
+    }
+}
+
 impl GenerateInput<(f32,)> for CachedInput {
     fn get_cases(&self) -> impl Iterator<Item = (f32,)> {
         self.inputs_f32.iter().map(|f| (f.0,))
@@ -70,3 +88,17 @@ impl GenerateInput<(f64, f64, f64)> for CachedInput {
         self.inputs_f64.iter().copied()
     }
 }
+
+#[cfg(f128_enabled)]
+impl GenerateInput<(f128,)> for CachedInput {
+    fn get_cases(&self) -> impl Iterator<Item = (f128,)> {
+        self.inputs_f128.iter().map(|f| (f.0,))
+    }
+}
+
+#[cfg(f128_enabled)]
+impl GenerateInput<(f128, f128)> for CachedInput {
+    fn get_cases(&self) -> impl Iterator<Item = (f128, f128)> {
+        self.inputs_f128.iter().map(|f| (f.0, f.1))
+    }
+}