From a911da13ddbfbe8cc9c7dec367cba715b6fb7f87 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sun, 15 Dec 2024 11:03:37 +0000
Subject: [PATCH 1/2] 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: https://github.com/rust-lang/compiler-builtins/pull/735 [1]
---
.../src/codegen_i128.rs | 18 +--
.../src/compiler_builtins.rs | 2 +-
compiler/rustc_codegen_gcc/src/int.rs | 123 +++++++++---------
.../rustc_codegen_gcc/src/intrinsic/mod.rs | 6 +-
4 files changed, 75 insertions(+), 74 deletions(-)
diff --git a/compiler/rustc_codegen_cranelift/src/codegen_i128.rs b/compiler/rustc_codegen_cranelift/src/codegen_i128.rs
index 025667e66b2a2..dcfd7ddabbc42 100644
--- a/compiler/rustc_codegen_cranelift/src/codegen_i128.rs
+++ b/compiler/rustc_codegen_cranelift/src/codegen_i128.rs
@@ -76,20 +76,22 @@ pub(crate) fn maybe_codegen_mul_checked<'tcx>(
}
let is_signed = type_sign(lhs.layout().ty);
-
- 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))
}
diff --git a/compiler/rustc_codegen_cranelift/src/compiler_builtins.rs b/compiler/rustc_codegen_cranelift/src/compiler_builtins.rs
index f8e3a034421da..2484c10848ed3 100644
--- a/compiler/rustc_codegen_cranelift/src/compiler_builtins.rs
+++ b/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;
diff --git a/compiler/rustc_codegen_gcc/src/int.rs b/compiler/rustc_codegen_gcc/src/int.rs
index 7b9d1feb8d710..fe6a65bed03b0 100644
--- a/compiler/rustc_codegen_gcc/src/int.rs
+++ b/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, width) = match oop {
+ OverflowOp::Add => match new_kind {
+ Int(I128) => ("__rust_i128_addo", 128),
+ Uint(U128) => ("__rust_u128_addo", 128),
+ _ => unreachable!(),
},
- }
+ OverflowOp::Sub => match new_kind {
+ Int(I128) => ("__rust_i128_subo", 128),
+ Uint(U128) => ("__rust_u128_subo", 128),
+ _ => unreachable!(),
+ },
+ OverflowOp::Mul => match new_kind {
+ Int(I32) => ("__mulosi4", 32),
+ Int(I64) => ("__mulodi4", 64),
+ Int(I128) => ("__rust_i128_mulo", 128), // TODO(antoyo): use __muloti4d instead?
+ Uint(U128) => ("__rust_u128_mulo", 128),
+ _ => unreachable!(),
+ },
+ };
+ return self.operation_with_overflow(func_name, lhs, rhs, width);
};
let intrinsic = self.context.get_builtin_function(name);
@@ -364,80 +354,87 @@ 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) -> T` signature.
pub fn operation_with_overflow(
&self,
func_name: &str,
lhs: RValue<'gcc>,
rhs: RValue<'gcc>,
+ width: u64,
) -> (RValue<'gcc>, RValue<'gcc>) {
let a_type = lhs.get_type();
let b_type = rhs.get_type();
debug_assert!(a_type.dyncast_array().is_some());
debug_assert!(b_type.dyncast_array().is_some());
+ let overflow_type = self.i32_type;
+ let overflow_param_type = overflow_type.make_pointer();
+ let res_type = a_type;
+
+ let overflow_value =
+ self.current_func().new_local(self.location, overflow_type, "overflow");
+ let overflow_addr = overflow_value.get_address(self.location);
+
let param_a = self.context.new_parameter(self.location, a_type, "a");
let param_b = self.context.new_parameter(self.location, b_type, "b");
- let result_field = self.context.new_field(self.location, a_type, "result");
- let overflow_field = self.context.new_field(self.location, self.bool_type, "overflow");
-
- let ret_ty = Ty::new_tup(self.tcx, &[self.tcx.types.i128, self.tcx.types.bool]);
+ let param_overflow =
+ self.context.new_parameter(self.location, overflow_param_type, "overflow");
+
+ let a_elem_type = a_type.dyncast_array().expect("non-array a value");
+ debug_assert!(a_elem_type.is_integral());
+ let res_ty = match width {
+ 32 => self.tcx.types.i32,
+ 64 => self.tcx.types.i64,
+ 128 => self.tcx.types.i128,
+ _ => unreachable!("unexpected integer size"),
+ };
let layout = self
.tcx
- .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ret_ty))
+ .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(res_ty))
.unwrap();
let arg_abi = ArgAbi { layout, mode: PassMode::Direct(ArgAttributes::new()) };
let mut fn_abi = FnAbi {
- args: vec![arg_abi.clone(), arg_abi.clone()].into_boxed_slice(),
+ args: vec![arg_abi.clone(), arg_abi.clone(), arg_abi.clone()].into_boxed_slice(),
ret: arg_abi,
c_variadic: false,
- fixed_count: 2,
+ fixed_count: 3,
conv: Conv::C,
can_unwind: false,
};
fn_abi.adjust_for_foreign_abi(self.cx, spec::abi::Abi::C { unwind: false }).unwrap();
- let indirect = matches!(fn_abi.ret.mode, PassMode::Indirect { .. });
-
- let return_type = self
- .context
- .new_struct_type(self.location, "result_overflow", &[result_field, overflow_field]);
- let result = if indirect {
- let return_value =
- self.current_func().new_local(self.location, return_type.as_type(), "return_value");
- let return_param_type = return_type.as_type().make_pointer();
- let return_param =
- self.context.new_parameter(self.location, return_param_type, "return_value");
+ let ret_indirect = matches!(fn_abi.ret.mode, PassMode::Indirect { .. });
+
+ let result = if ret_indirect {
+ let res_value = self.current_func().new_local(self.location, res_type, "result_value");
+ let res_addr = res_value.get_address(self.location);
+ let res_param_type = res_type.make_pointer();
+ let param_res = self.context.new_parameter(self.location, res_param_type, "result");
+
let func = self.context.new_function(
self.location,
FunctionType::Extern,
self.type_void(),
- &[return_param, param_a, param_b],
+ &[param_res, param_a, param_b, param_overflow],
func_name,
false,
);
- self.llbb().add_eval(
- self.location,
- self.context.new_call(self.location, func, &[
- return_value.get_address(self.location),
- lhs,
- rhs,
- ]),
- );
- return_value.to_rvalue()
+ let _void =
+ self.context.new_call(self.location, func, &[res_addr, lhs, rhs, overflow_addr]);
+ res_value.to_rvalue()
} else {
let func = self.context.new_function(
self.location,
FunctionType::Extern,
- return_type.as_type(),
- &[param_a, param_b],
+ res_type,
+ &[param_a, param_b, param_overflow],
func_name,
false,
);
- self.context.new_call(self.location, func, &[lhs, rhs])
+ self.context.new_call(self.location, func, &[lhs, rhs, overflow_addr])
};
- let overflow = result.access_field(self.location, overflow_field);
- let int_result = result.access_field(self.location, result_field);
- (int_result, overflow)
+
+ (result, self.context.new_cast(self.location, overflow_value, self.bool_type).to_rvalue())
}
pub fn gcc_icmp(
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index 42d189d1b7d38..48606f5f91c0f 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -1001,7 +1001,8 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
128 => "__rust_i128_addo",
_ => unreachable!(),
};
- let (int_result, overflow) = self.operation_with_overflow(func_name, lhs, rhs);
+ let (int_result, overflow) =
+ self.operation_with_overflow(func_name, lhs, rhs, width);
self.llbb().add_assignment(self.location, res, int_result);
overflow
};
@@ -1071,7 +1072,8 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
128 => "__rust_i128_subo",
_ => unreachable!(),
};
- let (int_result, overflow) = self.operation_with_overflow(func_name, lhs, rhs);
+ let (int_result, overflow) =
+ self.operation_with_overflow(func_name, lhs, rhs, width);
self.llbb().add_assignment(self.location, res, int_result);
overflow
};
From f6a2db8e1b6ee82ebf44b82dfc83740051c59d02 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Wed, 15 Jan 2025 03:58:37 +0000
Subject: [PATCH 2/2] Update compiler-builtins to 0.1.143
0.1.142 fixes an issue parsing optimization flags, and 0.1.143 changes
`__rust_[ui]128_*` builtins to use a C-safe signature.
---
...029-stdlib-Disable-f16-and-f128-in-compiler-builtins.patch | 4 ++--
library/Cargo.lock | 4 ++--
library/alloc/Cargo.toml | 2 +-
library/std/Cargo.toml | 2 +-
4 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/compiler/rustc_codegen_cranelift/patches/0029-stdlib-Disable-f16-and-f128-in-compiler-builtins.patch b/compiler/rustc_codegen_cranelift/patches/0029-stdlib-Disable-f16-and-f128-in-compiler-builtins.patch
index b2eeb52633604..bf58e48515855 100644
--- a/compiler/rustc_codegen_cranelift/patches/0029-stdlib-Disable-f16-and-f128-in-compiler-builtins.patch
+++ b/compiler/rustc_codegen_cranelift/patches/0029-stdlib-Disable-f16-and-f128-in-compiler-builtins.patch
@@ -16,8 +16,8 @@ index 7165c3e48af..968552ad435 100644
[dependencies]
core = { path = "../core" }
--compiler_builtins = { version = "=0.1.141", features = ['rustc-dep-of-std'] }
-+compiler_builtins = { version = "=0.1.141", features = ['rustc-dep-of-std', 'no-f16-f128'] }
+-compiler_builtins = { version = "=0.1.143", features = ['rustc-dep-of-std'] }
++compiler_builtins = { version = "=0.1.143", features = ['rustc-dep-of-std', 'no-f16-f128'] }
[dev-dependencies]
rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
diff --git a/library/Cargo.lock b/library/Cargo.lock
index b01fec9b8f5c4..c8007dd9be046 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -61,9 +61,9 @@ dependencies = [
[[package]]
name = "compiler_builtins"
-version = "0.1.141"
+version = "0.1.143"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e7a0206befe4e574e37d6d7a0fe82e88fdf54bedb0608f239cb11b7a6aa6be"
+checksum = "c85ba2077e3eab3dd81be4ece6b7fb2ad0887c1fb813e9a45400baf75c6c7c29"
dependencies = [
"cc",
"rustc-std-workspace-core",
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index 36f617b45261a..96caac890a35c 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2021"
[dependencies]
core = { path = "../core" }
-compiler_builtins = { version = "=0.1.141", features = ['rustc-dep-of-std'] }
+compiler_builtins = { version = "=0.1.143", features = ['rustc-dep-of-std'] }
[dev-dependencies]
rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index f34dc185eb195..da58d7c13bd12 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -17,7 +17,7 @@ cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
panic_unwind = { path = "../panic_unwind", optional = true }
panic_abort = { path = "../panic_abort" }
core = { path = "../core", public = true }
-compiler_builtins = { version = "=0.1.141" }
+compiler_builtins = { version = "=0.1.143" }
unwind = { path = "../unwind" }
hashbrown = { version = "0.15", default-features = false, features = [
'rustc-dep-of-std',