Add a way to print inputs on failure

When there is a panic in an extensive test, tracing down where it came
from can be difficult since no information is provides (messeges are
e.g. "attempted to subtract with overflow"). Resolve this by calling the
functions within `panic::catch_unwind`, printing the input, and
continuing.

Author: tgross35

crates/libm-test/src/op.rs

@@ -14,6 +14,7 @@
 //!   level. `Op` is also used as the name for generic parameters since it is terse.
 
 use std::fmt;
+use std::panic::{RefUnwindSafe, UnwindSafe};
 
 pub use shared::{ALL_OPERATIONS, FloatTy, MathOpInfo, Ty};
 
@@ -64,15 +65,16 @@ pub trait MathOp {
     type CRet;
 
     /// The signature of the Rust function as a `fn(...) -> ...` type.
-    type RustFn: Copy;
+    type RustFn: Copy + UnwindSafe;
 
     /// Arguments passed to the Rust library function as a tuple.
     ///
     /// The required `TupleCall` bounds ensure this type can be passed either to the C function or
     /// to the Rust function.
     type RustArgs: Copy
         + TupleCall<Self::RustFn, Output = Self::RustRet>
-        + TupleCall<Self::CFn, Output = Self::RustRet>;
+        + TupleCall<Self::CFn, Output = Self::RustRet>
+        + RefUnwindSafe;
 
     /// Type returned from the Rust function.
     type RustRet: CheckOutput<Self::RustArgs>;

crates/libm-test/src/test_traits.rs

@@ -6,7 +6,8 @@
 //! - `CheckOutput`: implemented on anything that is an output type for validation against an
 //!   expected value.
 
-use std::fmt;
+use std::panic::{RefUnwindSafe, UnwindSafe};
+use std::{fmt, panic};
 
 use anyhow::{Context, anyhow, bail, ensure};
 use libm::support::Hexf;
@@ -20,9 +21,25 @@ use crate::{
 ///
 /// Implemented on the tuple with the function signature as the generic (so we can use the same
 /// tuple for multiple signatures).
-pub trait TupleCall<Func>: fmt::Debug {
+pub trait TupleCall<Func>: Copy + fmt::Debug + Sized {
     type Output;
     fn call(self, f: Func) -> Self::Output;
+
+    /// Intercept panics and print the input to stderr before continuing.
+    fn call_intercept_panics(self, f: Func) -> Self::Output
+    where
+        Self: RefUnwindSafe,
+        Func: UnwindSafe,
+    {
+        let res = panic::catch_unwind(|| self.call(f));
+        match res {
+            Ok(v) => v,
+            Err(e) => {
+                eprintln!("panic with the following input: {self:?}");
+                panic::resume_unwind(e)
+            }
+        }
+    }
 }
 
 /// A trait to implement on any output type so we can verify it in a generic way.
@@ -48,7 +65,7 @@ pub trait Hex: Copy {
 
 impl<T1, R> TupleCall<fn(T1) -> R> for (T1,)
 where
-    T1: fmt::Debug,
+    T1: RefUnwindSafe + fmt::Debug + Copy,
 {
     type Output = R;
 
@@ -59,8 +76,8 @@ where
 
 impl<T1, T2, R> TupleCall<fn(T1, T2) -> R> for (T1, T2)
 where
-    T1: fmt::Debug,
-    T2: fmt::Debug,
+    T1: RefUnwindSafe + fmt::Debug + Copy,
+    T2: RefUnwindSafe + fmt::Debug + Copy,
 {
     type Output = R;
 
@@ -71,8 +88,8 @@ where
 
 impl<T1, T2, R> TupleCall<fn(T1, &mut T2) -> R> for (T1,)
 where
-    T1: fmt::Debug,
-    T2: fmt::Debug + Default,
+    T1: RefUnwindSafe + fmt::Debug + Copy,
+    T2: RefUnwindSafe + fmt::Debug + Copy + Default,
 {
     type Output = (R, T2);
 
@@ -84,9 +101,9 @@ where
 
 impl<T1, T2, T3, R> TupleCall<fn(T1, T2, T3) -> R> for (T1, T2, T3)
 where
-    T1: fmt::Debug,
-    T2: fmt::Debug,
-    T3: fmt::Debug,
+    T1: RefUnwindSafe + fmt::Debug + Copy,
+    T2: RefUnwindSafe + fmt::Debug + Copy,
+    T3: RefUnwindSafe + fmt::Debug + Copy,
 {
     type Output = R;
 
@@ -97,9 +114,9 @@ where
 
 impl<T1, T2, T3, R> TupleCall<fn(T1, T2, &mut T3) -> R> for (T1, T2)
 where
-    T1: fmt::Debug,
-    T2: fmt::Debug,
-    T3: fmt::Debug + Default,
+    T1: RefUnwindSafe + fmt::Debug + Copy,
+    T2: RefUnwindSafe + fmt::Debug + Copy,
+    T3: RefUnwindSafe + fmt::Debug + Copy + Default,
 {
     type Output = (R, T3);
 
@@ -111,9 +128,9 @@ where
 
 impl<T1, T2, T3> TupleCall<for<'a> fn(T1, &'a mut T2, &'a mut T3)> for (T1,)
 where
-    T1: fmt::Debug,
-    T2: fmt::Debug + Default,
-    T3: fmt::Debug + Default,
+    T1: RefUnwindSafe + fmt::Debug + Copy,
+    T2: RefUnwindSafe + fmt::Debug + Copy + Default,
+    T3: RefUnwindSafe + fmt::Debug + Copy + Default,
 {
     type Output = (T2, T3);
 

crates/libm-test/tests/compare_built_musl.rs

@@ -21,7 +21,7 @@ fn musl_runner<Op: MathOp>(
 ) {
     for input in cases {
         let musl_res = input.call(musl_fn);
-        let crate_res = input.call(Op::ROUTINE);
+        let crate_res = input.call_intercept_panics(Op::ROUTINE);
 
         crate_res.validate(musl_res, input, ctx).unwrap();
     }

crates/libm-test/tests/multiprecision.rs

@@ -12,7 +12,7 @@ fn mp_runner<Op: MathOp + MpOp>(ctx: &CheckCtx, cases: impl Iterator<Item = Op::
     let mut mp_vals = Op::new_mp();
     for input in cases {
         let mp_res = Op::run(&mut mp_vals, input);
-        let crate_res = input.call(Op::ROUTINE);
+        let crate_res = input.call_intercept_panics(Op::ROUTINE);
 
         crate_res.validate(mp_res, input, ctx).unwrap();
     }

crates/libm-test/tests/standalone.rs

@@ -10,7 +10,7 @@ fn standalone_runner<Op: MathOp>(
     cases: impl Iterator<Item = (Op::RustArgs, Op::RustRet)>,
 ) {
     for (input, expected) in cases {
-        let crate_res = input.call(Op::ROUTINE);
+        let crate_res = input.call_intercept_panics(Op::ROUTINE);
         crate_res.validate(expected, input, ctx).unwrap();
     }
 }

crates/libm-test/tests/z_extensive/run.rs

@@ -113,7 +113,7 @@ where
         for input in input_vec {
             // Test the input.
             let mp_res = Op::run(mp_vals, input);
-            let crate_res = input.call(Op::ROUTINE);
+            let crate_res = input.call_intercept_panics(Op::ROUTINE);
             crate_res.validate(mp_res, input, ctx)?;
 
             let completed = completed.fetch_add(1, Ordering::Relaxed) + 1;

crates/util/src/main.rs

@@ -59,7 +59,7 @@ macro_rules! handle_call {
             let libm_fn: <Op as MathOp>::RustFn = libm::$fn_name;
 
             let output = match $basis {
-                "libm" => input.call(libm_fn),
+                "libm" => input.call_intercept_panics(libm_fn),
                 #[cfg(feature = "build-musl")]
                 "musl" => {
                     let musl_fn: <Op as MathOp>::CFn =