libm: Improve debug output for Status

Author: tgross35

libm/src/math/support/env.rs

@@ -11,6 +11,8 @@
 //! side effects from elementary operations). Full support would require wrappers around basic
 //! operations, but there is no plan to add this at the current time.
 
+use core::fmt;
+
 /// A value combined with a floating point status.
 pub struct FpResult<T> {
     pub val: T,
@@ -49,7 +51,7 @@ pub enum Round {
 }
 
 /// IEEE 754 exception status flags.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct Status(u8);
 
 impl Status {
@@ -74,22 +76,22 @@ impl Status {
     /// result is -inf.
     /// `x / y` when `x != 0.0` and `y == 0.0`,
     #[cfg_attr(not(feature = "unstable-public-internals"), allow(dead_code))]
-    pub const DIVIDE_BY_ZERO: Self = Self(1 << 2);
+    pub const DIVIDE_BY_ZERO: Self = Self(1 << 1);
 
     /// The result exceeds the maximum finite value.
     ///
     /// The default result depends on rounding mode. `Nearest*` rounds to +/- infinity, sign based
     /// on the intermediate result. `Zero` rounds to the signed maximum finite. `Positive` and
     /// `Negative` round to signed maximum finite in one direction, signed infinity in the other.
     #[cfg_attr(not(feature = "unstable-public-internals"), allow(dead_code))]
-    pub const OVERFLOW: Self = Self(1 << 3);
+    pub const OVERFLOW: Self = Self(1 << 2);
 
     /// The result is subnormal and lost precision.
-    pub const UNDERFLOW: Self = Self(1 << 4);
+    pub const UNDERFLOW: Self = Self(1 << 3);
 
     /// The finite-precision result does not match that of infinite precision, and the reason
     /// is not represented by one of the other flags.
-    pub const INEXACT: Self = Self(1 << 5);
+    pub const INEXACT: Self = Self(1 << 4);
 
     /// True if `UNDERFLOW` is set.
     #[cfg_attr(not(feature = "unstable-public-internals"), allow(dead_code))]
@@ -128,3 +130,38 @@ impl Status {
         Self(self.0 | rhs.0)
     }
 }
+
+#[cfg(any(test, feature = "unstable-public-internals"))]
+impl fmt::Debug for Status {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // shift -> flag map
+        let names = &[
+            "INVALID",
+            "DIVIDE_BY_ZERO",
+            "OVERFLOW",
+            "UNDERFLOW",
+            "INEXACT",
+        ];
+
+        write!(f, "Status(")?;
+        let mut any = false;
+        for shift in 0..u8::BITS {
+            if self.0 & (1 << shift) != 0 {
+                if any {
+                    write!(f, " | ")?;
+                }
+                match names.get(shift as usize) {
+                    Some(name) => write!(f, "{name}")?,
+                    None => write!(f, "UNKNOWN(1 << {shift})")?,
+                }
+                any = true;
+            }
+        }
+
+        if !any {
+            write!(f, "OK")?;
+        }
+        write!(f, ")")?;
+        Ok(())
+    }
+}