disable floating point testing on some architectures

Author: AaronKutch

src/float/div.rs

@@ -1,5 +1,5 @@
 use float::Float;
-use int::{CastInto, Int, HInt, DInt};
+use int::{CastInto, DInt, HInt, Int};
 
 fn div32<F: Float>(a: F, b: F) -> F
 where

src/float/mul.rs

@@ -1,5 +1,5 @@
 use float::Float;
-use int::{CastInto, Int, HInt, DInt};
+use int::{CastInto, DInt, HInt, Int};
 
 fn mul<F: Float>(a: F, b: F) -> F
 where
@@ -112,7 +112,9 @@ where
     // have (exponentBits + 2) integral digits, all but two of which must be
     // zero.  Normalizing this result is just a conditional left-shift by one
     // and bumping the exponent accordingly.
-    let (mut product_low, mut product_high) = a_significand.widen_mul(b_significand << exponent_bits).lo_hi();
+    let (mut product_low, mut product_high) = a_significand
+        .widen_mul(b_significand << exponent_bits)
+        .lo_hi();
 
     let a_exponent_i32: i32 = a_exponent.cast();
     let b_exponent_i32: i32 = b_exponent.cast();

testcrate/build.rs

@@ -648,10 +648,7 @@ fn main() {
                 return None;
             }
             let c = a.0 / b.0;
-            if a.0.is_nan()
-                || b.0.is_nan()
-                || c.is_nan()
-                || c.abs() <= f32::from_bits(16777215u32)
+            if a.0.is_nan() || b.0.is_nan() || c.is_nan() || c.abs() <= f32::from_bits(16777215u32)
             {
                 None
             } else {

testcrate/src/lib.rs

@@ -9,6 +9,9 @@
 //! encounter. The randomized fuzz testing is specially designed to cover wide swaths of search
 //! space in as few iterations as possible. See `fuzz_values` in `testcrate/tests/misc.rs` for an
 //! example.
+//!
+//! Some floating point tests are disabled on x86 architectures without SSE, because they do not
+//! have correct rounding.
 #![no_std]
 
 use compiler_builtins::float::Float;

testcrate/tests/addsub.rs

@@ -91,6 +91,7 @@ macro_rules! float_sum {
     };
 }
 
+#[cfg(not(all(target_arch = "x86", not(target_feature = "sse"))))]
 #[test]
 fn float_addsub() {
     use compiler_builtins::float::{

testcrate/tests/conv.rs

@@ -12,6 +12,7 @@ macro_rules! i_to_f {
     };
 }
 
+#[cfg(not(all(target_arch = "x86", not(target_feature = "sse"))))]
 #[test]
 fn int_to_float() {
     use compiler_builtins::float::conv::{

testcrate/tests/div_rem.rs

@@ -1,6 +1,9 @@
 use compiler_builtins::int::sdiv::{__divmoddi4, __divmodsi4, __divmodti4};
 use compiler_builtins::int::udiv::{__udivmoddi4, __udivmodsi4, __udivmodti4, u128_divide_sparc};
 
+// Division algorithms have by far the nastiest and largest number of edge cases, and experience shows
+// that sometimes 100_000 iterations of the random fuzzer is needed.
+
 /// Creates intensive test functions for division functions of a certain size
 macro_rules! test {
     (
@@ -97,7 +100,6 @@ fn divide_sparc() {
     });
 }
 
-
 macro_rules! float {
     ($n:expr, $($i:ty, $fn:ident);*;) => {
         $(
@@ -118,13 +120,16 @@ macro_rules! float {
     };
 }
 
+#[cfg(not(all(target_arch = "x86", not(target_feature = "sse"))))]
 #[test]
 fn float_div() {
-    use compiler_builtins::float::{Float, div::{__divsf3, __divdf3}};
+    use compiler_builtins::float::{
+        div::{__divdf3, __divsf3},
+        Float,
+    };
 
-    float!(10_000,
+    float!(100_000,
         f32, __divsf3;
         f64, __divdf3;
     );
 }
-

testcrate/tests/mul.rs

@@ -97,9 +97,13 @@ macro_rules! float_mul {
     };
 }
 
+#[cfg(not(all(target_arch = "x86", not(target_feature = "sse"))))]
 #[test]
 fn float_mul() {
-    use compiler_builtins::float::{Float, mul::{__mulsf3, __muldf3}};
+    use compiler_builtins::float::{
+        mul::{__muldf3, __mulsf3},
+        Float,
+    };
 
     float_mul!(10_000,
         f32, __mulsf3;