Fix widen mul

Author: tgross35

src/int/big.rs

@@ -8,13 +8,17 @@ use core::ops;
 const WORD_LO_MASK: u64 = 0x00000000ffffffff;
 const WORD_HI_MASK: u64 = 0xffffffff00000000;
 const WORD_FULL_MASK: u64 = 0xffffffffffffffff;
+const U128_LO_MASK: u128 = u64::MAX as u128;
+const U128_HI_MASK: u128 = (u64::MAX as u128) << 64;
 
 // Stored little endian
 #[allow(non_camel_case_types)]
 #[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
 pub struct u256(pub [u64; 4]);
 
 impl u256 {
+    pub const MAX: Self = Self([u64::MAX, u64::MAX, u64::MAX, u64::MAX]);
+
     /// Reinterpret as a signed integer
     pub fn signed(self) -> i256 {
         i256(self.0)
@@ -256,7 +260,7 @@ impl HInt for u128 {
         let r1: u128 = (sum0 >> 64)
             + ((sum1 >> 32) & u128::from(WORD_FULL_MASK))
             + (sum2 & u128::from(WORD_FULL_MASK))
-            + ((sum3 << 32) & u128::from(WORD_FULL_MASK));
+            + ((sum3 << 32) & u128::from(WORD_HI_MASK));
 
         let lo = r0 + (r1 << 64);
         let hi = (r1 >> 64)
@@ -267,7 +271,12 @@ impl HInt for u128 {
             + (sum5 << 32)
             + (sum6 << 64);
 
-        u256([word!(1, lo), word!(2, lo), word!(1, hi), word!(2, hi)])
+        u256([
+            (lo & U128_LO_MASK) as u64,
+            ((lo >> 64) & U128_LO_MASK) as u64,
+            (hi & U128_LO_MASK) as u64,
+            ((hi >> 64) & U128_LO_MASK) as u64,
+        ])
     }
 
     fn widen_mul(self, rhs: Self) -> Self::D {
@@ -302,8 +311,8 @@ impl HInt for i128 {
                 let zeroes = word.leading_zeros();
                 let leading = u64::MAX << (64 - zeroes);
                 *word |= leading;
-                if zeroes != 64 { 
-                    break
+                if zeroes != 64 {
+                    break;
                 }
             }
         }

testcrate/tests/big.rs

@@ -1,23 +1,49 @@
 use compiler_builtins::int::{i256, u256, HInt};
 
+const LOHI_SPLIT: u128 = 0xaaaaaaaaaaaaaaaaffffffffffffffff;
+
 #[test]
 fn widen_u128() {
     assert_eq!(u128::MAX.widen(), u256([u64::MAX, u64::MAX, 0, 0]));
     assert_eq!(
-        0xaaaaaaaaaaaaaaaaffffffffffffffff_u128.widen(),
+        LOHI_SPLIT.widen(),
         u256([u64::MAX, 0xaaaaaaaaaaaaaaaa, 0, 0])
     );
 }
 
 #[test]
 fn widen_i128() {
+    assert_eq!((-1i128).widen(), u256::MAX.signed());
     assert_eq!(
-        (-1i128).widen(),
-        i256([u64::MAX, u64::MAX, u64::MAX, u64::MAX])
-    );
-    assert_eq!(
-        (0xaaaaaaaaaaaaaaaaffffffffffffffff_u128 as i128).widen(),
+        (LOHI_SPLIT as i128).widen(),
         i256([u64::MAX, 0xaaaaaaaaaaaaaaaa, u64::MAX, u64::MAX])
     );
     assert_eq!((-1i128).zero_widen().unsigned(), (u128::MAX).widen());
 }
+
+const WORD_LO_MASK: u64 = 0x00000000ffffffff;
+const WORD_HI_MASK: u64 = 0xffffffff00000000;
+const WORD_FULL_MASK: u64 = 0xffffffffffffffff;
+macro_rules! word {
+    (1, $val:expr) => {
+        (($val >> (32 * 3)) & u128::from(WORD_LO_MASK)) as u64
+    };
+    (2, $val:expr) => {
+        (($val >> (32 * 2)) & u128::from(WORD_LO_MASK)) as u64
+    };
+    (3, $val:expr) => {
+        (($val >> (32 * 1)) & u128::from(WORD_LO_MASK)) as u64
+    };
+    (4, $val:expr) => {
+        (($val >> (32 * 0)) & u128::from(WORD_LO_MASK)) as u64
+    };
+}
+
+#[test]
+fn widen_mul_u128() {
+    let a = u128::MAX;
+    let b = 2_u128;
+    let res = a.zero_widen_mul(b);
+
+    assert_eq!(res, u256([u64::MAX - 1, u64::MAX, 1, 0]));
+}