Auto merge of #111 - mattico:new_float_quickcheck, r=japaric

Add float quickcheck

Author: bors

build.rs

@@ -360,6 +360,10 @@ fn main() {
 
         }
 
+        if llvm_target.last().unwrap().ends_with("gnueabi") {
+            sources.extend(&["addsf3.c", "adddf3.c"]);
+        }
+
         if target_arch == "aarch64" {
             sources.extend(&["comparetf2.c",
                              "extenddftf2.c",
@@ -426,6 +430,8 @@ fn main() {
     // To filter away some flaky test (see src/float/add.rs for details)
     if llvm_target.last() == Some(&"gnueabihf") {
         println!("cargo:rustc-cfg=gnueabihf")
+    } else if llvm_target.last() == Some(&"gnueabi") {
+        println!("cargo:rustc-cfg=gnueabi")
     }
 
     // To compile intrinsics.rs for thumb targets, where there is no libc

src/arm.rs

@@ -58,11 +58,17 @@ pub unsafe fn __aeabi_ldivmod() {
 }
 
 // TODO: These aeabi_* functions should be defined as aliases
+
+// NOTE(cfg) The gnueabi targets use the C implementation for now
+// https://github.com/rust-lang-nursery/compiler-builtins/issues/90
+
+#[cfg(not(gnueabi))]
 #[cfg_attr(not(test), no_mangle)]
 pub extern "C" fn __aeabi_dadd(a: f64, b: f64) -> f64 {
     ::float::add::__adddf3(a, b)
 }
 
+#[cfg(not(gnueabi))]
 #[cfg_attr(not(test), no_mangle)]
 pub extern "C" fn __aeabi_fadd(a: f32, b: f32) -> f32 {
     ::float::add::__addsf3(a, b)

src/float/add.rs

@@ -187,111 +187,20 @@ add!(__adddf3: f64);
 #[cfg(test)]
 mod tests {
     use core::{f32, f64};
+    use qc::{F32, F64};
 
-    use float::{Float, FRepr};
-    use qc::{U32, U64};
-
-    // TODO: Add F32/F64 to qc so that they print the right values (at the very least)
     check! {
         fn __addsf3(f: extern fn(f32, f32) -> f32,
-                    a: U32,
-                    b: U32)
-                    -> Option<FRepr<f32> > {
-            let (a, b) = (f32::from_repr(a.0), f32::from_repr(b.0));
-            Some(FRepr(f(a, b)))
+                    a: F32,
+                    b: F32)
+                    -> Option<F32> {
+            Some(F32(f(a.0, b.0)))
         }
 
         fn __adddf3(f: extern fn(f64, f64) -> f64,
-                    a: U64,
-                    b: U64) -> Option<FRepr<f64> > {
-            let (a, b) = (f64::from_repr(a.0), f64::from_repr(b.0));
-            Some(FRepr(f(a, b)))
+                    a: F64,
+                    b: F64) -> Option<F64> {
+            Some(F64(f(a.0, b.0)))
         }
     }
-
-    // More tests for special float values
-
-    #[test]
-    fn test_float_tiny_plus_tiny() {
-        let tiny = f32::from_repr(1);
-        let r = super::__addsf3(tiny, tiny);
-        assert!(r.eq_repr(tiny + tiny));
-    }
-
-    #[test]
-    fn test_double_tiny_plus_tiny() {
-        let tiny = f64::from_repr(1);
-        let r = super::__adddf3(tiny, tiny);
-        assert!(r.eq_repr(tiny + tiny));
-    }
-
-    #[test]
-    fn test_float_small_plus_small() {
-        let a = f32::from_repr(327);
-        let b = f32::from_repr(256);
-        let r = super::__addsf3(a, b);
-        assert!(r.eq_repr(a + b));
-    }
-
-    #[test]
-    fn test_double_small_plus_small() {
-        let a = f64::from_repr(327);
-        let b = f64::from_repr(256);
-        let r = super::__adddf3(a, b);
-        assert!(r.eq_repr(a + b));
-    }
-
-    #[test]
-    fn test_float_one_plus_one() {
-        let r = super::__addsf3(1f32, 1f32);
-        assert!(r.eq_repr(1f32 + 1f32));
-    }
-
-    #[test]
-    fn test_double_one_plus_one() {
-        let r = super::__adddf3(1f64, 1f64);
-        assert!(r.eq_repr(1f64 + 1f64));
-    }
-
-    #[test]
-    fn test_float_different_nan() {
-        let a = f32::from_repr(1);
-        let b = f32::from_repr(0b11111111100100010001001010101010);
-        let x = super::__addsf3(a, b);
-        let y = a + b;
-        assert!(x.eq_repr(y));
-    }
-
-    #[test]
-    fn test_double_different_nan() {
-        let a = f64::from_repr(1);
-        let b = f64::from_repr(0b1111111111110010001000100101010101001000101010000110100011101011);
-        let x = super::__adddf3(a, b);
-        let y = a + b;
-        assert!(x.eq_repr(y));
-    }
-
-    #[test]
-    fn test_float_nan() {
-        let r = super::__addsf3(f32::NAN, 1.23);
-        assert_eq!(r.repr(), f32::NAN.repr());
-    }
-
-    #[test]
-    fn test_double_nan() {
-        let r = super::__adddf3(f64::NAN, 1.23);
-        assert_eq!(r.repr(), f64::NAN.repr());
-    }
-
-    #[test]
-    fn test_float_inf() {
-        let r = super::__addsf3(f32::INFINITY, -123.4);
-        assert_eq!(r, f32::INFINITY);
-    }
-
-    #[test]
-    fn test_double_inf() {
-        let r = super::__adddf3(f64::INFINITY, -123.4);
-        assert_eq!(r, f64::INFINITY);
-    }
 }

src/float/mod.rs

@@ -1,7 +1,9 @@
 use core::mem;
-#[cfg(test)]
-use core::fmt;
 
+// NOTE(cfg) add is disabled for gnueabi due to 
+// https://github.com/rust-lang-nursery/compiler-builtins/issues/90
+
+#[cfg(not(gnueabi))]
 pub mod add;
 pub mod pow;
 
@@ -16,22 +18,41 @@ pub trait Float: Sized + Copy {
     /// Returns the bitwidth of the significand
     fn significand_bits() -> u32;
 
+    /// Returns the bitwidth of the exponent
+    fn exponent_bits() -> u32 {
+        Self::bits() - Self::significand_bits() - 1
+    }
+
+    /// Returns a mask for the sign bit
+    fn sign_mask() -> Self::Int;
+
+    /// Returns a mask for the significand
+    fn significand_mask() -> Self::Int;
+
+    /// Returns a mask for the exponent
+    fn exponent_mask() -> Self::Int;
+
     /// Returns `self` transmuted to `Self::Int`
     fn repr(self) -> Self::Int;
 
     #[cfg(test)]
     /// Checks if two floats have the same bit representation. *Except* for NaNs! NaN can be
-    /// represented in multiple different ways. This methods returns `true` if two NaNs are
+    /// represented in multiple different ways. This method returns `true` if two NaNs are
     /// compared.
     fn eq_repr(self, rhs: Self) -> bool;
 
     /// Returns a `Self::Int` transmuted back to `Self`
     fn from_repr(a: Self::Int) -> Self;
 
+    /// Constructs a `Self` from its parts. Inputs are treated as bits and shifted into position.
+    fn from_parts(sign: bool, exponent: Self::Int, significand: Self::Int) -> Self;
+
     /// Returns (normalized exponent, normalized significand)
     fn normalize(significand: Self::Int) -> (i32, Self::Int);
 }
 
+// FIXME: Some of this can be removed if RFC Issue #1424 is resolved
+//        https://github.com/rust-lang/rfcs/issues/1424
 impl Float for f32 {
     type Int = u32;
     fn bits() -> u32 {
@@ -40,6 +61,15 @@ impl Float for f32 {
     fn significand_bits() -> u32 {
         23
     }
+    fn sign_mask() -> Self::Int {
+        1 << (Self::bits() - 1)
+    }
+    fn significand_mask() -> Self::Int {
+        (1 << Self::significand_bits()) - 1
+    }
+    fn exponent_mask() -> Self::Int {
+        !(Self::sign_mask() | Self::significand_mask())
+    }
     fn repr(self) -> Self::Int {
         unsafe { mem::transmute(self) }
     }
@@ -54,6 +84,11 @@ impl Float for f32 {
     fn from_repr(a: Self::Int) -> Self {
         unsafe { mem::transmute(a) }
     }
+    fn from_parts(sign: bool, exponent: Self::Int, significand: Self::Int) -> Self {
+        Self::from_repr(((sign as Self::Int) << (Self::bits() - 1)) |
+            ((exponent << Self::significand_bits()) & Self::exponent_mask()) |
+            (significand & Self::significand_mask()))
+    }
     fn normalize(significand: Self::Int) -> (i32, Self::Int) {
         let shift = significand.leading_zeros()
             .wrapping_sub((1u32 << Self::significand_bits()).leading_zeros());
@@ -68,6 +103,15 @@ impl Float for f64 {
     fn significand_bits() -> u32 {
         52
     }
+    fn sign_mask() -> Self::Int {
+        1 << (Self::bits() - 1)
+    }
+    fn significand_mask() -> Self::Int {
+        (1 << Self::significand_bits()) - 1
+    }
+    fn exponent_mask() -> Self::Int {
+        !(Self::sign_mask() | Self::significand_mask())
+    }
     fn repr(self) -> Self::Int {
         unsafe { mem::transmute(self) }
     }
@@ -82,36 +126,14 @@ impl Float for f64 {
     fn from_repr(a: Self::Int) -> Self {
         unsafe { mem::transmute(a) }
     }
+    fn from_parts(sign: bool, exponent: Self::Int, significand: Self::Int) -> Self {
+        Self::from_repr(((sign as Self::Int) << (Self::bits() - 1)) |
+            ((exponent << Self::significand_bits()) & Self::exponent_mask()) |
+            (significand & Self::significand_mask()))
+    }
     fn normalize(significand: Self::Int) -> (i32, Self::Int) {
         let shift = significand.leading_zeros()
             .wrapping_sub((1u64 << Self::significand_bits()).leading_zeros());
         (1i32.wrapping_sub(shift as i32), significand << shift as Self::Int)
     }
 }
-
-// TODO: Move this to F32/F64 in qc.rs
-#[cfg(test)]
-#[derive(Copy, Clone)]
-pub struct FRepr<F>(F);
-
-#[cfg(test)]
-impl<F: Float> PartialEq for FRepr<F> {
-    fn eq(&self, other: &FRepr<F>) -> bool {
-        // NOTE(cfg) for some reason, on hard float targets, our implementation doesn't
-        // match the output of its gcc_s counterpart. Until we investigate further, we'll
-        // just avoid testing against gcc_s on those targets. Do note that our
-        // implementation matches the output of the FPU instruction on *hard* float targets
-        // and matches its gcc_s counterpart on *soft* float targets.
-        if cfg!(gnueabihf) {
-            return true
-        }
-        self.0.eq_repr(other.0)
-    }
-}
-
-#[cfg(test)]
-impl<F: fmt::Debug> fmt::Debug for FRepr<F> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}

src/float/pow.rs

@@ -31,22 +31,19 @@ pow!(__powidf2: f64, i32);
 
 #[cfg(test)]
 mod tests {
-    use float::{Float, FRepr};
-    use qc::{I32, U32, U64};
+    use qc::{I32, F32, F64};
 
     check! {
         fn __powisf2(f: extern fn(f32, i32) -> f32, 
-                     a: U32, 
-                     b: I32) -> Option<FRepr<f32> > {
-            let (a, b) = (f32::from_repr(a.0), b.0);
-            Some(FRepr(f(a, b)))
+                     a: F32, 
+                     b: I32) -> Option<F32> {
+            Some(F32(f(a.0, b.0)))
         }
 
         fn __powidf2(f: extern fn(f64, i32) -> f64, 
-                     a: U64, 
-                     b: I32) -> Option<FRepr<f64> > {
-            let (a, b) = (f64::from_repr(a.0), b.0);
-            Some(FRepr(f(a, b)))
+                     a: F64, 
+                     b: I32) -> Option<F64> {
+            Some(F64(f(a.0, b.0)))
         }
     }
 }