impl Shl for i256, and add trailing_zeros in trait Int

Author: quaternic

libm/src/math/support/big.rs

@@ -148,42 +148,39 @@ macro_rules! impl_common {
                 Self { lo, hi }
             }
         }
-    };
-}
 
-impl_common!(i256);
-impl_common!(u256);
+        impl ops::Shr<u32> for $ty {
+            type Output = Self;
 
-impl ops::Shr<u32> for u256 {
-    type Output = Self;
+            fn shr(mut self, rhs: u32) -> Self::Output {
+                debug_assert!(rhs < Self::BITS, "attempt to shift right with overflow");
 
-    fn shr(mut self, rhs: u32) -> Self::Output {
-        debug_assert!(rhs < Self::BITS, "attempted to shift right with overflow");
-        if rhs >= Self::BITS {
-            return Self::ZERO;
-        }
+                let half_bits = Self::BITS / 2;
+                let low_mask = half_bits - 1;
+                let s = rhs & low_mask;
 
-        if rhs == 0 {
-            return self;
-        }
+                let lo = self.lo;
+                let hi = self.hi;
 
-        if rhs < 128 {
-            self.lo >>= rhs;
-            self.lo |= self.hi << (128 - rhs);
-        } else {
-            self.lo = self.hi >> (rhs - 128);
-        }
+                self.hi = hi >> s;
 
-        if rhs < 128 {
-            self.hi >>= rhs;
-        } else {
-            self.hi = 0;
+                #[allow(unused_comparisons)]
+                if rhs & half_bits == 0 {
+                    self.lo = (hi << (low_mask ^ s) << 1) as _;
+                    self.lo |= lo >> s;
+                } else {
+                    self.lo = self.hi as _;
+                    self.hi = if hi < 0 { !0 } else { 0 };
+                }
+                self
+            }
         }
-
-        self
-    }
+    };
 }
 
+impl_common!(i256);
+impl_common!(u256);
+
 impl HInt for u128 {
     type D = u256;
 

libm/src/math/support/int_traits.rs

@@ -9,6 +9,7 @@ pub trait MinInt:
     + ops::BitOr<Output = Self>
     + ops::Not<Output = Self>
     + ops::Shl<u32, Output = Self>
+    + ops::Shr<u32, Output = Self>
     + ops::Add<Output = Self>
     + ops::Sub<Output = Self>
 {
@@ -103,6 +104,7 @@ pub trait Int:
     fn carrying_add(self, other: Self, carry: bool) -> (Self, bool);
     fn borrowing_sub(self, other: Self, borrow: bool) -> (Self, bool);
     fn leading_zeros(self) -> u32;
+    fn trailing_zeros(self) -> u32;
     fn ilog2(self) -> u32;
 }
 
@@ -168,6 +170,10 @@ macro_rules! int_impl_common {
             <Self>::leading_zeros(self)
         }
 
+        fn trailing_zeros(self) -> u32 {
+            <Self>::trailing_zeros(self)
+        }
+
         fn ilog2(self) -> u32 {
             // On our older MSRV, this resolves to the trait method. Which won't actually work,
             // but this is only called behind other gates.