Skip to content

Commit 21bd677

Browse files
GuillaumeGomezGuillaumeGomez
committed
Merge commit '482e8540a1b757ed7bccc2041c5400f051fdb01e' into subtree-update_cg_gcc_2025-08-04
2 parents e1b9081 + 482e854 commit 21bd677

File tree

15 files changed

+275
-45
lines changed

15 files changed

+275
-45
lines changed

‎compiler/rustc_codegen_gcc/build_system/src/abi_test.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ pub fn run() -> Result<(), String> {
3131
Some("clones/abi-cafe".as_ref()),
3232
true,
3333
)
34-
.map_err(|err| (format!("Git clone failed with message: {err:?}!")))?;
34+
.map_err(|err| format!("Git clone failed with message: {err:?}!"))?;
3535
// Configure abi-cafe to use the exact same rustc version we use - this is crucial.
3636
// Otherwise, the concept of ABI compatibility becomes meanignless.
3737
std::fs::copy("rust-toolchain", "clones/abi-cafe/rust-toolchain")

‎compiler/rustc_codegen_gcc/build_system/src/fuzz.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -43,18 +43,18 @@ pub fn run() -> Result<(), String> {
4343
"--start" => {
4444
start =
4545
str::parse(&args.next().ok_or_else(|| "Fuzz start not provided!".to_string())?)
46-
.map_err(|err| (format!("Fuzz start not a number {err:?}!")))?;
46+
.map_err(|err| format!("Fuzz start not a number {err:?}!"))?;
4747
}
4848
"--count" => {
4949
count =
5050
str::parse(&args.next().ok_or_else(|| "Fuzz count not provided!".to_string())?)
51-
.map_err(|err| (format!("Fuzz count not a number {err:?}!")))?;
51+
.map_err(|err| format!("Fuzz count not a number {err:?}!"))?;
5252
}
5353
"-j" | "--jobs" => {
5454
threads = str::parse(
5555
&args.next().ok_or_else(|| "Fuzz thread count not provided!".to_string())?,
5656
)
57-
.map_err(|err| (format!("Fuzz thread count not a number {err:?}!")))?;
57+
.map_err(|err| format!("Fuzz thread count not a number {err:?}!"))?;
5858
}
5959
_ => return Err(format!("Unknown option {arg}")),
6060
}
@@ -66,7 +66,7 @@ pub fn run() -> Result<(), String> {
6666
Some("clones/rustlantis".as_ref()),
6767
true,
6868
)
69-
.map_err(|err| (format!("Git clone failed with message: {err:?}!")))?;
69+
.map_err(|err| format!("Git clone failed with message: {err:?}!"))?;
7070

7171
// Ensure that we are on the newest rustlantis commit.
7272
let cmd: &[&dyn AsRef<OsStr>] = &[&"git", &"pull", &"origin"];

‎compiler/rustc_codegen_gcc/patches/0001-Add-stdarch-Cargo.toml-for-testing.patch

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,29 +1,28 @@
1-
From b8f3eed3053c9333b5dfbeaeb2a6a65a4b3156df Mon Sep 17 00:00:00 2001
2-
From: Antoni Boucher <bouanto@zoho.com>
3-
Date: Tue, 29 Aug 2023 13:06:34 -0400
1+
From 190e26c9274b3c93a9ee3516b395590e6bd9213b Mon Sep 17 00:00:00 2001
2+
From: None <none@example.com>
3+
Date: Sun, 3 Aug 2025 19:54:56 -0400
44
Subject: [PATCH] Patch 0001-Add-stdarch-Cargo.toml-for-testing.patch
55

66
---
7-
library/stdarch/Cargo.toml | 23 +++++++++++++++++++++++
8-
1 file changed, 23 insertions(+)
7+
library/stdarch/Cargo.toml | 20 ++++++++++++++++++++
8+
1 file changed, 20 insertions(+)
99
create mode 100644 library/stdarch/Cargo.toml
1010

1111
diff --git a/library/stdarch/Cargo.toml b/library/stdarch/Cargo.toml
1212
new file mode 100644
13-
index 0000000..4c63700
13+
index 0000000..bd6725c
1414
--- /dev/null
1515
+++ b/library/stdarch/Cargo.toml
16-
@@ -0,0 +1,21 @@
16+
@@ -0,0 +1,20 @@
1717
+[workspace]
1818
+resolver = "1"
1919
+members = [
20-
+ "crates/core_arch",
21-
+ "crates/std_detect",
22-
+ "crates/stdarch-gen-arm",
20+
+ "crates/*",
2321
+ #"examples/"
2422
+]
2523
+exclude = [
26-
+ "crates/wasm-assert-instr-tests"
24+
+ "crates/wasm-assert-instr-tests",
25+
+ "rust_programs",
2726
+]
2827
+
2928
+[profile.release]
@@ -36,5 +35,5 @@ index 0000000..4c63700
3635
+opt-level = 3
3736
+incremental = true
3837
--
39-
2.42.0
38+
2.50.1
4039

‎compiler/rustc_codegen_gcc/rust-toolchain

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,3 @@
11
[toolchain]
2-
channel = "nightly-2025-07-04"
2+
channel = "nightly-2025-08-03"
33
components = ["rust-src", "rustc-dev", "llvm-tools-preview"]

‎compiler/rustc_codegen_gcc/src/allocator.rs

Lines changed: 9 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -99,11 +99,15 @@ fn create_const_value_function(
9999
let func = context.new_function(None, FunctionType::Exported, output, &[], name, false);
100100

101101
#[cfg(feature = "master")]
102-
func.add_attribute(FnAttribute::Visibility(symbol_visibility_to_gcc(
103-
tcx.sess.default_visibility(),
104-
)));
105-
106-
func.add_attribute(FnAttribute::AlwaysInline);
102+
{
103+
func.add_attribute(FnAttribute::Visibility(symbol_visibility_to_gcc(
104+
tcx.sess.default_visibility(),
105+
)));
106+
107+
// FIXME(antoyo): cg_llvm sets AlwaysInline, but AlwaysInline is different in GCC and using
108+
// it here will causes linking errors when using LTO.
109+
func.add_attribute(FnAttribute::Inline);
110+
}
107111

108112
if tcx.sess.must_emit_unwind_tables() {
109113
// TODO(antoyo): emit unwind tables.

‎compiler/rustc_codegen_gcc/src/builder.rs

Lines changed: 20 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -540,9 +540,15 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
540540

541541
fn ret(&mut self, mut value: RValue<'gcc>) {
542542
let expected_return_type = self.current_func().get_return_type();
543-
if !expected_return_type.is_compatible_with(value.get_type()) {
544-
// NOTE: due to opaque pointers now being used, we need to cast here.
545-
value = self.context.new_cast(self.___location, value, expected_return_type);
543+
let value_type = value.get_type();
544+
if !expected_return_type.is_compatible_with(value_type) {
545+
// NOTE: due to opaque pointers now being used, we need to (bit)cast here.
546+
if self.is_native_int_type(value_type) && self.is_native_int_type(expected_return_type)
547+
{
548+
value = self.context.new_cast(self.___location, value, expected_return_type);
549+
} else {
550+
value = self.context.new_bitcast(self.___location, value, expected_return_type);
551+
}
546552
}
547553
self.llbb().end_with_return(self.___location, value);
548554
}
@@ -1279,11 +1285,19 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
12791285

12801286
fn intcast(
12811287
&mut self,
1282-
value: RValue<'gcc>,
1288+
mut value: RValue<'gcc>,
12831289
dest_typ: Type<'gcc>,
1284-
_is_signed: bool,
1290+
is_signed: bool,
12851291
) -> RValue<'gcc> {
1286-
// NOTE: is_signed is for value, not dest_typ.
1292+
let value_type = value.get_type();
1293+
if is_signed && !value_type.is_signed(self.cx) {
1294+
let signed_type = value_type.to_signed(self.cx);
1295+
value = self.gcc_int_cast(value, signed_type);
1296+
} else if !is_signed && value_type.is_signed(self.cx) {
1297+
let unsigned_type = value_type.to_unsigned(self.cx);
1298+
value = self.gcc_int_cast(value, unsigned_type);
1299+
}
1300+
12871301
self.gcc_int_cast(value, dest_typ)
12881302
}
12891303

‎compiler/rustc_codegen_gcc/src/int.rs

Lines changed: 67 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -4,12 +4,15 @@
44
55
// cSpell:words cmpti divti modti mulodi muloti udivti umodti
66

7-
use gccjit::{BinaryOp, ComparisonOp, FunctionType, Location, RValue, ToRValue, Type, UnaryOp};
7+
use gccjit::{
8+
BinaryOp, CType, ComparisonOp, FunctionType, Location, RValue, ToRValue, Type, UnaryOp,
9+
};
810
use rustc_abi::{CanonAbi, Endian, ExternAbi};
911
use rustc_codegen_ssa::common::{IntPredicate, TypeKind};
1012
use rustc_codegen_ssa::traits::{BackendTypes, BaseTypeCodegenMethods, BuilderMethods, OverflowOp};
1113
use rustc_middle::ty::{self, Ty};
1214
use rustc_target::callconv::{ArgAbi, ArgAttributes, FnAbi, PassMode};
15+
use rustc_type_ir::{Interner, TyKind};
1316

1417
use crate::builder::{Builder, ToGccComp};
1518
use crate::common::{SignType, TypeReflection};
@@ -167,9 +170,9 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
167170
if a_type.is_vector() {
168171
// Vector types need to be bitcast.
169172
// TODO(antoyo): perhaps use __builtin_convertvector for vector casting.
170-
b = self.context.new_bitcast(self.___location, b, a.get_type());
173+
b = self.context.new_bitcast(self.___location, b, a_type);
171174
} else {
172-
b = self.context.new_cast(self.___location, b, a.get_type());
175+
b = self.context.new_cast(self.___location, b, a_type);
173176
}
174177
}
175178
self.context.new_binary_op(self.___location, operation, a_type, a, b)
@@ -216,13 +219,22 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
216219
operation_name: &str,
217220
signed: bool,
218221
a: RValue<'gcc>,
219-
b: RValue<'gcc>,
222+
mut b: RValue<'gcc>,
220223
) -> RValue<'gcc> {
221224
let a_type = a.get_type();
222225
let b_type = b.get_type();
223226
if (self.is_native_int_type_or_bool(a_type) && self.is_native_int_type_or_bool(b_type))
224227
|| (a_type.is_vector() && b_type.is_vector())
225228
{
229+
if !a_type.is_compatible_with(b_type) {
230+
if a_type.is_vector() {
231+
// Vector types need to be bitcast.
232+
// TODO(antoyo): perhaps use __builtin_convertvector for vector casting.
233+
b = self.context.new_bitcast(self.___location, b, a_type);
234+
} else {
235+
b = self.context.new_cast(self.___location, b, a_type);
236+
}
237+
}
226238
self.context.new_binary_op(self.___location, operation, a_type, a, b)
227239
} else {
228240
debug_assert!(a_type.dyncast_array().is_some());
@@ -351,6 +363,11 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
351363
// TODO(antoyo): is it correct to use rhs type instead of the parameter typ?
352364
.new_local(self.___location, rhs.get_type(), "binopResult")
353365
.get_address(self.___location);
366+
let new_type = type_kind_to_gcc_type(new_kind);
367+
let new_type = self.context.new_c_type(new_type);
368+
let lhs = self.context.new_cast(self.___location, lhs, new_type);
369+
let rhs = self.context.new_cast(self.___location, rhs, new_type);
370+
let res = self.context.new_cast(self.___location, res, new_type.make_pointer());
354371
let overflow = self.overflow_call(intrinsic, &[lhs, rhs, res], None);
355372
(res.dereference(self.___location).to_rvalue(), overflow)
356373
}
@@ -477,11 +494,27 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
477494
let lhs_low = self.context.new_cast(self.___location, self.low(lhs), unsigned_type);
478495
let rhs_low = self.context.new_cast(self.___location, self.low(rhs), unsigned_type);
479496

497+
let mut lhs_high = self.high(lhs);
498+
let mut rhs_high = self.high(rhs);
499+
500+
match op {
501+
IntPredicate::IntUGT
502+
| IntPredicate::IntUGE
503+
| IntPredicate::IntULT
504+
| IntPredicate::IntULE => {
505+
lhs_high = self.context.new_cast(self.___location, lhs_high, unsigned_type);
506+
rhs_high = self.context.new_cast(self.___location, rhs_high, unsigned_type);
507+
}
508+
// TODO(antoyo): we probably need to handle signed comparison for unsigned
509+
// integers.
510+
_ => (),
511+
}
512+
480513
let condition = self.context.new_comparison(
481514
self.___location,
482515
ComparisonOp::LessThan,
483-
self.high(lhs),
484-
self.high(rhs),
516+
lhs_high,
517+
rhs_high,
485518
);
486519
self.llbb().end_with_conditional(self.___location, condition, block1, block2);
487520

@@ -495,8 +528,8 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
495528
let condition = self.context.new_comparison(
496529
self.___location,
497530
ComparisonOp::GreaterThan,
498-
self.high(lhs),
499-
self.high(rhs),
531+
lhs_high,
532+
rhs_high,
500533
);
501534
block2.end_with_conditional(self.___location, condition, block3, block4);
502535

@@ -620,14 +653,17 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
620653
}
621654
}
622655

623-
pub fn gcc_xor(&self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
656+
pub fn gcc_xor(&self, a: RValue<'gcc>, mut b: RValue<'gcc>) -> RValue<'gcc> {
624657
let a_type = a.get_type();
625658
let b_type = b.get_type();
626659
if a_type.is_vector() && b_type.is_vector() {
627660
let b = self.bitcast_if_needed(b, a_type);
628661
a ^ b
629662
} else if self.is_native_int_type_or_bool(a_type) && self.is_native_int_type_or_bool(b_type)
630663
{
664+
if !a_type.is_compatible_with(b_type) {
665+
b = self.context.new_cast(self.___location, b, a_type);
666+
}
631667
a ^ b
632668
} else {
633669
self.concat_low_high_rvalues(
@@ -1042,3 +1078,25 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
10421078
self.context.new_array_constructor(None, typ, &values)
10431079
}
10441080
}
1081+
1082+
fn type_kind_to_gcc_type<I: Interner>(kind: TyKind<I>) -> CType {
1083+
use rustc_middle::ty::IntTy::*;
1084+
use rustc_middle::ty::UintTy::*;
1085+
use rustc_middle::ty::{Int, Uint};
1086+
1087+
match kind {
1088+
Int(I8) => CType::Int8t,
1089+
Int(I16) => CType::Int16t,
1090+
Int(I32) => CType::Int32t,
1091+
Int(I64) => CType::Int64t,
1092+
Int(I128) => CType::Int128t,
1093+
1094+
Uint(U8) => CType::UInt8t,
1095+
Uint(U16) => CType::UInt16t,
1096+
Uint(U32) => CType::UInt32t,
1097+
Uint(U64) => CType::UInt64t,
1098+
Uint(U128) => CType::UInt128t,
1099+
1100+
_ => unimplemented!("Kind: {:?}", kind),
1101+
}
1102+
}

0 commit comments

Comments
 (0)