Make float addition implementation wrap

Author: mattico

src/float/add.rs

@@ -1,3 +1,4 @@
+use core::num::Wrapping;
 use float::Float;
 
 macro_rules! add {
@@ -6,41 +7,44 @@ macro_rules! add {
         #[allow(unused_parens)]
         #[cfg_attr(not(test), no_mangle)]
         pub extern fn $intrinsic(a: $ty, b: $ty) -> $ty {
-            let bits =             <$ty>::bits() as <$ty as Float>::Int;
-            let significand_bits = <$ty>::significand_bits() as <$ty as Float>::Int;
-            let exponent_bits =    bits - significand_bits - 1;
-            let max_exponent =     (1 << exponent_bits) - 1;
-
-            let implicit_bit =     1 << significand_bits;
-            let significand_mask = implicit_bit - 1;
-            let sign_bit =         1 << (significand_bits + exponent_bits);
-            let abs_mask =         sign_bit - 1;
+            let one = Wrapping(1 as <$ty as Float>::Int);
+            let zero = Wrapping(0 as <$ty as Float>::Int);
+
+            let bits =             Wrapping(<$ty>::bits() as <$ty as Float>::Int);
+            let significand_bits = Wrapping(<$ty>::significand_bits() as <$ty as Float>::Int);
+            let exponent_bits =    bits - significand_bits - one;
+            let max_exponent =     (one << exponent_bits.0 as usize) - one;
+
+            let implicit_bit =     one << significand_bits.0 as usize;
+            let significand_mask = implicit_bit - one;
+            let sign_bit =         one << (significand_bits + exponent_bits).0 as usize;
+            let abs_mask =         sign_bit - one;
             let exponent_mask =    abs_mask ^ significand_mask;
             let inf_rep =          exponent_mask;
             let quiet_bit =        implicit_bit >> 1;
             let qnan_rep =         exponent_mask | quiet_bit;
 
-            let mut a_rep = a.repr();
-            let mut b_rep = b.repr();
+            let mut a_rep = Wrapping(a.repr());
+            let mut b_rep = Wrapping(b.repr());
             let a_abs = a_rep & abs_mask;
             let b_abs = b_rep & abs_mask;
 
             // Detect if a or b is zero, infinity, or NaN.
-            if a_abs - 1 >= inf_rep - 1 ||
-                b_abs - 1 >= inf_rep - 1 {
+            if a_abs - one >= inf_rep - one ||
+                b_abs - one >= inf_rep - one {
                 // NaN + anything = qNaN
                 if a_abs > inf_rep {
-                    return (<$ty as Float>::from_repr(a_abs | quiet_bit));
+                    return (<$ty as Float>::from_repr((a_abs | quiet_bit).0));
                 }
                 // anything + NaN = qNaN
                 if b_abs > inf_rep {
-                    return (<$ty as Float>::from_repr(b_abs | quiet_bit));
+                    return (<$ty as Float>::from_repr((b_abs | quiet_bit).0));
                 }
 
                 if a_abs == inf_rep {
                     // +/-infinity + -/+infinity = qNaN
-                    if a.repr() ^ b.repr() == sign_bit {
-                        return (<$ty as Float>::from_repr(qnan_rep));
+                    if a.repr() ^ b.repr() == sign_bit.0 {
+                        return (<$ty as Float>::from_repr(qnan_rep.0));
                     } else {
                         // +/-infinity + anything remaining = +/- infinity
                         return a;
@@ -53,17 +57,17 @@ macro_rules! add {
                 }
 
                 // zero + anything = anything
-                if a_abs == 0 {
+                if a_abs.0 == 0 {
                     // but we need to get the sign right for zero + zero
-                    if b_abs == 0 {
+                    if b_abs.0 == 0 {
                         return (<$ty as Float>::from_repr(a.repr() & b.repr()));
                     } else {
                         return b;
                     }
                 }
 
                 // anything + zero = anything
-                if b_abs == 0 {
+                if b_abs.0 == 0 {
                      return a;
                 }
             }
@@ -76,27 +80,27 @@ macro_rules! add {
             }
 
             // Extract the exponent and significand from the (possibly swapped) a and b.
-            let mut a_exponent = a_rep >> significand_bits & max_exponent;
-            let mut b_exponent = b_rep >> significand_bits & max_exponent;
+            let mut a_exponent = a_rep >> significand_bits.0 as usize & max_exponent;
+            let mut b_exponent = b_rep >> significand_bits.0 as usize & max_exponent;
             let mut a_significand = a_rep & significand_mask;
             let mut b_significand = b_rep & significand_mask;
 
             // normalize any denormals, and adjust the exponent accordingly.
-            if a_exponent == 0 {
-                let (exponent, significand) = <$ty>::normalize(a_significand);
-                a_exponent = exponent;
-                a_significand = significand; 
+            if a_exponent.0 == 0 {
+                let (exponent, significand) = <$ty>::normalize(a_significand.0);
+                a_exponent = Wrapping(exponent);
+                a_significand = Wrapping(significand); 
             }
-            if b_exponent == 0 {
-                let (exponent, significand) = <$ty>::normalize(b_significand);
-                b_exponent = exponent;
-                b_significand = significand; 
+            if b_exponent.0 == 0 {
+                let (exponent, significand) = <$ty>::normalize(b_significand.0);
+                b_exponent = Wrapping(exponent);
+                b_significand = Wrapping(significand); 
             }
 
             // The sign of the result is the sign of the larger operand, a.  If they
             // have opposite signs, we are performing a subtraction; otherwise addition.
             let result_sign = a_rep & sign_bit;
-            let subtraction = (a_rep ^ b_rep) & sign_bit != 0;
+            let subtraction = (a_rep ^ b_rep) & sign_bit != zero;
 
             // Shift the significands to give us round, guard and sticky, and or in the
             // implicit significand bit.  (If we fell through from the denormal path it
@@ -108,70 +112,70 @@ macro_rules! add {
             // Shift the significand of b by the difference in exponents, with a sticky
             // bottom bit to get rounding correct.
             let align = a_exponent - b_exponent;
-            if align != 0 {
+            if align.0 != 0 {
                 if align < bits {
-                    let sticky = (b_significand << (bits - align) != 0) as <$ty as Float>::Int;
-                    b_significand = b_significand >> align | sticky;
+                    let sticky = ((b_significand << (bits - align).0 as usize).0 != 0) as <$ty as Float>::Int;
+                    b_significand = b_significand >> (align.0 | sticky) as usize;
                 } else {
-                    b_significand = 1; // sticky; b is known to be non-zero.
+                    b_significand = one; // sticky; b is known to be non-zero.
                 }
             }
             if subtraction {
                 a_significand -= b_significand;
                 // If a == -b, return +zero.
-                if a_significand == 0 { 
+                if a_significand.0 == 0 { 
                     return (<$ty as Float>::from_repr(0)); 
                 }
 
                 // If partial cancellation occured, we need to left-shift the result
                 // and adjust the exponent:
                 if a_significand < implicit_bit << 3 {
-                    let shift = (a_significand.leading_zeros() 
-                        - (implicit_bit << 3).leading_zeros()) as <$ty as Float>::Int;
-                    a_significand <<= shift;
-                    a_exponent -= shift;
+                    let shift = (a_significand.0.leading_zeros() 
+                        - (implicit_bit << 3).0.leading_zeros()) as <$ty as Float>::Int;
+                    a_significand <<= shift as usize;
+                    a_exponent -= Wrapping(shift);
                 }
             } else /* addition */ {
                 a_significand += b_significand;
 
                 // If the addition carried up, we need to right-shift the result and
                 // adjust the exponent:
-                if (a_significand & implicit_bit << 4) != 0 {
-                    let sticky = (a_significand & 1 != 0) as <$ty as Float>::Int;
-                    a_significand = a_significand >> 1 | sticky;
-                    a_exponent += 1;
+                if (a_significand & implicit_bit << 4).0 != 0 {
+                    let sticky = ((a_significand & one).0 != 0) as <$ty as Float>::Int;
+                    a_significand = a_significand >> 1 | Wrapping(sticky);
+                    a_exponent += one;
                 }
             }
 
             // If we have overflowed the type, return +/- infinity:
             if a_exponent >= max_exponent { 
-                return (<$ty>::from_repr(inf_rep | result_sign));
+                return (<$ty>::from_repr((inf_rep | result_sign).0));
             }
 
-            if a_exponent <= 0 {
+            if a_exponent.0 <= 0 {
                 // Result is denormal before rounding; the exponent is zero and we
                 // need to shift the significand.
-                let shift = 1 - a_exponent;
-                let sticky = (a_significand << (bits - shift) != 0) as <$ty as Float>::Int;
-                a_significand = a_significand >> shift | sticky;
-                a_exponent = 0;
+                let shift = one - a_exponent;
+                let sticky = ((a_significand << (bits - shift).0 as usize).0 != 0) as <$ty as Float>::Int;
+                a_significand = a_significand >> (shift.0 | sticky) as usize;
+                a_exponent = zero;
             }
 
             // Low three bits are round, guard, and sticky.
-            let round_guard_sticky = a_significand & 0x7;
+            let round_guard_sticky = a_significand & Wrapping(0x7);
 
             // Shift the significand into place, and mask off the implicit bit.
             let mut result = a_significand >> 3 & significand_mask;
 
             // Insert the exponent and sign.
-            result |= a_exponent << significand_bits;
+            result |= a_exponent << significand_bits.0 as usize;
             result |= result_sign;
 
             // Final rounding.  The result may overflow to infinity, but that is the
             // correct result in that case.
-            if round_guard_sticky > 0x4 { result += 1; }
-            if round_guard_sticky == 0x4 { result += result & 1; }
-            return (<$ty>::from_repr(result));
+            if round_guard_sticky > Wrapping(0x4) { result += one; }
+            if round_guard_sticky == Wrapping(0x4) { result += result & one; }
+            return (<$ty>::from_repr(result.0));
         }
     }
 }

src/float/mod.rs

@@ -1,5 +1,4 @@
-use core::mem::transmute;
-use core::ops::*;
+use core::mem;
 
 pub mod add;
 
@@ -33,15 +32,15 @@ impl Float for f32 {
         23
     }
     fn repr(self) -> Self::Int {
-        unsafe { transmute(self) }
+        unsafe { mem::transmute(self) }
     }
     fn from_repr(a: Self::Int) -> Self {
-        unsafe { transmute(a) }
+        unsafe { mem::transmute(a) }
     }
     fn normalize(significand: Self::Int) -> (Self::Int, Self::Int) {
-        let shift = Self::Int::leading_zeros(significand) 
-            - Self::Int::leading_zeros(1 << Self::significand_bits());
-        (1 - shift as Self::Int, significand << shift as Self::Int)
+        let shift = Self::Int::leading_zeros(significand)
+            .wrapping_sub(Self::Int::leading_zeros(1 << Self::significand_bits()));
+        (1u32.wrapping_sub(shift as Self::Int), significand << shift as Self::Int)
     }
 }
 impl Float for f64 {
@@ -53,14 +52,14 @@ impl Float for f64 {
         52
     }
     fn repr(self) -> Self::Int {
-        unsafe { transmute(self) }
+        unsafe { mem::transmute(self) }
     }
     fn from_repr(a: Self::Int) -> Self {
-        unsafe { transmute(a) }
+        unsafe { mem::transmute(a) }
     }
     fn normalize(significand: Self::Int) -> (Self::Int, Self::Int) {
         let shift = Self::Int::leading_zeros(significand) 
-            - Self::Int::leading_zeros(1 << Self::significand_bits());
-        (1 - shift as Self::Int, significand << shift as Self::Int)
+            .wrapping_sub(Self::Int::leading_zeros(1 << Self::significand_bits()));
+        (1u64.wrapping_sub(shift as Self::Int), significand << shift as Self::Int)
     }
 }