Use a C-safe return type for __rust_[ui]128_* overflowing intrinsics

Combined with [1], this will change the overflowing multiplication
operations to return an `extern "C"`-safe type.

Link: rust-lang/compiler-builtins#735 [1]

Author: tgross35

compiler/rustc_codegen_cranelift/src/codegen_i128.rs

@@ -82,21 +82,25 @@ pub(crate) fn maybe_codegen_checked<'tcx>(
         BinOp::BitAnd | BinOp::BitOr | BinOp::BitXor => unreachable!(),
         BinOp::Add | BinOp::Sub => None,
         BinOp::Mul => {
-            let out_ty = Ty::new_tup(fx.tcx, &[lhs.layout().ty, fx.tcx.types.bool]);
-            let out_place = CPlace::new_stack_slot(fx, fx.layout_of(out_ty));
+            let oflow_out_place = CPlace::new_stack_slot(fx, fx.layout_of(fx.tcx.types.i32));
             let param_types = vec![
-                AbiParam::special(fx.pointer_type, ArgumentPurpose::StructReturn),
                 AbiParam::new(types::I128),
                 AbiParam::new(types::I128),
+                AbiParam::special(fx.pointer_type, ArgumentPurpose::Normal),
             ];
-            let args = [out_place.to_ptr().get_addr(fx), lhs.load_scalar(fx), rhs.load_scalar(fx)];
-            fx.lib_call(
+            let args =
+                [lhs.load_scalar(fx), rhs.load_scalar(fx), oflow_out_place.to_ptr().get_addr(fx)];
+            let ret = fx.lib_call(
                 if is_signed { "__rust_i128_mulo" } else { "__rust_u128_mulo" },
                 param_types,
-                vec![],
+                vec![AbiParam::new(types::I128)],
                 &args,
             );
-            Some(out_place.to_cvalue(fx))
+            let mul = ret[0];
+            let oflow = oflow_out_place.to_cvalue(fx).load_scalar(fx);
+            let oflow = clif_intcast(fx, oflow, types::I8, false);
+            let layout = fx.layout_of(Ty::new_tup(fx.tcx, &[lhs.layout().ty, fx.tcx.types.bool]));
+            Some(CValue::by_val_pair(mul, oflow, layout))
         }
         BinOp::AddUnchecked | BinOp::SubUnchecked | BinOp::MulUnchecked => unreachable!(),
         BinOp::AddWithOverflow | BinOp::SubWithOverflow | BinOp::MulWithOverflow => unreachable!(),

compiler/rustc_codegen_cranelift/src/compiler_builtins.rs

@@ -43,7 +43,7 @@ builtin_functions! {
     fn __divti3(n: i128, d: i128) -> i128;
     fn __umodti3(n: u128, d: u128) -> u128;
     fn __modti3(n: i128, d: i128) -> i128;
-    fn __rust_u128_mulo(a: u128, b: u128) -> (u128, bool);
+    fn __rust_u128_mulo(a: u128, b: u128, oflow: &mut i32) -> u128;
 
     // floats
     fn __floattisf(i: i128) -> f32;

compiler/rustc_codegen_gcc/src/int.rs

@@ -322,36 +322,26 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
                 },
             }
         } else {
-            match new_kind {
-                Int(I128) | Uint(U128) => {
-                    let func_name = match oop {
-                        OverflowOp::Add => match new_kind {
-                            Int(I128) => "__rust_i128_addo",
-                            Uint(U128) => "__rust_u128_addo",
-                            _ => unreachable!(),
-                        },
-                        OverflowOp::Sub => match new_kind {
-                            Int(I128) => "__rust_i128_subo",
-                            Uint(U128) => "__rust_u128_subo",
-                            _ => unreachable!(),
-                        },
-                        OverflowOp::Mul => match new_kind {
-                            Int(I128) => "__rust_i128_mulo", // TODO(antoyo): use __muloti4d instead?
-                            Uint(U128) => "__rust_u128_mulo",
-                            _ => unreachable!(),
-                        },
-                    };
-                    return self.operation_with_overflow(func_name, lhs, rhs);
-                }
-                _ => match oop {
-                    OverflowOp::Mul => match new_kind {
-                        Int(I32) => "__mulosi4",
-                        Int(I64) => "__mulodi4",
-                        _ => unreachable!(),
-                    },
-                    _ => unimplemented!("overflow operation for {:?}", new_kind),
+            let func_name = match oop {
+                OverflowOp::Add => match new_kind {
+                    Int(I128) => "__rust_i128_addo",
+                    Uint(U128) => "__rust_u128_addo",
+                    _ => unreachable!(),
                 },
-            }
+                OverflowOp::Sub => match new_kind {
+                    Int(I128) => "__rust_i128_subo",
+                    Uint(U128) => "__rust_u128_subo",
+                    _ => unreachable!(),
+                },
+                OverflowOp::Mul => match new_kind {
+                    Int(I32) => "__mulosi4",
+                    Int(I64) => "__mulodi4",
+                    Int(I128) => "__rust_i128_mulo", // TODO(antoyo): use __muloti4d instead?
+                    Uint(U128) => "__rust_u128_mulo",
+                    _ => unreachable!(),
+                },
+            };
+            return self.operation_with_overflow(func_name, lhs, rhs);
         };
 
         let intrinsic = self.context.get_builtin_function(name);
@@ -364,6 +354,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         (res.dereference(self.location).to_rvalue(), overflow)
     }
 
+    /// Non-`__builtin_*` overflow operations with a `fn(T, T, &mut i32) -> bool` signature.
     pub fn operation_with_overflow(
         &self,
         func_name: &str,