Implement bit-reverse for 128-bit integers

Author: antoyo

gcc-test-backend/src/main.rs

@@ -193,22 +193,24 @@ fn main() {
     assert_eq!(r.saturating_pow(3), -8 as i128);
     assert_eq!(r.saturating_pow(0), 1 as i128);*/
 
-    const A: u64 = 0b0101100;
-    const B: u64 = 0b0100001;
-    const C: u64 = 0b1111001;
+    {
+        const A: u128 = 0b0101100;
+        const B: u128 = 0b0100001;
+        const C: u128 = 0b1111001;
 
-    const _0: u64 = 0;
-    const _1: u64 = !0;
+        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);
+        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);
+        // Swapping these should make no difference
+        assert_eq!(_0.reverse_bits(), _0);
+        assert_eq!(_1.reverse_bits(), _1);
+    }
 
-    /*const _0: i128 = 0;
+    const _0: i128 = 0;
     const _1: i128 = !0;
 
     use std::i128::MAX;
@@ -233,5 +235,5 @@ fn main() {
 
     let x: i128 = 0b0010_1100;
     assert_eq!(x.leading_ones(), 0);
-    assert_eq!(x.trailing_ones(), 0);*/
+    assert_eq!(x.trailing_ones(), 0);
 }

src/intrinsic.rs

@@ -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);