Fix cast from u64 to i128

Author: antoyo

gcc-test-backend/src/main.rs

@@ -214,4 +214,46 @@ fn main() {
     assert_eq!(r.saturating_pow(2), 4 as i128);
     assert_eq!(r.saturating_pow(3), -8 as i128);
     assert_eq!(r.saturating_pow(0), 1 as i128);*/
+
+    fn max64() -> i128 {
+        18446744073709551615_u64 as i128
+
+        /*println!("{}", u64::MAX);
+        u64::MAX as i128*/
+    }
+
+    println!("1. {}", max64());
+
+    /*use std::convert::TryFrom;
+
+    fn try_from(u: i128) -> Option<u64> {
+        let min = u64::MIN as i128;
+        let max = u64::MAX as i128;
+        /*println!("{} < {} == {}", u, min, u < min);
+        println!("{} > {} == {}", u, max, u > max);*/
+        if u < min || u > max {
+            None
+        } else {
+            Some(u as u64)
+        }
+    }
+
+    let max = <i128>::MAX;
+    let min = <i128>::MIN;
+    let zero: i128 = 0;
+    let t_max = <u64>::MAX;
+    let t_min = <u64>::MIN;
+    assert!(<u64 as TryFrom<i128>>::try_from(max).is_err());
+    assert!(<u64 as TryFrom<i128>>::try_from(min).is_err());
+    println!("{:?}", try_from(zero));
+    println!("{:?}", <u64 as TryFrom<i128>>::try_from(zero));
+    assert_eq!(<u64 as TryFrom<i128>>::try_from(zero).unwrap(), zero as u64);
+    assert_eq!(
+        <u64 as TryFrom<i128>>::try_from(t_max as i128).unwrap(),
+        t_max as u64
+    );
+    assert_eq!(
+        <u64 as TryFrom<i128>>::try_from(t_min as i128).unwrap(),
+        t_min as u64
+    );*/
 }

src/common.rs

@@ -128,20 +128,28 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
     }
 
     fn const_uint_big(&self, typ: Type<'gcc>, num: u128) -> RValue<'gcc> {
-        let num64: Result<u64, _> = num.try_into();
+        println!("Num: {:?}", num);
+        let num64: Result<i64, _> = num.try_into();
         if let Ok(num) = num64 {
+            println!("1");
             // FIXME: workaround for a bug where libgccjit is expecting a constant.
             // The operations >> 64 and | low are making the normal case a non-constant.
             return self.context.new_rvalue_from_long(typ, num as i64);
         }
 
-        // FIXME: use a new function new_rvalue_from_unsigned_long()?
-        let low = self.context.new_rvalue_from_long(self.u64_type, num as u64 as i64);
-        let high = self.context.new_rvalue_from_long(typ, (num >> 64) as u64 as i64);
+        if num >> 64 != 0 {
+            println!("2");
+            // FIXME: use a new function new_rvalue_from_unsigned_long()?
+            let low = self.context.new_rvalue_from_long(self.u64_type, num as u64 as i64);
+            let high = self.context.new_rvalue_from_long(typ, (num >> 64) as u64 as i64);
 
-        let sixty_four = self.context.new_rvalue_from_long(typ, 64);
-
-        (high << sixty_four) | self.context.new_cast(None, low, typ)
+            let sixty_four = self.context.new_rvalue_from_long(typ, 64);
+            (high << sixty_four) | self.context.new_cast(None, low, typ)
+        }
+        else {
+            println!("3");
+            self.context.new_rvalue_from_long(typ, num as u64 as i64)
+        }
 
         /*unsafe {
             let words = [u as u64, (u >> 64) as u64];