Merge pull request #21 from antoyo/fix-oper-128bits

Fix oper 128bits

Author: antoyo

gcc-test-backend/src/main.rs

@@ -1,7 +1,5 @@
 #![feature(const_option)]
 
-use std::num::{NonZeroU8, NonZeroI8, NonZeroU16, NonZeroI16, NonZeroU32, NonZeroI32, NonZeroU64, NonZeroI64, NonZeroU128, NonZeroI128, NonZeroUsize, NonZeroIsize};
-
 fn main() {
     /*test_float!(f64, f64, f64::INFINITY, f64::NEG_INFINITY, f64::NAN);
     ($modname: ident, $fty: ty, $inf: expr, $neginf: expr, $nan: expr) => {*/
@@ -156,67 +154,86 @@ fn main() {
     println!();
 */
 
-    assert_eq!(NonZeroU8::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroI8::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroU16::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroI16::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroU32::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroI32::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroU64::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroI64::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroU128::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroI128::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroUsize::new(1).unwrap().trailing_zeros(), 0);
-    assert_eq!(NonZeroIsize::new(1).unwrap().trailing_zeros(), 0);
-
-    assert_eq!(NonZeroU8::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroI8::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroU16::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroI16::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroU32::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroI32::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroU64::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroI64::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroU128::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroI128::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroUsize::new(1 << 2).unwrap().trailing_zeros(), 2);
-    assert_eq!(NonZeroIsize::new(1 << 2).unwrap().trailing_zeros(), 2);
-
-    assert_eq!(NonZeroU8::new(1 << 7).unwrap().trailing_zeros(), 7);
-    assert_eq!(NonZeroI8::new(1 << 7).unwrap().trailing_zeros(), 7);
-    assert_eq!(NonZeroU16::new(1 << 15).unwrap().trailing_zeros(), 15);
-    assert_eq!(NonZeroI16::new(1 << 15).unwrap().trailing_zeros(), 15);
-    assert_eq!(NonZeroU32::new(1 << 31).unwrap().trailing_zeros(), 31);
-    assert_eq!(NonZeroI32::new(1 << 31).unwrap().trailing_zeros(), 31);
-    assert_eq!(NonZeroU64::new(1 << 63).unwrap().trailing_zeros(), 63);
-    assert_eq!(NonZeroI64::new(1 << 63).unwrap().trailing_zeros(), 63);
-    assert_eq!(NonZeroU128::new(1 << 127).unwrap().trailing_zeros(), 127);
-    assert_eq!(NonZeroI128::new(1 << 127).unwrap().trailing_zeros(), 127);
+    /*let mut r = 2 as i128;
+    assert_eq!(r.pow(2), 4 as i128);
+    assert_eq!(r.pow(0), 1 as i128);
+    assert_eq!(r.wrapping_pow(2), 4 as i128);
+    assert_eq!(r.wrapping_pow(0), 1 as i128);
+    assert_eq!(r.checked_pow(2), Some(4 as i128));
+    assert_eq!(r.checked_pow(0), Some(1 as i128));
+    assert_eq!(r.overflowing_pow(2), (4 as i128, false));
+    assert_eq!(r.overflowing_pow(0), (1 as i128, false));
+    assert_eq!(r.saturating_pow(2), 4 as i128);
+    assert_eq!(r.saturating_pow(0), 1 as i128);
+
+    r = i128::MAX;
+    // use `^` to represent .pow() with no overflow.
+    // if itest::MAX == 2^j-1, then itest is a `j` bit int,
+    // so that `itest::MAX*itest::MAX == 2^(2*j)-2^(j+1)+1`,
+    // thussaturating_pow the overflowing result is exactly 1.
+    assert_eq!(r.wrapping_pow(2), 1 as i128);
+    assert_eq!(r.checked_pow(2), None);
+    assert_eq!(r.overflowing_pow(2), (1 as i128, true));
+    assert_eq!(r.saturating_pow(2), i128::MAX);
+    //test for negative exponent.
+    r = -2 as i128;
+    assert_eq!(r.pow(2), 4 as i128);
+    assert_eq!(r.pow(3), -8 as i128);
+    assert_eq!(r.pow(0), 1 as i128);
+    assert_eq!(r.wrapping_pow(2), 4 as i128);
+    assert_eq!(r.wrapping_pow(3), -8 as i128);
+    assert_eq!(r.wrapping_pow(0), 1 as i128);
+    assert_eq!(r.checked_pow(2), Some(4 as i128));
+    assert_eq!(r.checked_pow(3), Some(-8 as i128));
+    assert_eq!(r.checked_pow(0), Some(1 as i128));
+    assert_eq!(r.overflowing_pow(2), (4 as i128, false));
+    assert_eq!(r.overflowing_pow(3), (-8 as i128, false));
+    assert_eq!(r.overflowing_pow(0), (1 as i128, false));
+    assert_eq!(r.saturating_pow(2), 4 as i128);
+    assert_eq!(r.saturating_pow(3), -8 as i128);
+    assert_eq!(r.saturating_pow(0), 1 as i128);*/
+
+    {
+        const A: u128 = 0b0101100;
+        const B: u128 = 0b0100001;
+        const C: u128 = 0b1111001;
+
+        const _0: u128 = 0;
+        const _1: u128 = !0;
+
+        assert_eq!(A.reverse_bits().reverse_bits(), A);
+        assert_eq!(B.reverse_bits().reverse_bits(), B);
+        assert_eq!(C.reverse_bits().reverse_bits(), C);
+
+        // Swapping these should make no difference
+        assert_eq!(_0.reverse_bits(), _0);
+        assert_eq!(_1.reverse_bits(), _1);
+    }
 
-    assert_eq!(
-        NonZeroUsize::new(1 << (usize::BITS - 1)).unwrap().trailing_zeros(),
-        usize::BITS - 1
-    );
-    assert_eq!(
-        NonZeroIsize::new(1 << (usize::BITS - 1)).unwrap().trailing_zeros(),
-        usize::BITS - 1
-    );
+    const _0: i128 = 0;
+    const _1: i128 = !0;
+
+    use std::i128::MAX;
+
+    let a: i128 = 0b0101_1111;
+    assert_eq!(a.trailing_ones(), 5);
+    assert_eq!((!a).leading_ones(), i128::BITS - 7);
+
+    assert_eq!(a.reverse_bits().leading_ones(), 5);
+
+    assert_eq!(_1.leading_ones(), i128::BITS);
+    assert_eq!(_1.trailing_ones(), i128::BITS);
 
-    const TRAILING_ZEROS: u32 = NonZeroU16::new(1 << 2).unwrap().trailing_zeros();
-    assert_eq!(TRAILING_ZEROS, 2);
+    assert_eq!((_1 << 1).trailing_ones(), 0);
+    assert_eq!(MAX.leading_ones(), 0);
 
-    const A: u128 = 0b0101100;
-    const B: u128 = 0b0100001;
-    const C: u128 = 0b1111001;
+    assert_eq!((_1 << 1).leading_ones(), i128::BITS - 1);
+    assert_eq!(MAX.trailing_ones(), i128::BITS - 1);
 
-    const _0: u128 = 0;
-    const _1: u128 = !0;
+    assert_eq!(_0.leading_ones(), 0);
+    assert_eq!(_0.trailing_ones(), 0);
 
-    assert_eq!(u128::from_be(A.to_be()), A);
-    assert_eq!(u128::from_be(B.to_be()), B);
-    assert_eq!(u128::from_be(C.to_be()), C);
-    assert_eq!(u128::from_be(_0), _0);
-    assert_eq!(u128::from_be(_1), _1);
-    assert_eq!(_0.to_be(), _0);
-    assert_eq!(_1.to_be(), _1);
+    let x: i128 = 0b0010_1100;
+    assert_eq!(x.leading_ones(), 0);
+    assert_eq!(x.trailing_ones(), 0);
 }

src/intrinsic.rs

@@ -677,14 +677,14 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
             64 => {
                 // First step.
                 let left = self.shl(value, context.new_rvalue_from_long(typ, 32));
-                let right = self.lshr(left, context.new_rvalue_from_long(typ, 32));
+                let right = self.lshr(value, context.new_rvalue_from_long(typ, 32));
                 let step1 = self.or(left, right);
 
                 // Second step.
                 let left = self.and(step1, context.new_rvalue_from_long(typ, 0x0001FFFF0001FFFF));
                 let left = self.shl(left, context.new_rvalue_from_long(typ, 15));
                 let right = self.and(step1, context.new_rvalue_from_long(typ, 0xFFFE0000FFFE0000u64 as i64)); // TODO: transmute the number instead?
-                let right = self.shl(right, context.new_rvalue_from_long(typ, 17));
+                let right = self.lshr(right, context.new_rvalue_from_long(typ, 17));
                 let step2 = self.or(left, right);
 
                 // Third step.
@@ -717,8 +717,18 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
                 step5
             },
             128 => {
-                // TODO
-                value
+                // TODO: find a more efficient implementation?
+                let sixty_four = self.context.new_rvalue_from_long(typ, 64);
+                let high = self.context.new_cast(None, value >> sixty_four, self.u64_type);
+                let low = self.context.new_cast(None, value, self.u64_type);
+
+                let reversed_high = self.bit_reverse(64, high);
+                let reversed_low = self.bit_reverse(64, low);
+
+                let new_low = self.context.new_cast(None, reversed_high, typ);
+                let new_high = self.context.new_cast(None, reversed_low, typ) << sixty_four;
+
+                new_low | new_high
             },
             _ => {
                 panic!("cannot bit reverse with width = {}", width);
@@ -1006,14 +1016,6 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
             let then_block = func.new_block("then");
             let after_block = func.new_block("after");
 
-            let width =
-                // TODO: support 128-bit integers.
-                if width == 128 {
-                    64
-                }
-                else {
-                    width
-                };
             let unsigned_type = self.context.new_int_type(width as i32 / 8, false);
             let shifted = self.context.new_cast(None, lhs, unsigned_type) >> self.context.new_rvalue_from_int(unsigned_type, width as i32 - 1);
             let uint_max = self.context.new_unary_op(None, UnaryOp::BitwiseNegate, unsigned_type,