Implement __bswap[si]i2 intrinsics

These can be emitted by gcc, at least if requested specifically via __builtin_bswap{32,64}.

Author: tea

build.rs

@@ -161,6 +161,8 @@ fn configure_check_cfg() {
         "__ashlsi3",
         "__ashrdi3",
         "__ashrsi3",
+        "__bswapsi2",
+        "__bswapdi2",
         "__clzsi2",
         "__divdi3",
         "__divsi3",

src/int/bswap.rs

@@ -0,0 +1,30 @@
+intrinsics! {
+    #[maybe_use_optimized_c_shim]
+    #[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
+    /// Swaps bytes in 32-bit number
+    pub extern "C" fn __bswapsi2(x: u32) -> u32 {
+        (x & 0xff000000u32) >> 24 |
+        (x & 0x00ff0000u32) >> 8  |
+        (x & 0x0000ff00u32) << 8  |
+        (x & 0x000000ffu32) << 24
+    }
+
+    #[maybe_use_optimized_c_shim]
+    #[cfg(target_pointer_width = "32")]
+    /// Swaps bytes in 64-bit number
+    pub extern "C" fn __bswapdi2(x: u64) -> u64 {
+        __bswapsi2((x >> 32) as u32) as u64 |
+        (__bswapsi2(x as u32) as u64) << 32
+    }
+
+    #[maybe_use_optimized_c_shim]
+    #[cfg(target_pointer_width = "64")]
+    /// Swaps bytes in 64-bit number
+    pub extern "C" fn __bswapdi2(x: u64) -> u64 {
+        let x = (x & 0xff000000ff000000u64) >> 24 |
+                (x & 0x00ff000000ff0000u64) >> 8 |
+                (x & 0x0000ff000000ff00u64) << 8 |
+                (x & 0x000000ff000000ffu64) << 24;
+        x << 32 | x >> 32
+    }
+}

src/int/mod.rs

@@ -4,6 +4,7 @@ mod specialized_div_rem;
 
 pub mod addsub;
 mod big;
+pub mod bswap;
 pub mod leading_zeros;
 pub mod mul;
 pub mod sdiv;

testcrate/tests/misc.rs

@@ -92,6 +92,47 @@ fn leading_zeros() {
     })
 }
 
+#[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
+#[test]
+fn bswap() {
+    use compiler_builtins::int::bswap::{__bswapdi2, __bswapsi2};
+    fuzz(N, |x: u32| {
+        let x_std = x.swap_bytes();
+        let x_intr = __bswapsi2(x);
+        if x_std != x_intr {
+            panic!("__bswapsi2({}): std: {}, builtins: {}", x, x_std, x_intr);
+        }
+    });
+    fuzz(N, |x: u64| {
+        let x_std = x.swap_bytes();
+        let x_intr = __bswapdi2(x);
+        if x_std != x_intr {
+            panic!("__bswapdi2({}): std: {}, builtins: {}", x, x_std, x_intr);
+        }
+    });
+
+    let mut x1 = 0x12345678u32;
+    let mut sw1 = __bswapsi2(x1);
+    if sw1 != 0x78563412u32 {
+        panic!("__bswapsi2({}): {}", x1, sw1);
+    }
+    x1 = 0x00000001u32;
+    sw1 = __bswapsi2(x1);
+    if sw1 != 0x01000000u32 {
+        panic!("__bswapsi2({}): {}", x1, sw1);
+    }
+    let mut x2 = 0x123456789ABCDEF0u64;
+    let mut sw2 = __bswapdi2(x2);
+    if sw2 != 0xF0DEBC9A78563412u64 {
+        panic!("__bswapdi2({}): {}", x2, sw2);
+    }
+    x2 = 0x0000000100000002u64;
+    sw2 = __bswapdi2(x2);
+    if sw2 != 0x0200000001000000u64 {
+        panic!("__bswapdi2({}): {}", x2, sw2);
+    }
+}
+
 // This is approximate because of issues related to
 // https://github.com/rust-lang/rust/issues/73920.
 // TODO how do we resolve this indeterminacy?