Merge pull request #627 from bjorn3/wip_i128

Support 128bit numbers

Author: bjorn3

Cargo.lock

@@ -27,6 +27,12 @@ gimli = { git = "https://github.com/gimli-rs/gimli.git" }
 indexmap = "1.0.2"
 object = "0.12.0"
 
+[patch."https://github.com/CraneStation/cranelift.git"]
+cranelift = { git = "https://github.com/bjorn3/cretonne.git", branch = "do_not_remove_cg_clif_i128" }
+cranelift-module = { git = "https://github.com/bjorn3/cretonne.git", branch = "do_not_remove_cg_clif_i128" }
+cranelift-simplejit = { git = "https://github.com/bjorn3/cretonne.git", branch = "do_not_remove_cg_clif_i128" }
+cranelift-faerie = { git = "https://github.com/bjorn3/cretonne.git", branch = "do_not_remove_cg_clif_i128" }
+
 # Uncomment to use local checkout of cranelift
 #[patch."https://github.com/CraneStation/cranelift.git"]
 #cranelift = { path = "../cranelift/cranelift-umbrella" }

Cargo.toml

@@ -29,10 +29,9 @@ $ RUSTFLAGS="-Cpanic=abort -Zcodegen-backend=$cg_clif_dir/target/debug/librustc_
 
 ## Not yet supported
 
-* Good non-rust abi support ([scalar pair and vector are passed by-ref](https://github.com/bjorn3/rustc_codegen_cranelift/issues/10))
+* Good non-rust abi support ([vectors are passed by-ref](https://github.com/bjorn3/rustc_codegen_cranelift/issues/10))
 * Checked binops ([some missing instructions in cranelift](https://github.com/CraneStation/cranelift/issues/460))
 * Inline assembly ([no cranelift support](https://github.com/CraneStation/cranelift/issues/444))
-* u128 and i128 ([no cranelift support](https://github.com/CraneStation/cranelift/issues/354))
 * SIMD ([tracked here](https://github.com/bjorn3/rustc_codegen_cranelift/issues/171))
 
 ## Troubleshooting

Readme.md

@@ -14,7 +14,6 @@ alloc_system = { path = "./alloc_system" }
 [patch.crates-io]
 rustc-std-workspace-core = { path = "./sysroot_src/src/tools/rustc-std-workspace-core" }
 rustc-std-workspace-alloc = { path = "./rustc-std-workspace-alloc" }
-compiler_builtins = { path = "./compiler_builtins" }
 
 [profile.release]
 debug = true

build_sysroot/Cargo.toml

@@ -314,7 +314,7 @@ impl Neg for i16 {
     type Output = i16;
 
     fn neg(self) -> i16 {
-        -self
+        self
     }
 }
 

build_sysroot/compiler_builtins/Cargo.toml

@@ -236,21 +236,4 @@ fn main() {
     unsafe { assert_eq!(ABC as usize, 0); }
 
     &mut (|| Some(0 as *const ())) as &mut FnMut() -> Option<*const ()>;
-
-    // checked binops
-    let zeroi8 = 0i8;
-    let oneu8 = 1u8;
-    let onei8 = 1i8;
-    zeroi8 - 1;
-    oneu8 - 1;
-    zeroi8 - -2i8;
-    #[allow(unreachable_code)]
-    {
-        if false {
-            let minustwoi8 = -2i8;
-            oneu8 + 255;
-            onei8 + 127;
-            minustwoi8 - 127;
-        }
-    }
 }

build_sysroot/compiler_builtins/lib.rs

@@ -1,6 +1,7 @@
 #![feature(core_intrinsics)]
 
 use std::io::Write;
+use std::intrinsics;
 
 fn main() {
     let _ = ::std::iter::repeat('a' as u8).take(10).collect::<Vec<_>>();
@@ -29,6 +30,18 @@ fn main() {
     println!("{}", 2.3f32.ceil());
     println!("{}", 2.3f32.min(1.0));
     println!("{}", 2.3f32.max(1.0));
+
+    assert_eq!(0b0000000000000000000000000010000010000000000000000000000000000000_0000000000100000000000000000000000001000000000000100000000000000u128.leading_zeros(), 26);
+    assert_eq!(0b0000000000000000000000000010000000000000000000000000000000000000_0000000000000000000000000000000000001000000000000000000010000000u128.trailing_zeros(), 7);
+
+    0i128.checked_div(2i128);
+    0u128.checked_div(2u128);
+    assert_eq!(1u128 + 2, 3);
+
+    assert_eq!(0b100010000000000000000000000000000u128 >> 10, 0b10001000000000000000000u128);
+    assert_eq!(0xFEDCBA987654321123456789ABCDEFu128 >> 64, 0xFEDCBA98765432u128);
+    assert_eq!(0xFEDCBA987654321123456789ABCDEFu128 as i128 >> 64, 0xFEDCBA98765432i128);
+    assert_eq!(353985398u128 * 932490u128, 330087843781020u128);
 }
 
 #[derive(PartialEq)]

example/mini_core.rs

@@ -87,7 +87,7 @@ pub fn scalar_to_clif_type(tcx: TyCtxt, scalar: Scalar) -> Type {
             Integer::I16 => types::I16,
             Integer::I32 => types::I32,
             Integer::I64 => types::I64,
-            Integer::I128 => unimpl!("u/i128"),
+            Integer::I128 => types::I128,
         },
         Primitive::Float(flt) => match flt {
             FloatTy::F32 => types::F32,
@@ -252,14 +252,12 @@ impl<'a, 'tcx: 'a, B: Backend + 'a> FunctionCx<'a, 'tcx, B> {
         &mut self,
         name: &str,
         input_tys: Vec<types::Type>,
-        output_ty: Option<types::Type>,
+        output_tys: Vec<types::Type>,
         args: &[Value],
-    ) -> Option<Value> {
+    ) -> &[Value] {
         let sig = Signature {
             params: input_tys.iter().cloned().map(AbiParam::new).collect(),
-            returns: output_ty
-                .map(|output_ty| vec![AbiParam::new(output_ty)])
-                .unwrap_or(Vec::new()),
+            returns: output_tys.iter().cloned().map(AbiParam::new).collect(),
             call_conv: CallConv::SystemV,
         };
         let func_id = self
@@ -270,12 +268,10 @@ impl<'a, 'tcx: 'a, B: Backend + 'a> FunctionCx<'a, 'tcx, B> {
             .module
             .declare_func_in_func(func_id, &mut self.bcx.func);
         let call_inst = self.bcx.ins().call(func_ref, args);
-        if output_ty.is_none() {
-            return None;
-        }
+        self.add_comment(call_inst, format!("easy_call {}", name));
         let results = self.bcx.inst_results(call_inst);
-        assert_eq!(results.len(), 1);
-        Some(results[0])
+        assert!(results.len() <= 2, "{}", results.len());
+        results
     }
 
     pub fn easy_call(
@@ -294,23 +290,22 @@ impl<'a, 'tcx: 'a, B: Backend + 'a> FunctionCx<'a, 'tcx, B> {
             })
             .unzip();
         let return_layout = self.layout_of(return_ty);
-        let return_ty = if let ty::Tuple(tup) = return_ty.sty {
-            if !tup.is_empty() {
-                bug!("easy_call( (...) -> <non empty tuple> ) is not allowed");
-            }
-            None
+        let return_tys = if let ty::Tuple(tup) = return_ty.sty {
+            tup.types().map(|ty| self.clif_type(ty).unwrap()).collect()
         } else {
-            Some(self.clif_type(return_ty).unwrap())
+            vec![self.clif_type(return_ty).unwrap()]
         };
-        if let Some(val) = self.lib_call(name, input_tys, return_ty, &args) {
-            CValue::by_val(val, return_layout)
-        } else {
-            CValue::by_ref(
+        let ret_vals = self.lib_call(name, input_tys, return_tys, &args);
+        match *ret_vals {
+            [] => CValue::by_ref(
                 self.bcx
                     .ins()
                     .iconst(self.pointer_type, self.pointer_type.bytes() as i64),
                 return_layout,
-            )
+            ),
+            [val] => CValue::by_val(val, return_layout),
+            [val, extra] => CValue::by_val_pair(val, extra, return_layout),
+            _ => unreachable!(),
         }
     }
 
@@ -346,7 +341,7 @@ fn add_arg_comment<'a, 'tcx: 'a>(
     };
     let pass_mode = format!("{:?}", pass_mode);
     fx.add_global_comment(format!(
-        "{msg:5} {local:>3}{local_field:<5} {params:10} {pass_mode:20} {ssa:10} {ty:?}",
+        "{msg:5} {local:>3}{local_field:<5} {params:10} {pass_mode:36} {ssa:10} {ty:?}",
         msg = msg,
         local = format!("{:?}", local),
         local_field = local_field,
@@ -360,7 +355,7 @@ fn add_arg_comment<'a, 'tcx: 'a>(
 #[cfg(debug_assertions)]
 fn add_local_header_comment(fx: &mut FunctionCx<impl Backend>) {
     fx.add_global_comment(format!(
-        "msg   loc.idx    param    pass mode            ssa flags  ty"
+        "msg   loc.idx    param    pass mode                            ssa flags  ty"
     ));
 }
 
@@ -846,7 +841,7 @@ pub fn codegen_drop<'a, 'tcx: 'a>(
                 );
                 drop_place.write_place_ref(fx, arg_place);
                 let arg_value = arg_place.to_cvalue(fx);
-                crate::abi::codegen_call_inner(
+                codegen_call_inner(
                     fx,
                     None,
                     drop_fn_ty,