mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #92671 - WaffleLapkin:atomic_from_mut_unique_ref, r=m-ou-se

Browse Source 
Make `Atomic*::from_mut` return `&mut Atomic*`

```rust
impl Atomic* {
    pub fn from_mut(v: &mut bool) -> &mut Self;
    //                               ^^^^---- previously was just a &
}
```

This PR makes `from_mut` atomic methods tracked in #76314 return unique references to atomic types, instead of shared ones. This makes `from_mut` and `get_mut` inverses of each other, allowing to undo either of them by the other.

r? `@RalfJung`
(as Ralf was [concerned](https://github.com/rust-lang/rust/issues/76314#issuecomment-955062593) about this)
This commit is contained in:
Matthias Krüger 2022-01-09 13:38:33 +01:00 committed by GitHub
commit 0871a38adf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 6 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
library/core/src/sync/atomic.rs
View File

@ -333,10 +333,10 @@ pub fn get_mut(&mut self) -> &mut bool {
#[inline] #[inline]
#[cfg(target_has_atomic_equal_alignment = "8")] #[cfg(target_has_atomic_equal_alignment = "8")]
#[unstable(feature = "atomic_from_mut", issue = "76314")] #[unstable(feature = "atomic_from_mut", issue = "76314")]
pub fn from_mut(v: &mut bool) -> &Self { pub fn from_mut(v: &mut bool) -> &mut Self {
// SAFETY: the mutable reference guarantees unique ownership, and // SAFETY: the mutable reference guarantees unique ownership, and
// alignment of both `bool` and `Self` is 1. // alignment of both `bool` and `Self` is 1.
unsafe { &*(v as *mut bool as *mut Self) } unsafe { &mut *(v as *mut bool as *mut Self) }
} }
/// Consumes the atomic and returns the contained value. /// Consumes the atomic and returns the contained value.
@ -934,14 +934,14 @@ pub fn get_mut(&mut self) -> &mut *mut T {
#[inline] #[inline]
#[cfg(target_has_atomic_equal_alignment = "ptr")] #[cfg(target_has_atomic_equal_alignment = "ptr")]
#[unstable(feature = "atomic_from_mut", issue = "76314")] #[unstable(feature = "atomic_from_mut", issue = "76314")]
pub fn from_mut(v: &mut *mut T) -> &Self { pub fn from_mut(v: &mut *mut T) -> &mut Self {
use crate::mem::align_of; use crate::mem::align_of;
let [] = [(); align_of::<AtomicPtr<()>>() - align_of::<*mut ()>()]; let [] = [(); align_of::<AtomicPtr<()>>() - align_of::<*mut ()>()];
// SAFETY: // SAFETY:
// - the mutable reference guarantees unique ownership. // - the mutable reference guarantees unique ownership.
// - the alignment of `*mut T` and `Self` is the same on all platforms // - the alignment of `*mut T` and `Self` is the same on all platforms
// supported by rust, as verified above. // supported by rust, as verified above.
unsafe { &*(v as *mut *mut T as *mut Self) } unsafe { &mut *(v as *mut *mut T as *mut Self) }
} }
/// Consumes the atomic and returns the contained value. /// Consumes the atomic and returns the contained value.
@ -1447,14 +1447,14 @@ pub fn get_mut(&mut self) -> &mut $int_type {
#[inline] #[inline]
#[$cfg_align] #[$cfg_align]
#[unstable(feature = "atomic_from_mut", issue = "76314")] #[unstable(feature = "atomic_from_mut", issue = "76314")]
pub fn from_mut(v: &mut $int_type) -> &Self { pub fn from_mut(v: &mut $int_type) -> &mut Self {
use crate::mem::align_of; use crate::mem::align_of;
let [] = [(); align_of::<Self>() - align_of::<$int_type>()]; let [] = [(); align_of::<Self>() - align_of::<$int_type>()];
// SAFETY: // SAFETY:
// - the mutable reference guarantees unique ownership. // - the mutable reference guarantees unique ownership.
// - the alignment of `$int_type` and `Self` is the // - the alignment of `$int_type` and `Self` is the
// same, as promised by $cfg_align and verified above. // same, as promised by $cfg_align and verified above.
unsafe { &*(v as *mut $int_type as *mut Self) } unsafe { &mut *(v as *mut $int_type as *mut Self) }
} }
/// Consumes the atomic and returns the contained value. /// Consumes the atomic and returns the contained value.