Use traits instead of macros for shift intrinsics

This is an attempt to tidy up the definition of intrinsics by making them more
rust-like at the definition site and using traits instead of macros for the
definition. Additionally the helper macro, `intrinsics!`, now fills in a
definition for #[cfg]'d off intrinsics when compiling with C code

src/int/mod.rs

@@ -1,3 +1,5 @@
+use core::ops;
+
 macro_rules! hty {
     ($ty:ty) => {
         <$ty as LargeInt>::HighHalf
@@ -16,15 +18,25 @@ pub mod shift;
 pub mod udiv;
 
 /// Trait for some basic operations on integers
-pub trait Int {
+pub trait Int:
+    Copy +
+    PartialEq  +
+    ops::Shl<u32, Output = Self> +
+    ops::Shr<u32, Output = Self> +
+    ops::BitOr<Output = Self> +
+    // ops::BitAnd<Output = Self> +
+{
     /// Type with the same width but other signedness
-    type OtherSign;
+    type OtherSign: Int;
     /// Unsigned version of Self
-    type UnsignedInt;
+    type UnsignedInt: Int;
 
     /// Returns the bitwidth of the int type
     fn bits() -> u32;
 
+    /// Returns the zero representation of this number
+    fn zero() -> Self;
+
     /// Extracts the sign from self and returns a tuple.
     ///
     /// # Examples
@@ -36,6 +48,9 @@ pub trait Int {
     /// assert_eq!(u, 25_u32);
     /// ```
     fn extract_sign(self) -> (bool, Self::UnsignedInt);
+
+    /// Convert to a signed representation
+    fn unsigned(self) -> Self::UnsignedInt;
 }
 
 macro_rules! int_impl {
@@ -44,6 +59,10 @@ macro_rules! int_impl {
             type OtherSign = $ity;
             type UnsignedInt = $uty;
 
+            fn zero() -> Self {
+                0
+            }
+
             fn bits() -> u32 {
                 $bits
             }
@@ -51,6 +70,10 @@ macro_rules! int_impl {
             fn extract_sign(self) -> (bool, $uty) {
                 (false, self)
             }
+
+            fn unsigned(self) -> $uty {
+                self
+            }
         }
 
         impl Int for $ity {
@@ -61,6 +84,10 @@ macro_rules! int_impl {
                 $bits
             }
 
+            fn zero() -> Self {
+                0
+            }
+
             fn extract_sign(self) -> (bool, $uty) {
                 if self < 0 {
                     (true, (!(self as $uty)).wrapping_add(1))
@@ -68,6 +95,10 @@ macro_rules! int_impl {
                     (false, self as $uty)
                 }
             }
+
+            fn unsigned(self) -> $uty {
+                self as $uty
+            }
         }
     }
 }
@@ -77,9 +108,9 @@ int_impl!(i64, u64, 64);
 int_impl!(i128, u128, 128);
 
 /// Trait to convert an integer to/from smaller parts
-pub trait LargeInt {
+pub trait LargeInt: Int {
-    type LowHalf;
+    type LowHalf: Int;
-    type HighHalf;
+    type HighHalf: Int;
 
     fn low(self) -> Self::LowHalf;
     fn high(self) -> Self::HighHalf;

src/int/shift.rs

@@ -1,74 +1,94 @@
 use int::{Int, LargeInt};
 
-macro_rules! ashl {
+trait Ashl: Int + LargeInt {
-    ($intrinsic:ident: $ty:ty) => {
+    /// Returns `a << b`, requires `b < $ty::bits()`
-        /// Returns `a << b`, requires `b < $ty::bits()`
+    fn ashl(self, offset: u32) -> Self
-        #[cfg_attr(not(test), no_mangle)]
+        where Self: LargeInt<HighHalf = <Self as LargeInt>::LowHalf>,
-        #[cfg_attr(all(not(test), not(target_arch = "arm")), no_mangle)]
+    {
-        #[cfg_attr(all(not(test), target_arch = "arm"), inline(always))]
+        let half_bits = Self::bits() / 2;
-        pub extern "C" fn $intrinsic(a: $ty, b: u32) -> $ty {
+        if offset & half_bits != 0 {
-            let half_bits = <$ty>::bits() / 2;
+            Self::from_parts(Int::zero(), self.low() << (offset - half_bits))
-            if b & half_bits != 0 {
+        } else if offset == 0 {
-                <$ty>::from_parts(0, a.low() << (b - half_bits))
+            self
-            } else if b == 0 {
+        } else {
-                a
+            Self::from_parts(self.low() << offset,
-            } else {
+                             (self.high() << offset) |
-                <$ty>::from_parts(a.low() << b, (a.high() << b) | (a.low() >> (half_bits - b)))
+                                (self.low() >> (half_bits - offset)))
-            }
         }
     }
 }
 
-macro_rules! ashr {
+impl Ashl for u64 {}
-    ($intrinsic:ident: $ty:ty) => {
+impl Ashl for u128 {}
-        /// Returns arithmetic `a >> b`, requires `b < $ty::bits()`
+
-        #[cfg_attr(not(test), no_mangle)]
+trait Ashr: Int + LargeInt {
-        #[cfg_attr(all(not(test), not(target_arch = "arm")), no_mangle)]
+    /// Returns arithmetic `a >> b`, requires `b < $ty::bits()`
-        #[cfg_attr(all(not(test), target_arch = "arm"), inline(always))]
+    fn ashr(self, offset: u32) -> Self
-        pub extern "C" fn $intrinsic(a: $ty, b: u32) -> $ty {
+        where Self: LargeInt<LowHalf = <<Self as LargeInt>::HighHalf as Int>::UnsignedInt>,
-            let half_bits = <$ty>::bits() / 2;
+    {
-            if b & half_bits != 0 {
+        let half_bits = Self::bits() / 2;
-                <$ty>::from_parts((a.high() >> (b - half_bits)) as <$ty as LargeInt>::LowHalf,
+        if offset & half_bits != 0 {
-                                  a.high() >> (half_bits - 1))
+            Self::from_parts((self.high() >> (offset - half_bits)).unsigned(),
-            } else if b == 0 {
+                              self.high() >> (half_bits - 1))
-                a
+        } else if offset == 0 {
-            } else {
+            self
-                let high_unsigned = a.high() as <$ty as LargeInt>::LowHalf;
+        } else {
-                <$ty>::from_parts((high_unsigned << (half_bits - b)) | (a.low() >> b),
+            let high_unsigned = self.high().unsigned();
-                                  a.high() >> b)
+            Self::from_parts((high_unsigned << (half_bits - offset)) | (self.low() >> offset),
-            }
+                              self.high() >> offset)
         }
     }
 }
 
-macro_rules! lshr {
+impl Ashr for i64 {}
-    ($intrinsic:ident: $ty:ty) => {
+impl Ashr for i128 {}
-        /// Returns logical `a >> b`, requires `b < $ty::bits()`
+
-        #[cfg_attr(not(test), no_mangle)]
+trait Lshr: Int + LargeInt {
-        pub extern "C" fn $intrinsic(a: $ty, b: u32) -> $ty {
+    /// Returns logical `a >> b`, requires `b < $ty::bits()`
-            let half_bits = <$ty>::bits() / 2;
+    fn lshr(self, offset: u32) -> Self
-            if b & half_bits != 0 {
+        where Self: LargeInt<HighHalf = <Self as LargeInt>::LowHalf>,
-                <$ty>::from_parts(a.high() >> (b - half_bits), 0)
+    {
-            } else if b == 0 {
+        let half_bits = Self::bits() / 2;
-                a
+        if offset & half_bits != 0 {
-            } else {
+            Self::from_parts(self.high() >> (offset - half_bits), Int::zero())
-                <$ty>::from_parts((a.high() << (half_bits - b)) | (a.low() >> b), a.high() >> b)
+        } else if offset == 0 {
-            }
+            self
+        } else {
+            Self::from_parts((self.high() << (half_bits - offset)) |
+                                (self.low() >> offset),
+                             self.high() >> offset)
         }
     }
 }
 
-#[cfg(not(all(feature = "c", target_arch = "x86")))]
+impl Lshr for u64 {}
-ashl!(__ashldi3: u64);
+impl Lshr for u128 {}
 
-ashl!(__ashlti3: u128);
+intrinsics! {
+    #[cfg(not(all(feature = "c", target_arch = "x86")))]
+    pub extern "C" fn __ashldi3(a: u64, b: u32) -> u64 {
+        a.ashl(b)
+    }
 
-#[cfg(not(all(feature = "c", target_arch = "x86")))]
+    pub extern "C" fn __ashlti3(a: u128, b: u32) -> u128 {
-ashr!(__ashrdi3: i64);
+        a.ashl(b)
+    }
 
-ashr!(__ashrti3: i128);
+    #[cfg(not(all(feature = "c", target_arch = "x86")))]
+    pub extern "C" fn __ashrdi3(a: i64, b: u32) -> i64 {
+        a.ashr(b)
+    }
 
-#[cfg(not(all(feature = "c", target_arch = "x86")))]
+    pub extern "C" fn __ashrti3(a: i128, b: u32) -> i128 {
-lshr!(__lshrdi3: u64);
+        a.ashr(b)
+    }
 
-lshr!(__lshrti3: u128);
+    #[cfg(not(all(feature = "c", target_arch = "x86")))]
+    pub extern "C" fn __lshrdi3(a: u64, b: u32) -> u64 {
+        a.lshr(b)
+    }
+
+    pub extern "C" fn __lshrti3(a: u128, b: u32) -> u128 {
+        a.lshr(b)
+    }
+}

src/lib.rs

@@ -99,6 +99,9 @@ fn sconv(i: i128) -> U64x2 {
 #[cfg(test)]
 extern crate core;
 
+#[macro_use]
+mod macros;
+
 pub mod int;
 pub mod float;
 

src/macros.rs

@@ -0,0 +1,51 @@
+macro_rules! intrinsics {
+    () => ();
+    (
+        #[cfg(not(all(feature = "c", $($cfg_clause:tt)*)))]
+        $(#[$attr:meta])*
+        pub extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) -> $ret:ty {
+            $($body:tt)*
+        }
+
+        $($rest:tt)*
+    ) => (
+
+        #[cfg(all(feature = "c", not($($cfg_clause)*)))]
+        $(#[$attr])*
+        pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {
+            extern $abi {
+                fn $name($($argname: $ty),*) -> $ret;
+            }
+            unsafe {
+                $name($($argname),*)
+            }
+        }
+
+        #[cfg(not(all(feature = "c", not($($cfg_clause)*))))]
+        intrinsics! {
+            $(#[$attr])*
+            pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {
+                $($body)*
+            }
+        }
+
+        intrinsics!($($rest)*);
+    );
+
+    (
+        $(#[$attr:meta])*
+        pub extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) -> $ret:ty {
+            $($body:tt)*
+        }
+
+        $($rest:tt)*
+    ) => (
+        $(#[$attr])*
+        #[cfg_attr(not(test), no_mangle)]
+        pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {
+            $($body)*
+        }
+
+        intrinsics!($($rest)*);
+    );
+}