https://gcc.gnu.org/g:8c999b73f08e8909a47768796017f1175969ac6b
commit r17-5922-g8c999b73f08e8909a47768796017f1175969ac6b Author: Yap Zhi Heng <[email protected]> Date: Sat Oct 10 08:38:50 2026 +0800 gccrs: Implement rust-intrinsics atomic compare-exchange built-ins Assisted-by: GPT-6.1 Sol (for testcases) gcc/rust/ChangeLog: * util/rust-intrinsic-values.h (Intrinsics): Add new entries for atomic compare- exchange function names. * backend/rust-intrinsic-handlers.h (inner::atomic_compare_exchange): New function for compiling atomic commpare-exchange intrinsics. (atomic_compare_exchange): New function to handle atomic_cxchg and its variants. * backend/rust-intrinsic-handlers.cc (inner::atomic_compare_exchange): Implement. (atomic_compare_exchange): Implement. * backend/rust-compile-intrinsic.cc (generic_intrinsics): Add entries for the new atomic compare-exchange intrinsics. * typecheck/rust-hir-type-check-intrinsic.cc (intrinsic_rules): Likewise, but for type checking. Signed-off-by: Yap Zhi Heng <[email protected]> Diff: --- gcc/rust/backend/rust-compile-intrinsic.cc | 30 +++ gcc/rust/backend/rust-intrinsic-handlers.cc | 73 +++++++ gcc/rust/backend/rust-intrinsic-handlers.h | 4 + .../typecheck/rust-hir-type-check-intrinsic.cc | 41 ++++ gcc/rust/util/rust-intrinsic-values.h | 24 ++ .../execute/torture/atomic_compare_exchange.rs | 241 +++++++++++++++++++++ 6 files changed, 413 insertions(+) diff --git a/gcc/rust/backend/rust-compile-intrinsic.cc b/gcc/rust/backend/rust-compile-intrinsic.cc index dab7f67d0cbe..151bda26f40e 100644 --- a/gcc/rust/backend/rust-compile-intrinsic.cc +++ b/gcc/rust/backend/rust-compile-intrinsic.cc @@ -90,6 +90,36 @@ static const std::map<std::string, Intrinsic::CompileFn> intrinsics = { {IValue::ATOMIC_XOR_REL, handlers::atomic_xor (__ATOMIC_RELEASE)}, {IValue::ATOMIC_XOR_ACQREL, handlers::atomic_xor (__ATOMIC_ACQ_REL)}, {IValue::ATOMIC_XOR_RELAXED, handlers::atomic_xor (__ATOMIC_RELAXED)}, + {IValue::ATOMIC_CXCHG, + handlers::atomic_compare_exchange (false, __ATOMIC_SEQ_CST, + __ATOMIC_SEQ_CST)}, + {IValue::ATOMIC_CXCHG_ACQ, + handlers::atomic_compare_exchange (false, __ATOMIC_ACQUIRE, + __ATOMIC_ACQUIRE)}, + {IValue::ATOMIC_CXCHG_REL, + handlers::atomic_compare_exchange (false, __ATOMIC_RELEASE, + __ATOMIC_RELAXED)}, + {IValue::ATOMIC_CXCHG_ACQREL, + handlers::atomic_compare_exchange (false, __ATOMIC_ACQ_REL, + __ATOMIC_ACQUIRE)}, + {IValue::ATOMIC_CXCHG_RELAXED, + handlers::atomic_compare_exchange (false, __ATOMIC_RELAXED, + __ATOMIC_RELAXED)}, + {IValue::ATOMIC_CXCHGWEAK, + handlers::atomic_compare_exchange (true, __ATOMIC_SEQ_CST, + __ATOMIC_SEQ_CST)}, + {IValue::ATOMIC_CXCHGWEAK_ACQ, + handlers::atomic_compare_exchange (true, __ATOMIC_ACQUIRE, + __ATOMIC_ACQUIRE)}, + {IValue::ATOMIC_CXCHGWEAK_REL, + handlers::atomic_compare_exchange (true, __ATOMIC_RELEASE, + __ATOMIC_RELAXED)}, + {IValue::ATOMIC_CXCHGWEAK_ACQREL, + handlers::atomic_compare_exchange (true, __ATOMIC_ACQ_REL, + __ATOMIC_ACQUIRE)}, + {IValue::ATOMIC_CXCHGWEAK_RELAXED, + handlers::atomic_compare_exchange (true, __ATOMIC_RELAXED, + __ATOMIC_RELAXED)}, {IValue::UNCHECKED_ADD, handlers::unchecked_op (PLUS_EXPR)}, {IValue::UNCHECKED_SUB, handlers::unchecked_op (MINUS_EXPR)}, {IValue::UNCHECKED_MUL, handlers::unchecked_op (MULT_EXPR)}, diff --git a/gcc/rust/backend/rust-intrinsic-handlers.cc b/gcc/rust/backend/rust-intrinsic-handlers.cc index b15e4a539075..1beb7a2e97b4 100644 --- a/gcc/rust/backend/rust-intrinsic-handlers.cc +++ b/gcc/rust/backend/rust-intrinsic-handlers.cc @@ -641,6 +641,71 @@ atomic_binary_op (IntrinsicCtx &ctx, const std::string &op_name, int ordering) ctx.add_statement (return_statement); } +// Compiles atomic compare exchange with signature (*mut T, T, T) -> (T, bool). +void +atomic_compare_exchange (IntrinsicCtx &ctx, bool weak, int success_ordering, + int failure_ordering) +{ + // Most intrinsic functions are pure but not the atomic ones + TREE_READONLY (ctx.fn) = 0; + TREE_SIDE_EFFECTS (ctx.fn) = 1; + + // The intrinsic block is already open, so emit the temporary declarations + // directly into it. + tree tmp_stmt = NULL_TREE; + Bvariable *expected_var + = Backend::temporary_variable (ctx.fn, NULL_TREE, ctx.param_types[1], + NULL_TREE, true, UNDEF_LOCATION, &tmp_stmt); + ctx.add_statement (tmp_stmt); + Bvariable *success_var + = Backend::temporary_variable (ctx.fn, NULL_TREE, boolean_type_node, + NULL_TREE, false, UNDEF_LOCATION, &tmp_stmt); + ctx.add_statement (tmp_stmt); + + auto dst = Backend::var_expression (ctx.param_vars[0], UNDEF_LOCATION); + TREE_READONLY (dst) = 0; + + auto expected = expected_var->get_tree (UNDEF_LOCATION); + auto success = success_var->get_tree (UNDEF_LOCATION); + + auto old_value = Backend::var_expression (ctx.param_vars[1], UNDEF_LOCATION); + auto new_value = Backend::var_expression (ctx.param_vars[2], UNDEF_LOCATION); + + auto builtin_decl = resolve_atomic_builtin (ctx, "atomic_compare_exchange"); + + if (!builtin_decl || builtin_decl == error_mark_node) + return; + + ctx.add_statement ( + Backend::assignment_statement (expected, old_value, UNDEF_LOCATION)); + + auto expected_addr = build_fold_addr_expr_loc (UNDEF_LOCATION, expected); + auto builtin_addr = build_fold_addr_expr_loc (UNDEF_LOCATION, builtin_decl); + auto weak_flag = build_int_cst (boolean_type_node, weak); + auto success_memorder = make_unsigned_long_tree (success_ordering); + auto failure_memorder = make_unsigned_long_tree (failure_ordering); + + auto exchange_call + = Backend::call_expression (builtin_addr, + {dst, expected_addr, new_value, weak_flag, + success_memorder, failure_memorder}, + nullptr, UNDEF_LOCATION); + TREE_READONLY (exchange_call) = 0; + TREE_SIDE_EFFECTS (exchange_call) = 1; + + auto assignment_statement + = Backend::assignment_statement (success, exchange_call, UNDEF_LOCATION); + ctx.add_statement (assignment_statement); + + auto tuple_type = TREE_TYPE (DECL_RESULT (ctx.fn)); + auto result + = Backend::constructor_expression (tuple_type, false, {expected, success}, + -1, UNDEF_LOCATION); + auto return_statement + = Backend::return_statement (ctx.fn, result, UNDEF_LOCATION); + ctx.add_statement (return_statement); +} + // Shared inner implementation for ctlz and ctlz_nonzero. // // nonzero=false → ctlz: ctlz(0) is well-defined in Rust and must return @@ -1121,6 +1186,14 @@ atomic_xor (int ordering) return inner::atomic_binary_op (ctx, "fetch_xor", ordering); }; } +Intrinsic::CompileFn +atomic_compare_exchange (bool weak, int success_ordering, int failure_ordering) +{ + return [weak, success_ordering, failure_ordering] (IntrinsicCtx &ctx) { + return inner::atomic_compare_exchange (ctx, weak, success_ordering, + failure_ordering); + }; +} Intrinsic::CompileFn unchecked_op (tree_code op) diff --git a/gcc/rust/backend/rust-intrinsic-handlers.h b/gcc/rust/backend/rust-intrinsic-handlers.h index 3bd1d12dbb71..a1f3aa03fd55 100644 --- a/gcc/rust/backend/rust-intrinsic-handlers.h +++ b/gcc/rust/backend/rust-intrinsic-handlers.h @@ -137,6 +137,8 @@ void atomic_store (IntrinsicCtx &ctx, int ordering); void atomic_load (IntrinsicCtx &ctx, int ordering); void atomic_binary_op (IntrinsicCtx &ctx, const std::string &op_name, int ordering); +void atomic_compare_exchange (IntrinsicCtx &ctx, bool weak, + int success_ordering, int failure_ordering); inline void copy (IntrinsicCtx &ctx, bool overlaps); inline void expect (IntrinsicCtx &ctx, bool likely); void try_handler (IntrinsicCtx &ctx, bool is_new_api); @@ -199,6 +201,8 @@ Intrinsic::CompileFn atomic_and (int ordering); Intrinsic::CompileFn atomic_nand (int ordering); Intrinsic::CompileFn atomic_or (int ordering); Intrinsic::CompileFn atomic_xor (int ordering); +Intrinsic::CompileFn atomic_compare_exchange (bool weak, int success_ordering, + int failure_ordering); Intrinsic::CompileFn unchecked_op (tree_code op); diff --git a/gcc/rust/typecheck/rust-hir-type-check-intrinsic.cc b/gcc/rust/typecheck/rust-hir-type-check-intrinsic.cc index 6e94d6f5f2c8..eccbe882a92b 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-intrinsic.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-intrinsic.cc @@ -277,6 +277,47 @@ const std::unordered_map<std::string, IntrinsicRules> // pub unsafe fn atomic_xor_relaxed<T: Copy>(dst: *mut T, val: T) -> T; {IValue::ATOMIC_XOR_RELAXED, {1, {IRT::MutPtrFirstGeneric, IRT::FirstGeneric}, IRT::FirstGeneric}}, + // fn atomic_cxchg[weak]*<T>(dst: *mut T, old: T, new: T) -> (T, bool); + {IValue::ATOMIC_CXCHG, + {1, + {IRT::MutPtrFirstGeneric, IRT::FirstGeneric, IRT::FirstGeneric}, + IRT::TupleFirstGenericAndBool}}, + {IValue::ATOMIC_CXCHG_ACQ, + {1, + {IRT::MutPtrFirstGeneric, IRT::FirstGeneric, IRT::FirstGeneric}, + IRT::TupleFirstGenericAndBool}}, + {IValue::ATOMIC_CXCHG_REL, + {1, + {IRT::MutPtrFirstGeneric, IRT::FirstGeneric, IRT::FirstGeneric}, + IRT::TupleFirstGenericAndBool}}, + {IValue::ATOMIC_CXCHG_ACQREL, + {1, + {IRT::MutPtrFirstGeneric, IRT::FirstGeneric, IRT::FirstGeneric}, + IRT::TupleFirstGenericAndBool}}, + {IValue::ATOMIC_CXCHG_RELAXED, + {1, + {IRT::MutPtrFirstGeneric, IRT::FirstGeneric, IRT::FirstGeneric}, + IRT::TupleFirstGenericAndBool}}, + {IValue::ATOMIC_CXCHGWEAK, + {1, + {IRT::MutPtrFirstGeneric, IRT::FirstGeneric, IRT::FirstGeneric}, + IRT::TupleFirstGenericAndBool}}, + {IValue::ATOMIC_CXCHGWEAK_ACQ, + {1, + {IRT::MutPtrFirstGeneric, IRT::FirstGeneric, IRT::FirstGeneric}, + IRT::TupleFirstGenericAndBool}}, + {IValue::ATOMIC_CXCHGWEAK_REL, + {1, + {IRT::MutPtrFirstGeneric, IRT::FirstGeneric, IRT::FirstGeneric}, + IRT::TupleFirstGenericAndBool}}, + {IValue::ATOMIC_CXCHGWEAK_ACQREL, + {1, + {IRT::MutPtrFirstGeneric, IRT::FirstGeneric, IRT::FirstGeneric}, + IRT::TupleFirstGenericAndBool}}, + {IValue::ATOMIC_CXCHGWEAK_RELAXED, + {1, + {IRT::MutPtrFirstGeneric, IRT::FirstGeneric, IRT::FirstGeneric}, + IRT::TupleFirstGenericAndBool}}, // pub fn unchecked_add<T: Copy>(x: T, y: T) -> T; {IValue::UNCHECKED_ADD, {1, {IRT::FirstGeneric, IRT::FirstGeneric}, IRT::FirstGeneric}}, diff --git a/gcc/rust/util/rust-intrinsic-values.h b/gcc/rust/util/rust-intrinsic-values.h index e184859a0bdb..06d3469e58b9 100644 --- a/gcc/rust/util/rust-intrinsic-values.h +++ b/gcc/rust/util/rust-intrinsic-values.h @@ -151,6 +151,30 @@ public: static constexpr auto &ATOMIC_XOR_ACQREL = "atomic_xor_acqrel"; static constexpr auto &ATOMIC_XOR_RELAXED = "atomic_xor_relaxed"; + static constexpr auto &ATOMIC_CXCHG = "atomic_cxchg"; + static constexpr auto &ATOMIC_CXCHG_ACQ = "atomic_cxchg_acq"; + static constexpr auto &ATOMIC_CXCHG_REL = "atomic_cxchg_rel"; + static constexpr auto &ATOMIC_CXCHG_ACQREL = "atomic_cxchg_acqrel"; + static constexpr auto &ATOMIC_CXCHG_RELAXED = "atomic_cxchg_relaxed"; + static constexpr auto &ATOMIC_CXCHG_FAILRELAXED = "atomic_cxchg_failrelaxed"; + static constexpr auto &ATOMIC_CXCHG_FAILACQ = "atomic_cxchg_failacq"; + static constexpr auto &ATOMIC_CXCHG_ACQ_FAILRELAXED + = "atomic_cxchg_acq_failrelaxed"; + static constexpr auto &ATOMIC_CXCHG_ACQREL_FAILRELAXED + = "atomic_cxchg_acqrel_failrelaxed"; + static constexpr auto &ATOMIC_CXCHGWEAK = "atomic_cxchgweak"; + static constexpr auto &ATOMIC_CXCHGWEAK_ACQ = "atomic_cxchgweak_acq"; + static constexpr auto &ATOMIC_CXCHGWEAK_REL = "atomic_cxchgweak_rel"; + static constexpr auto &ATOMIC_CXCHGWEAK_ACQREL = "atomic_cxchgweak_acqrel"; + static constexpr auto &ATOMIC_CXCHGWEAK_RELAXED = "atomic_cxchgweak_relaxed"; + static constexpr auto &ATOMIC_CXCHGWEAK_FAILRELAXED + = "atomic_cxchgweak_failrelaxed"; + static constexpr auto &ATOMIC_CXCHGWEAK_FAILACQ = "atomic_cxchgweak_failacq"; + static constexpr auto &ATOMIC_CXCHGWEAK_ACQ_FAILRELAXED + = "atomic_cxchgweak_acq_failrelaxed"; + static constexpr auto &ATOMIC_CXCHGWEAK_ACQREL_FAILRELAXED + = "atomic_cxchgweak_acqrel_failrelaxed"; + static constexpr auto &UNCHECKED_ADD = "unchecked_add"; static constexpr auto &UNCHECKED_SUB = "unchecked_sub"; static constexpr auto &UNCHECKED_MUL = "unchecked_mul"; diff --git a/gcc/testsuite/rust/execute/torture/atomic_compare_exchange.rs b/gcc/testsuite/rust/execute/torture/atomic_compare_exchange.rs new file mode 100644 index 000000000000..2fa8e609826f --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/atomic_compare_exchange.rs @@ -0,0 +1,241 @@ +#![feature(no_core)] +#![no_core] + +#![feature(intrinsics)] + +#![feature(lang_items)] +#[lang = "sized"] +pub trait Sized {} + +#[lang = "clone"] +pub trait Clone: Sized { + fn clone(&self) -> Self; + + fn clone_from(&mut self, source: &Self) { + *self = source.clone() + } +} + +mod impls { + use super::Clone; + + macro_rules! impl_clone { + ($($t:ty)*) => { + $( + impl Clone for $t { + fn clone(&self) -> Self { + *self + } + } + )* + } + } + + impl_clone! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +#[lang = "copy"] +pub trait Copy: Clone { + // Empty. +} + +mod copy_impls { + use super::Copy; + + macro_rules! impl_copy { + ($($t:ty)*) => { + $( + impl Copy for $t {} + )* + } + } + + impl_copy! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +extern "rust-intrinsic" { + pub fn atomic_cxchg<T: Copy>(dst: *mut T, old: T, new: T) -> (T, bool); + pub fn atomic_cxchg_acq<T: Copy>(dst: *mut T, old: T, new: T) -> (T, bool); + pub fn atomic_cxchg_rel<T: Copy>(dst: *mut T, old: T, new: T) -> (T, bool); + pub fn atomic_cxchg_acqrel<T: Copy>(dst: *mut T, old: T, new: T) -> (T, bool); + pub fn atomic_cxchg_relaxed<T: Copy>(dst: *mut T, old: T, new: T) -> (T, bool); + pub fn atomic_cxchgweak<T: Copy>(dst: *mut T, old: T, new: T) -> (T, bool); + pub fn atomic_cxchgweak_acq<T: Copy>(dst: *mut T, old: T, new: T) -> (T, bool); + pub fn atomic_cxchgweak_rel<T: Copy>(dst: *mut T, old: T, new: T) -> (T, bool); + pub fn atomic_cxchgweak_acqrel<T: Copy>(dst: *mut T, old: T, new: T) -> (T, bool); + pub fn atomic_cxchgweak_relaxed<T: Copy>(dst: *mut T, old: T, new: T) -> (T, bool); +} + +fn main() -> u32 { + unsafe { + let mut src = -7i8; + + let result = atomic_cxchg(&mut src, -7, 9); + if result.0 != -7 || !result.1 || src != 9 { + return 1; + } + + let result = atomic_cxchg(&mut src, 3, 11); + if result.0 != 9 || result.1 || src != 9 { + return 1; + } + + let result = atomic_cxchgweak(&mut src, 3, 11); + if result.0 != 9 || result.1 || src != 9 { + return 1; + } + + // Retry weak compare-exchange when it fails spuriously. + loop { + let result = atomic_cxchgweak(&mut src, 9, -7); + if result.0 != 9 { + return 1; + } + if result.1 { + if src != -7 { + return 1; + } + break; + } + if src != 9 { + return 1; + } + } + + let result = atomic_cxchg_acq(&mut src, -7, 9); + if result.0 != -7 || !result.1 || src != 9 { + return 1; + } + + let result = atomic_cxchg_acq(&mut src, 3, 11); + if result.0 != 9 || result.1 || src != 9 { + return 1; + } + + let result = atomic_cxchgweak_acq(&mut src, 3, 11); + if result.0 != 9 || result.1 || src != 9 { + return 1; + } + + loop { + let result = atomic_cxchgweak_acq(&mut src, 9, -7); + if result.0 != 9 { + return 1; + } + if result.1 { + if src != -7 { + return 1; + } + break; + } + if src != 9 { + return 1; + } + } + + let result = atomic_cxchg_rel(&mut src, -7, 9); + if result.0 != -7 || !result.1 || src != 9 { + return 1; + } + + let result = atomic_cxchg_rel(&mut src, 3, 11); + if result.0 != 9 || result.1 || src != 9 { + return 1; + } + + let result = atomic_cxchgweak_rel(&mut src, 3, 11); + if result.0 != 9 || result.1 || src != 9 { + return 1; + } + + loop { + let result = atomic_cxchgweak_rel(&mut src, 9, -7); + if result.0 != 9 { + return 1; + } + if result.1 { + if src != -7 { + return 1; + } + break; + } + if src != 9 { + return 1; + } + } + + let result = atomic_cxchg_acqrel(&mut src, -7, 9); + if result.0 != -7 || !result.1 || src != 9 { + return 1; + } + + let result = atomic_cxchg_acqrel(&mut src, 3, 11); + if result.0 != 9 || result.1 || src != 9 { + return 1; + } + + let result = atomic_cxchgweak_acqrel(&mut src, 3, 11); + if result.0 != 9 || result.1 || src != 9 { + return 1; + } + + loop { + let result = atomic_cxchgweak_acqrel(&mut src, 9, -7); + if result.0 != 9 { + return 1; + } + if result.1 { + if src != -7 { + return 1; + } + break; + } + if src != 9 { + return 1; + } + } + + let result = atomic_cxchg_relaxed(&mut src, -7, 9); + if result.0 != -7 || !result.1 || src != 9 { + return 1; + } + + let result = atomic_cxchg_relaxed(&mut src, 3, 11); + if result.0 != 9 || result.1 || src != 9 { + return 1; + } + + let result = atomic_cxchgweak_relaxed(&mut src, 3, 11); + if result.0 != 9 || result.1 || src != 9 { + return 1; + } + + loop { + let result = atomic_cxchgweak_relaxed(&mut src, 9, -7); + if result.0 != 9 { + return 1; + } + if result.1 { + if src != -7 { + return 1; + } + break; + } + if src != 9 { + return 1; + } + } + } + + 0 +}
