Skip to content

Commit 9a94c72

Browse files
taiki-etaiki-e
committed
fuzzy_provenance_casts and lossy_provenance_casts has been merged as implicit_provenance_casts
1 parent 88c1344 commit 9a94c72

10 files changed

Lines changed: 63 additions & 46 deletions

File tree

‎src/imp/atomic128/aarch64.rs‎

Lines changed: 20 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -171,6 +171,8 @@ mod test_detect_auxv;
171171
use core::arch::asm;
172172
use core::sync::atomic::Ordering;
173173

174+
#[cfg(portable_atomic_no_strict_provenance)]
175+
use crate::utils::ptr::PtrExt as _;
174176
use crate::utils::{Pair, U128};
175177

176178
#[cfg(any(
@@ -645,7 +647,7 @@ cfg_sel!({
645647
))]
646648
#[inline]
647649
unsafe fn _atomic_load_ldp(src: *mut u128, order: Ordering) -> u128 {
648-
debug_assert!(src as usize % 16 == 0);
650+
debug_assert!(src.addr() % 16 == 0);
649651
debug_assert_lse2!();
650652

651653
// SAFETY: the caller must guarantee that `dst` is valid for reads,
@@ -712,7 +714,7 @@ unsafe fn _atomic_load_ldp(src: *mut u128, order: Ordering) -> u128 {
712714
))]
713715
#[inline]
714716
unsafe fn _atomic_load_ldiapp(src: *mut u128, order: Ordering) -> u128 {
715-
debug_assert!(src as usize % 16 == 0);
717+
debug_assert!(src.addr() % 16 == 0);
716718
debug_assert_lse2!();
717719
debug_assert_rcpc3!();
718720

@@ -785,7 +787,7 @@ unsafe fn _atomic_load_ldiapp(src: *mut u128, order: Ordering) -> u128 {
785787
#[cfg(any(target_feature = "lse", portable_atomic_target_feature = "lse"))]
786788
#[inline]
787789
unsafe fn _atomic_load_casp(src: *mut u128, order: Ordering) -> u128 {
788-
debug_assert!(src as usize % 16 == 0);
790+
debug_assert!(src.addr() % 16 == 0);
789791
debug_assert_lse!();
790792

791793
// SAFETY: the caller must uphold the safety contract.
@@ -824,7 +826,7 @@ unsafe fn _atomic_load_casp(src: *mut u128, order: Ordering) -> u128 {
824826
))]
825827
#[inline]
826828
unsafe fn _atomic_load_ldxp_stxp(src: *mut u128, order: Ordering) -> u128 {
827-
debug_assert!(src as usize % 16 == 0);
829+
debug_assert!(src.addr() % 16 == 0);
828830

829831
// SAFETY: the caller must uphold the safety contract.
830832
unsafe {
@@ -1061,7 +1063,7 @@ cfg_sel!({
10611063
))]
10621064
#[inline]
10631065
unsafe fn _atomic_store_stp(dst: *mut u128, val: u128, order: Ordering) {
1064-
debug_assert!(dst as usize % 16 == 0);
1066+
debug_assert!(dst.addr() % 16 == 0);
10651067
debug_assert_lse2!();
10661068

10671069
// SAFETY: the caller must guarantee that `dst` is valid for writes,
@@ -1136,7 +1138,7 @@ unsafe fn _atomic_store_stp(dst: *mut u128, val: u128, order: Ordering) {
11361138
))]
11371139
#[inline]
11381140
unsafe fn _atomic_store_stilp(dst: *mut u128, val: u128, order: Ordering) {
1139-
debug_assert!(dst as usize % 16 == 0);
1141+
debug_assert!(dst.addr() % 16 == 0);
11401142
debug_assert_lse2!();
11411143
debug_assert_rcpc3!();
11421144

@@ -1195,7 +1197,7 @@ unsafe fn _atomic_store_stilp(dst: *mut u128, val: u128, order: Ordering) {
11951197
))]
11961198
#[inline]
11971199
unsafe fn _atomic_store_ldxp_stxp(dst: *mut u128, val: u128, order: Ordering) {
1198-
debug_assert!(dst as usize % 16 == 0);
1200+
debug_assert!(dst.addr() % 16 == 0);
11991201

12001202
// SAFETY: the caller must uphold the safety contract.
12011203
unsafe {
@@ -1430,7 +1432,7 @@ unsafe fn _atomic_compare_exchange_casp(
14301432
success: Ordering,
14311433
failure: Ordering,
14321434
) -> u128 {
1433-
debug_assert!(dst as usize % 16 == 0);
1435+
debug_assert!(dst.addr() % 16 == 0);
14341436
debug_assert_lse!();
14351437
let order = crate::utils::upgrade_success_ordering(success, failure);
14361438

@@ -1472,7 +1474,7 @@ unsafe fn _atomic_compare_exchange_ldxp_stxp(
14721474
success: Ordering,
14731475
failure: Ordering,
14741476
) -> u128 {
1475-
debug_assert!(dst as usize % 16 == 0);
1477+
debug_assert!(dst.addr() % 16 == 0);
14761478
let order = crate::utils::upgrade_success_ordering(success, failure);
14771479

14781480
// SAFETY: the caller must guarantee that `dst` is valid for both writes and
@@ -1581,7 +1583,7 @@ cfg_sel!({
15811583
))]
15821584
#[inline]
15831585
unsafe fn _atomic_swap_swpp(dst: *mut u128, val: u128, order: Ordering) -> u128 {
1584-
debug_assert!(dst as usize % 16 == 0);
1586+
debug_assert!(dst.addr() % 16 == 0);
15851587
debug_assert_lse128!();
15861588

15871589
// SAFETY: the caller must guarantee that `dst` is valid for both writes and
@@ -1632,7 +1634,7 @@ unsafe fn _atomic_swap_swpp(dst: *mut u128, val: u128, order: Ordering) -> u128
16321634
#[cfg(any(target_feature = "lse", portable_atomic_target_feature = "lse"))]
16331635
#[inline]
16341636
unsafe fn _atomic_swap_casp(dst: *mut u128, val: u128, order: Ordering) -> u128 {
1635-
debug_assert!(dst as usize % 16 == 0);
1637+
debug_assert!(dst.addr() % 16 == 0);
16361638
debug_assert_lse!();
16371639

16381640
// SAFETY: the caller must uphold the safety contract.
@@ -1685,7 +1687,7 @@ unsafe fn _atomic_swap_casp(dst: *mut u128, val: u128, order: Ordering) -> u128
16851687
))]
16861688
#[inline]
16871689
unsafe fn _atomic_swap_ldxp_stxp(dst: *mut u128, val: u128, order: Ordering) -> u128 {
1688-
debug_assert!(dst as usize % 16 == 0);
1690+
debug_assert!(dst.addr() % 16 == 0);
16891691

16901692
// SAFETY: the caller must uphold the safety contract.
16911693
unsafe {
@@ -1739,7 +1741,7 @@ macro_rules! atomic_rmw_ll_sc_3 {
17391741
))]
17401742
#[inline]
17411743
unsafe fn $name(dst: *mut u128, val: u128, order: Ordering) -> u128 {
1742-
debug_assert!(dst as usize % 16 == 0);
1744+
debug_assert!(dst.addr() % 16 == 0);
17431745
// SAFETY: the caller must uphold the safety contract.
17441746
unsafe {
17451747
let val = U128 { whole: val };
@@ -1791,7 +1793,7 @@ macro_rules! atomic_rmw_cas_3 {
17911793
#[cfg(any(target_feature = "lse", portable_atomic_target_feature = "lse"))]
17921794
#[inline]
17931795
unsafe fn $name(dst: *mut u128, val: u128, order: Ordering) -> u128 {
1794-
debug_assert!(dst as usize % 16 == 0);
1796+
debug_assert!(dst.addr() % 16 == 0);
17951797
debug_assert_lse!();
17961798
// SAFETY: the caller must uphold the safety contract.
17971799
// cfg guarantee that the CPU supports FEAT_LSE.
@@ -1863,7 +1865,7 @@ macro_rules! atomic_rmw_ll_sc_2 {
18631865
))]
18641866
#[inline]
18651867
unsafe fn $name(dst: *mut u128, order: Ordering) -> u128 {
1866-
debug_assert!(dst as usize % 16 == 0);
1868+
debug_assert!(dst.addr() % 16 == 0);
18671869
// SAFETY: the caller must uphold the safety contract.
18681870
unsafe {
18691871
let (mut prev_lo, mut prev_hi);
@@ -1911,7 +1913,7 @@ macro_rules! atomic_rmw_cas_2 {
19111913
#[cfg(any(target_feature = "lse", portable_atomic_target_feature = "lse"))]
19121914
#[inline]
19131915
unsafe fn $name(dst: *mut u128, order: Ordering) -> u128 {
1914-
debug_assert!(dst as usize % 16 == 0);
1916+
debug_assert!(dst.addr() % 16 == 0);
19151917
debug_assert_lse!();
19161918
// SAFETY: the caller must uphold the safety contract.
19171919
// cfg guarantee that the CPU supports FEAT_LSE.
@@ -1995,7 +1997,7 @@ atomic_rmw_cas_3! {
19951997
#[cfg(any(target_feature = "lse128", portable_atomic_target_feature = "lse128"))]
19961998
#[inline]
19971999
unsafe fn atomic_and(dst: *mut u128, val: u128, order: Ordering) -> u128 {
1998-
debug_assert!(dst as usize % 16 == 0);
2000+
debug_assert!(dst.addr() % 16 == 0);
19992001

20002002
// SAFETY: the caller must guarantee that `dst` is valid for both writes and
20012003
// reads, 16-byte aligned, that there are no concurrent non-atomic operations,
@@ -2071,7 +2073,7 @@ atomic_rmw_cas_3! {
20712073
#[cfg(any(target_feature = "lse128", portable_atomic_target_feature = "lse128"))]
20722074
#[inline]
20732075
unsafe fn atomic_or(dst: *mut u128, val: u128, order: Ordering) -> u128 {
2074-
debug_assert!(dst as usize % 16 == 0);
2076+
debug_assert!(dst.addr() % 16 == 0);
20752077

20762078
// SAFETY: the caller must guarantee that `dst` is valid for both writes and
20772079
// reads, 16-byte aligned, that there are no concurrent non-atomic operations,

‎src/imp/atomic128/intrinsics.rs‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -122,7 +122,9 @@ unsafe fn atomic_compare_exchange(
122122
success: Ordering,
123123
failure: Ordering,
124124
) -> (u128, bool) {
125-
debug_assert!(dst as usize % 16 == 0);
125+
#[cfg(portable_atomic_no_strict_provenance)]
126+
use crate::utils::ptr::PtrExt as _;
127+
debug_assert!(dst.addr() % 16 == 0);
126128
#[cfg(not(target_feature = "cmpxchg16b"))]
127129
{
128130
debug_assert!(detect::detect().cmpxchg16b());

‎src/imp/atomic128/powerpc64.rs‎

Lines changed: 9 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -94,6 +94,8 @@ mod detect;
9494

9595
use core::{arch::asm, sync::atomic::Ordering};
9696

97+
#[cfg(portable_atomic_no_strict_provenance)]
98+
use crate::utils::ptr::PtrExt as _;
9799
use crate::utils::{Pair, U128};
98100

99101
macro_rules! debug_assert_pwr8 {
@@ -238,7 +240,7 @@ unsafe fn atomic_load(src: *mut u128, order: Ordering) -> u128 {
238240
}
239241
#[inline]
240242
unsafe fn atomic_load_pwr8(src: *mut u128, order: Ordering) -> u128 {
241-
debug_assert!(src as usize % 16 == 0);
243+
debug_assert!(src.addr() % 16 == 0);
242244
debug_assert_pwr8!();
243245
let (out_hi, out_lo);
244246

@@ -348,7 +350,7 @@ unsafe fn atomic_store(dst: *mut u128, val: u128, order: Ordering) {
348350
}
349351
#[inline]
350352
unsafe fn atomic_store_pwr8(dst: *mut u128, val: u128, order: Ordering) {
351-
debug_assert!(dst as usize % 16 == 0);
353+
debug_assert!(dst.addr() % 16 == 0);
352354
debug_assert_pwr8!();
353355
let val = U128 { whole: val };
354356

@@ -477,7 +479,7 @@ unsafe fn atomic_compare_exchange_pwr8(
477479
success: Ordering,
478480
failure: Ordering,
479481
) -> (u128, bool) {
480-
debug_assert!(dst as usize % 16 == 0);
482+
debug_assert!(dst.addr() % 16 == 0);
481483
debug_assert_pwr8!();
482484
let old = U128 { whole: old };
483485
let new = U128 { whole: new };
@@ -563,7 +565,7 @@ unsafe fn atomic_compare_exchange_weak_pwr8(
563565
success: Ordering,
564566
failure: Ordering,
565567
) -> (u128, bool) {
566-
debug_assert!(dst as usize % 16 == 0);
568+
debug_assert!(dst.addr() % 16 == 0);
567569
debug_assert_pwr8!();
568570
let old = U128 { whole: old };
569571
let new = U128 { whole: new };
@@ -615,7 +617,7 @@ unsafe fn atomic_compare_exchange_weak_pwr8(
615617
// Do not use atomic_rmw_ll_sc_3 because it needs extra MR to implement swap.
616618
#[inline]
617619
unsafe fn atomic_swap_pwr8(dst: *mut u128, val: u128, order: Ordering) -> u128 {
618-
debug_assert!(dst as usize % 16 == 0);
620+
debug_assert!(dst.addr() % 16 == 0);
619621
debug_assert_pwr8!();
620622
let val = U128 { whole: val };
621623
let (mut prev_hi, mut prev_lo);
@@ -661,7 +663,7 @@ macro_rules! atomic_rmw_ll_sc_3 {
661663
($name:ident, [$($reg:tt)*], $($op:tt)*) => {
662664
#[inline]
663665
unsafe fn $name(dst: *mut u128, val: u128, order: Ordering) -> u128 {
664-
debug_assert!(dst as usize % 16 == 0);
666+
debug_assert!(dst.addr() % 16 == 0);
665667
debug_assert_pwr8!();
666668
let val = U128 { whole: val };
667669
let (mut prev_hi, mut prev_lo);
@@ -711,7 +713,7 @@ macro_rules! atomic_rmw_ll_sc_2 {
711713
($name:ident, [$($reg:tt)*], $($op:tt)*) => {
712714
#[inline]
713715
unsafe fn $name(dst: *mut u128, order: Ordering) -> u128 {
714-
debug_assert!(dst as usize % 16 == 0);
716+
debug_assert!(dst.addr() % 16 == 0);
715717
debug_assert_pwr8!();
716718
let (mut prev_hi, mut prev_lo);
717719

‎src/imp/atomic128/riscv64.rs‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,8 @@ mod detect;
4040
use core::arch::asm;
4141
use core::sync::atomic::Ordering;
4242

43+
#[cfg(portable_atomic_no_strict_provenance)]
44+
use crate::utils::ptr::PtrExt as _;
4345
use crate::utils::{Pair, U128};
4446

4547
macro_rules! debug_assert_zacas {
@@ -156,7 +158,7 @@ unsafe fn atomic_load(src: *mut u128, order: Ordering) -> u128 {
156158
}
157159
#[inline]
158160
unsafe fn atomic_load_zacas(src: *mut u128, order: Ordering) -> u128 {
159-
debug_assert!(src as usize % 16 == 0);
161+
debug_assert!(src.addr() % 16 == 0);
160162
debug_assert_zacas!();
161163
let (out_lo, out_hi);
162164

@@ -296,7 +298,7 @@ unsafe fn atomic_compare_exchange_zacas(
296298
success: Ordering,
297299
failure: Ordering,
298300
) -> (u128, bool) {
299-
debug_assert!(dst as usize % 16 == 0);
301+
debug_assert!(dst.addr() % 16 == 0);
300302
debug_assert_zacas!();
301303
let order = crate::utils::upgrade_success_ordering(success, failure);
302304
let old = U128 { whole: old };

‎src/imp/atomic128/s390x.rs‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,8 @@ include!("macros.rs");
3333

3434
use core::{arch::asm, sync::atomic::Ordering};
3535

36+
#[cfg(portable_atomic_no_strict_provenance)]
37+
use crate::utils::ptr::PtrExt as _;
3638
use crate::utils::{Pair, U128};
3739

3840
// bcr 14,0 requires fast-BCR-serialization facility added in arch9 (z196).
@@ -105,7 +107,7 @@ fn extract_cc(r: i64) -> bool {
105107

106108
#[inline]
107109
unsafe fn atomic_load(src: *mut u128, _order: Ordering) -> u128 {
108-
debug_assert!(src as usize % 16 == 0);
110+
debug_assert!(src.addr() % 16 == 0);
109111
let (out_hi, out_lo);
110112

111113
// SAFETY: the caller must uphold the safety contract.
@@ -125,7 +127,7 @@ unsafe fn atomic_load(src: *mut u128, _order: Ordering) -> u128 {
125127

126128
#[inline]
127129
unsafe fn atomic_store(dst: *mut u128, val: u128, order: Ordering) {
128-
debug_assert!(dst as usize % 16 == 0);
130+
debug_assert!(dst.addr() % 16 == 0);
129131
let val = U128 { whole: val };
130132

131133
// SAFETY: the caller must uphold the safety contract.
@@ -160,7 +162,7 @@ unsafe fn atomic_compare_exchange(
160162
_success: Ordering,
161163
_failure: Ordering,
162164
) -> Result<u128, u128> {
163-
debug_assert!(dst as usize % 16 == 0);
165+
debug_assert!(dst.addr() % 16 == 0);
164166
let old = U128 { whole: old };
165167
let new = U128 { whole: new };
166168
let (prev_hi, prev_lo);
@@ -243,7 +245,7 @@ where
243245

244246
#[inline]
245247
unsafe fn atomic_swap(dst: *mut u128, val: u128, _order: Ordering) -> u128 {
246-
debug_assert!(dst as usize % 16 == 0);
248+
debug_assert!(dst.addr() % 16 == 0);
247249
let val = U128 { whole: val };
248250
let (mut prev_hi, mut prev_lo);
249251

@@ -287,7 +289,7 @@ macro_rules! atomic_rmw_cas_3 {
287289
($name:ident, [$($reg:tt)*], $($op:tt)*) => {
288290
#[inline]
289291
unsafe fn $name(dst: *mut u128, val: u128, _order: Ordering) -> u128 {
290-
debug_assert!(dst as usize % 16 == 0);
292+
debug_assert!(dst.addr() % 16 == 0);
291293
let val = U128 { whole: val };
292294
let (mut prev_hi, mut prev_lo);
293295

@@ -330,7 +332,7 @@ macro_rules! atomic_rmw_cas_2 {
330332
($name:ident, [$($reg:tt)*], $($op:tt)*) => {
331333
#[inline]
332334
unsafe fn $name(dst: *mut u128, _order: Ordering) -> u128 {
333-
debug_assert!(dst as usize % 16 == 0);
335+
debug_assert!(dst.addr() % 16 == 0);
334336
let (mut prev_hi, mut prev_lo);
335337

336338
// SAFETY: the caller must uphold the safety contract.

0 commit comments

Comments
 (0)