make atomic operations const - #160079

RalfJung · 2026-07-28T14:28:50Z

In a similar vein to #159094, it makes sense to make these const fn so that code can be shared between compile-time and run-time even if the runtime version has to deal with concurrency.

This constifies the following:

// core::sync::atomic

impl AtomicBool {
    pub const fn get_mut(&mut self) -> &mut bool;
    pub const fn from_mut(v: &mut bool) -> &mut Self;
    pub const fn get_mut_slice(this: &mut [Self]) -> &mut [bool];
    pub const fn from_mut_slice(v: &mut [bool]) -> &mut [Self];
    pub const fn load(&self, order: Ordering) -> bool;
    pub const fn store(&self, val: bool, order: Ordering);
    pub const fn swap(&self, val: bool, order: Ordering) -> bool;
    pub const fn compare_and_swap(&self, current: bool, new: bool, order: Ordering) -> bool;
    pub const fn compare_exchange(
        &self,
        current: bool,
        new: bool,
        success: Ordering,
        failure: Ordering,
    ) -> Result<bool, bool>;
    pub const fn compare_exchange_weak(
        &self,
        current: bool,
        new: bool,
        success: Ordering,
        failure: Ordering,
    ) -> Result<bool, bool>;
    pub const fn fetch_and(&self, val: bool, order: Ordering) -> bool;
    pub const fn fetch_nand(&self, val: bool, order: Ordering) -> bool;
    pub const fn fetch_or(&self, val: bool, order: Ordering) -> bool;
    pub const fn fetch_xor(&self, val: bool, order: Ordering) -> bool;
    pub const fn fetch_not(&self, order: Ordering) -> bool;
}

impl AtomicPtr<T> {
    pub const fn get_mut(&mut self) -> &mut *mut T;
    pub const fn from_mut(v: &mut *mut T) -> &mut Self;
    pub const fn get_mut_slice(this: &mut [Self]) -> &mut [*mut T];
    pub const fn from_mut_slice(v: &mut [*mut T]) -> &mut [Self];
    pub const fn load(&self, order: Ordering) -> *mut T;
    pub const fn store(&self, ptr: *mut T, order: Ordering);
    pub const fn swap(&self, ptr: *mut T, order: Ordering) -> *mut T;
}

impl Atomic$Int {
    pub const fn get_mut(&mut self) -> &mut $int_type;
    pub const fn from_mut(v: &mut $int_type) -> &mut Self;
    pub const fn get_mut_slice(this: &mut [Self]) -> &mut [$int_type];
    pub const fn from_mut_slice(v: &mut [$int_type]) -> &mut [Self];
    pub const fn load(&self, order: Ordering) -> $int_type;
    pub const fn store(&self, val: $int_type, order: Ordering);
    pub const fn swap(&self, val: $int_type, order: Ordering) -> $int_type;
    pub const fn compare_and_swap(&self,
                                    current: $int_type,
                                    new: $int_type,
                                    order: Ordering) -> $int_type;
    pub const fn compare_exchange(&self,
                                    current: $int_type,
                                    new: $int_type,
                                    success: Ordering,
                                    failure: Ordering) -> Result<$int_type, $int_type>;
    pub const fn compare_exchange_weak(&self,
                                         current: $int_type,
                                         new: $int_type,
                                         success: Ordering,
                                         failure: Ordering) -> Result<$int_type, $int_type>;
    pub const fn fetch_add(&self, val: $int_type, order: Ordering) -> $int_type;
    pub const fn fetch_sub(&self, val: $int_type, order: Ordering) -> $int_type;
    pub const fn fetch_and(&self, val: $int_type, order: Ordering) -> $int_type;
    pub const fn fetch_nand(&self, val: $int_type, order: Ordering) -> $int_type;
    pub const fn fetch_or(&self, val: $int_type, order: Ordering) -> $int_type;
    pub const fn fetch_xor(&self, val: $int_type, order: Ordering) -> $int_type;
    pub const fn fetch_max(&self, val: $int_type, order: Ordering) -> $int_type;
    pub const fn fetch_min(&self, val: $int_type, order: Ordering) -> $int_type;
}

pub const fn fence(order: Ordering);
pub const fn compiler_fence(order: Ordering);

However, this excludes the fetch_* and compare_* operations on AtomicPtr, as that kind of pointer arithmetic is not possible at compile time.

Tracking issue: #160078
Cc @rust-lang/wg-const-eval @rust-lang/opsem

rustbot · 2026-07-28T14:28:54Z

Some changes occurred to the intrinsics. Make sure the CTFE / Miri interpreter
gets adapted for the changes, if necessary.

cc @rust-lang/miri, @oli-obk, @lcnr

miri is developed in its own repository. If the Miri part of this change can be broken out, consider making this change to rust-lang/miri instead. However, if Miri needs adjusting for rustc changes, just ignore this message.

cc @rust-lang/miri

Some changes occurred to the CTFE machinery

cc @oli-obk, @lcnr

Some changes occurred to the CTFE / Miri interpreter

cc @rust-lang/miri

rustbot · 2026-07-28T14:28:56Z

r? @folkertdev

rustbot has assigned @folkertdev.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

Why was this reviewer chosen?

The reviewer was selected based on:

Owners of files modified in this PR: compiler, mir
compiler, mir expanded to 74 candidates
Random selection from 16 candidates

folkertdev

@bors r+

View changes since this review

rust-bors · 2026-07-31T17:06:06Z

📌 Commit aa1b09a has been approved by folkertdev

It is now in the queue for this repository.

make atomic operations const In a similar vein to rust-lang#159094, it makes sense to make these `const fn` so that code can be shared between compile-time and run-time even if the runtime version has to deal with concurrency. This constifies the following: ```rust // core::sync::atomic impl AtomicBool { pub const fn get_mut(&mut self) -> &mut bool; pub const fn from_mut(v: &mut bool) -> &mut Self; pub const fn get_mut_slice(this: &mut [Self]) -> &mut [bool]; pub const fn from_mut_slice(v: &mut [bool]) -> &mut [Self]; pub const fn load(&self, order: Ordering) -> bool; pub const fn store(&self, val: bool, order: Ordering); pub const fn swap(&self, val: bool, order: Ordering) -> bool; pub const fn compare_and_swap(&self, current: bool, new: bool, order: Ordering) -> bool; pub const fn compare_exchange( &self, current: bool, new: bool, success: Ordering, failure: Ordering, ) -> Result<bool, bool>; pub const fn compare_exchange_weak( &self, current: bool, new: bool, success: Ordering, failure: Ordering, ) -> Result<bool, bool>; pub const fn fetch_and(&self, val: bool, order: Ordering) -> bool; pub const fn fetch_nand(&self, val: bool, order: Ordering) -> bool; pub const fn fetch_or(&self, val: bool, order: Ordering) -> bool; pub const fn fetch_xor(&self, val: bool, order: Ordering) -> bool; pub const fn fetch_not(&self, order: Ordering) -> bool; } impl AtomicPtr<T> { pub const fn get_mut(&mut self) -> &mut *mut T; pub const fn from_mut(v: &mut *mut T) -> &mut Self; pub const fn get_mut_slice(this: &mut [Self]) -> &mut [*mut T]; pub const fn from_mut_slice(v: &mut [*mut T]) -> &mut [Self]; pub const fn load(&self, order: Ordering) -> *mut T; pub const fn store(&self, ptr: *mut T, order: Ordering); pub const fn swap(&self, ptr: *mut T, order: Ordering) -> *mut T; } impl Atomic$Int { pub const fn get_mut(&mut self) -> &mut $int_type; pub const fn from_mut(v: &mut $int_type) -> &mut Self; pub const fn get_mut_slice(this: &mut [Self]) -> &mut [$int_type]; pub const fn from_mut_slice(v: &mut [$int_type]) -> &mut [Self]; pub const fn load(&self, order: Ordering) -> $int_type; pub const fn store(&self, val: $int_type, order: Ordering); pub const fn swap(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn compare_and_swap(&self, current: $int_type, new: $int_type, order: Ordering) -> $int_type; pub const fn compare_exchange(&self, current: $int_type, new: $int_type, success: Ordering, failure: Ordering) -> Result<$int_type, $int_type>; pub const fn compare_exchange_weak(&self, current: $int_type, new: $int_type, success: Ordering, failure: Ordering) -> Result<$int_type, $int_type>; pub const fn fetch_add(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_sub(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_and(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_nand(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_or(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_xor(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_max(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_min(&self, val: $int_type, order: Ordering) -> $int_type; } pub const fn fence(order: Ordering); pub const fn compiler_fence(order: Ordering); ``` However, this excludes the `fetch_*` and `compare_*` operations on `AtomicPtr`, as that kind of pointer arithmetic is not possible at compile time. Tracking issue: rust-lang#160078 Cc @rust-lang/wg-const-eval @rust-lang/opsem

Rollup of 14 pull requests Successful merges: - #159245 (Emit retags in codegen to support BorrowSanitizer (part 5)) - #159864 (Report "capacity overflow" for oversized Rc<[T]>/Arc<[T]>) - #160079 (make atomic operations const) - #160124 (Structurally prevent zero-count `BackendRepr::SimdVector`s) - #160162 (Make `#[fundamental]` only apply to the first argument of `Box`) - #160210 (Remove an outdated FIXME) - #160282 (Improve diagnostic for patterns in function pointer types) - #157928 (Eagerly fetch typeck results when linting) - #159672 (Improve suggestions when multiples tuples implement the same trait) - #159861 (Add documentation for the `non_exhaustive` attribute) - #159907 (Fix `hidden_glob_reexports` in `rustc_ast`) - #159998 (Align expect messages with guidance) - #160145 (Expand checks for register_tool) - #160307 (Update `minifier` version to `0.4.0`)

Rollup merge of #160079 - RalfJung:const-atomic, r=folkertdev make atomic operations const In a similar vein to #159094, it makes sense to make these `const fn` so that code can be shared between compile-time and run-time even if the runtime version has to deal with concurrency. This constifies the following: ```rust // core::sync::atomic impl AtomicBool { pub const fn get_mut(&mut self) -> &mut bool; pub const fn from_mut(v: &mut bool) -> &mut Self; pub const fn get_mut_slice(this: &mut [Self]) -> &mut [bool]; pub const fn from_mut_slice(v: &mut [bool]) -> &mut [Self]; pub const fn load(&self, order: Ordering) -> bool; pub const fn store(&self, val: bool, order: Ordering); pub const fn swap(&self, val: bool, order: Ordering) -> bool; pub const fn compare_and_swap(&self, current: bool, new: bool, order: Ordering) -> bool; pub const fn compare_exchange( &self, current: bool, new: bool, success: Ordering, failure: Ordering, ) -> Result<bool, bool>; pub const fn compare_exchange_weak( &self, current: bool, new: bool, success: Ordering, failure: Ordering, ) -> Result<bool, bool>; pub const fn fetch_and(&self, val: bool, order: Ordering) -> bool; pub const fn fetch_nand(&self, val: bool, order: Ordering) -> bool; pub const fn fetch_or(&self, val: bool, order: Ordering) -> bool; pub const fn fetch_xor(&self, val: bool, order: Ordering) -> bool; pub const fn fetch_not(&self, order: Ordering) -> bool; } impl AtomicPtr<T> { pub const fn get_mut(&mut self) -> &mut *mut T; pub const fn from_mut(v: &mut *mut T) -> &mut Self; pub const fn get_mut_slice(this: &mut [Self]) -> &mut [*mut T]; pub const fn from_mut_slice(v: &mut [*mut T]) -> &mut [Self]; pub const fn load(&self, order: Ordering) -> *mut T; pub const fn store(&self, ptr: *mut T, order: Ordering); pub const fn swap(&self, ptr: *mut T, order: Ordering) -> *mut T; } impl Atomic$Int { pub const fn get_mut(&mut self) -> &mut $int_type; pub const fn from_mut(v: &mut $int_type) -> &mut Self; pub const fn get_mut_slice(this: &mut [Self]) -> &mut [$int_type]; pub const fn from_mut_slice(v: &mut [$int_type]) -> &mut [Self]; pub const fn load(&self, order: Ordering) -> $int_type; pub const fn store(&self, val: $int_type, order: Ordering); pub const fn swap(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn compare_and_swap(&self, current: $int_type, new: $int_type, order: Ordering) -> $int_type; pub const fn compare_exchange(&self, current: $int_type, new: $int_type, success: Ordering, failure: Ordering) -> Result<$int_type, $int_type>; pub const fn compare_exchange_weak(&self, current: $int_type, new: $int_type, success: Ordering, failure: Ordering) -> Result<$int_type, $int_type>; pub const fn fetch_add(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_sub(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_and(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_nand(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_or(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_xor(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_max(&self, val: $int_type, order: Ordering) -> $int_type; pub const fn fetch_min(&self, val: $int_type, order: Ordering) -> $int_type; } pub const fn fence(order: Ordering); pub const fn compiler_fence(order: Ordering); ``` However, this excludes the `fetch_*` and `compare_*` operations on `AtomicPtr`, as that kind of pointer arithmetic is not possible at compile time. Tracking issue: #160078 Cc @rust-lang/wg-const-eval @rust-lang/opsem

Rollup of 14 pull requests Successful merges: - rust-lang/rust#159245 (Emit retags in codegen to support BorrowSanitizer (part 5)) - rust-lang/rust#159864 (Report "capacity overflow" for oversized Rc<[T]>/Arc<[T]>) - rust-lang/rust#160079 (make atomic operations const) - rust-lang/rust#160124 (Structurally prevent zero-count `BackendRepr::SimdVector`s) - rust-lang/rust#160162 (Make `#[fundamental]` only apply to the first argument of `Box`) - rust-lang/rust#160210 (Remove an outdated FIXME) - rust-lang/rust#160282 (Improve diagnostic for patterns in function pointer types) - rust-lang/rust#157928 (Eagerly fetch typeck results when linting) - rust-lang/rust#159672 (Improve suggestions when multiples tuples implement the same trait) - rust-lang/rust#159861 (Add documentation for the `non_exhaustive` attribute) - rust-lang/rust#159907 (Fix `hidden_glob_reexports` in `rustc_ast`) - rust-lang/rust#159998 (Align expect messages with guidance) - rust-lang/rust#160145 (Expand checks for register_tool) - rust-lang/rust#160307 (Update `minifier` version to `0.4.0`)

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. T-libs Relevant to the library team, which will review and decide on the PR/issue. labels Jul 28, 2026

rustbot assigned folkertdev Jul 28, 2026

RalfJung force-pushed the const-atomic branch from 7c9e145 to 7c525fc Compare July 28, 2026 14:35

RalfJung mentioned this pull request Jul 28, 2026

Tracking Issue for const_atomic #160078

Open

4 tasks

This comment has been minimized.

Sign in to view

RalfJung force-pushed the const-atomic branch from 7c525fc to 71c8f07 Compare July 28, 2026 15:24

make atomic operations const

aa1b09a

RalfJung force-pushed the const-atomic branch from 71c8f07 to aa1b09a Compare July 28, 2026 16:47

folkertdev approved these changes Jul 31, 2026

View reviewed changes

rust-bors Bot added S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Jul 31, 2026

jhpratt mentioned this pull request Aug 1, 2026

Rollup of 16 pull requests #160308

Closed

This was referenced Aug 1, 2026

Rollup of 15 pull requests #160309

Closed

Rollup of 14 pull requests #160310

Merged

rust-bors Bot merged commit f5811a1 into rust-lang:main Aug 1, 2026
13 checks passed

rustbot added this to the 1.99.0 milestone Aug 1, 2026

RalfJung deleted the const-atomic branch August 2, 2026 16:46

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

make atomic operations const - #160079