From ec58c4786445344a21d9df152e8811b1c4e9f350 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <grigorenkopv@ya.ru>
Date: Sat, 24 Feb 2024 18:48:45 +0300
Subject: [PATCH] use `addr_of!`
---
crates/core_arch/src/x86/avx.rs | 55 +++++++++++++++--------------
crates/core_arch/src/x86/sse.rs | 18 +++++-----
crates/core_arch/src/x86/sse2.rs | 23 ++++++------
crates/core_arch/src/x86_64/sse2.rs | 3 +-
4 files changed, 51 insertions(+), 48 deletions(-)
diff --git a/crates/core_arch/src/x86/avx.rs b/crates/core_arch/src/x86/avx.rs
index a6167c7616..e550305e93 100644
--- a/crates/core_arch/src/x86/avx.rs
+++ b/crates/core_arch/src/x86/avx.rs
@@ -1432,7 +1432,7 @@ pub unsafe fn _mm256_loadu_pd(mem_addr: *const f64) -> __m256d {
let mut dst = _mm256_undefined_pd();
ptr::copy_nonoverlapping(
mem_addr as *const u8,
- &mut dst as *mut __m256d as *mut u8,
+ ptr::addr_of_mut!(dst) as *mut u8,
mem::size_of::<__m256d>(),
);
dst
@@ -1464,7 +1464,7 @@ pub unsafe fn _mm256_loadu_ps(mem_addr: *const f32) -> __m256 {
let mut dst = _mm256_undefined_ps();
ptr::copy_nonoverlapping(
mem_addr as *const u8,
- &mut dst as *mut __m256 as *mut u8,
+ ptr::addr_of_mut!(dst) as *mut u8,
mem::size_of::<__m256>(),
);
dst
@@ -1521,7 +1521,7 @@ pub unsafe fn _mm256_loadu_si256(mem_addr: *const __m256i) -> __m256i {
let mut dst = _mm256_undefined_si256();
ptr::copy_nonoverlapping(
mem_addr as *const u8,
- &mut dst as *mut __m256i as *mut u8,
+ ptr::addr_of_mut!(dst) as *mut u8,
mem::size_of::<__m256i>(),
);
dst
@@ -3065,6 +3065,7 @@ extern "C" {
#[cfg(test)]
mod tests {
use crate::hint::black_box;
+ use crate::ptr;
use stdarch_test::simd_test;
use crate::core_arch::x86::*;
@@ -3903,7 +3904,7 @@ mod tests {
#[simd_test(enable = "avx")]
unsafe fn test_mm256_load_pd() {
let a = _mm256_setr_pd(1., 2., 3., 4.);
- let p = &a as *const _ as *const f64;
+ let p = ptr::addr_of!(a) as *const f64;
let r = _mm256_load_pd(p);
let e = _mm256_setr_pd(1., 2., 3., 4.);
assert_eq_m256d(r, e);
@@ -3913,14 +3914,14 @@ mod tests {
unsafe fn test_mm256_store_pd() {
let a = _mm256_setr_pd(1., 2., 3., 4.);
let mut r = _mm256_undefined_pd();
- _mm256_store_pd(&mut r as *mut _ as *mut f64, a);
+ _mm256_store_pd(ptr::addr_of_mut!(r) as *mut f64, a);
assert_eq_m256d(r, a);
}
#[simd_test(enable = "avx")]
unsafe fn test_mm256_load_ps() {
let a = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
- let p = &a as *const _ as *const f32;
+ let p = ptr::addr_of!(a) as *const f32;
let r = _mm256_load_ps(p);
let e = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
assert_eq_m256(r, e);
@@ -3930,7 +3931,7 @@ mod tests {
unsafe fn test_mm256_store_ps() {
let a = _mm256_setr_ps(4., 3., 2., 5., 8., 9., 64., 50.);
let mut r = _mm256_undefined_ps();
- _mm256_store_ps(&mut r as *mut _ as *mut f32, a);
+ _mm256_store_ps(ptr::addr_of_mut!(r) as *mut f32, a);
assert_eq_m256(r, a);
}
@@ -3947,7 +3948,7 @@ mod tests {
unsafe fn test_mm256_storeu_pd() {
let a = _mm256_set1_pd(9.);
let mut r = _mm256_undefined_pd();
- _mm256_storeu_pd(&mut r as *mut _ as *mut f64, a);
+ _mm256_storeu_pd(ptr::addr_of_mut!(r) as *mut f64, a);
assert_eq_m256d(r, a);
}
@@ -3964,14 +3965,14 @@ mod tests {
unsafe fn test_mm256_storeu_ps() {
let a = _mm256_set1_ps(9.);
let mut r = _mm256_undefined_ps();
- _mm256_storeu_ps(&mut r as *mut _ as *mut f32, a);
+ _mm256_storeu_ps(ptr::addr_of_mut!(r) as *mut f32, a);
assert_eq_m256(r, a);
}
#[simd_test(enable = "avx")]
unsafe fn test_mm256_load_si256() {
let a = _mm256_setr_epi64x(1, 2, 3, 4);
- let p = &a as *const _;
+ let p = ptr::addr_of!(a);
let r = _mm256_load_si256(p);
let e = _mm256_setr_epi64x(1, 2, 3, 4);
assert_eq_m256i(r, e);
@@ -3981,14 +3982,14 @@ mod tests {
unsafe fn test_mm256_store_si256() {
let a = _mm256_setr_epi64x(1, 2, 3, 4);
let mut r = _mm256_undefined_si256();
- _mm256_store_si256(&mut r as *mut _, a);
+ _mm256_store_si256(ptr::addr_of_mut!(r), a);
assert_eq_m256i(r, a);
}
#[simd_test(enable = "avx")]
unsafe fn test_mm256_loadu_si256() {
let a = _mm256_setr_epi64x(1, 2, 3, 4);
- let p = &a as *const _;
+ let p = ptr::addr_of!(a);
let r = _mm256_loadu_si256(black_box(p));
let e = _mm256_setr_epi64x(1, 2, 3, 4);
assert_eq_m256i(r, e);
@@ -3998,7 +3999,7 @@ mod tests {
unsafe fn test_mm256_storeu_si256() {
let a = _mm256_set1_epi8(9);
let mut r = _mm256_undefined_si256();
- _mm256_storeu_si256(&mut r as *mut _, a);
+ _mm256_storeu_si256(ptr::addr_of_mut!(r), a);
assert_eq_m256i(r, a);
}
@@ -4017,7 +4018,7 @@ mod tests {
let mut r = _mm256_set1_pd(0.);
let mask = _mm256_setr_epi64x(0, !0, 0, !0);
let a = _mm256_setr_pd(1., 2., 3., 4.);
- _mm256_maskstore_pd(&mut r as *mut _ as *mut f64, mask, a);
+ _mm256_maskstore_pd(ptr::addr_of_mut!(r) as *mut f64, mask, a);
let e = _mm256_setr_pd(0., 2., 0., 4.);
assert_eq_m256d(r, e);
}
@@ -4037,7 +4038,7 @@ mod tests {
let mut r = _mm_set1_pd(0.);
let mask = _mm_setr_epi64x(0, !0);
let a = _mm_setr_pd(1., 2.);
- _mm_maskstore_pd(&mut r as *mut _ as *mut f64, mask, a);
+ _mm_maskstore_pd(ptr::addr_of_mut!(r) as *mut f64, mask, a);
let e = _mm_setr_pd(0., 2.);
assert_eq_m128d(r, e);
}
@@ -4057,7 +4058,7 @@ mod tests {
let mut r = _mm256_set1_ps(0.);
let mask = _mm256_setr_epi32(0, !0, 0, !0, 0, !0, 0, !0);
let a = _mm256_setr_ps(1., 2., 3., 4., 5., 6., 7., 8.);
- _mm256_maskstore_ps(&mut r as *mut _ as *mut f32, mask, a);
+ _mm256_maskstore_ps(ptr::addr_of_mut!(r) as *mut f32, mask, a);
let e = _mm256_setr_ps(0., 2., 0., 4., 0., 6., 0., 8.);
assert_eq_m256(r, e);
}
@@ -4077,7 +4078,7 @@ mod tests {
let mut r = _mm_set1_ps(0.);
let mask = _mm_setr_epi32(0, !0, 0, !0);
let a = _mm_setr_ps(1., 2., 3., 4.);
- _mm_maskstore_ps(&mut r as *mut _ as *mut f32, mask, a);
+ _mm_maskstore_ps(ptr::addr_of_mut!(r) as *mut f32, mask, a);
let e = _mm_setr_ps(0., 2., 0., 4.);
assert_eq_m128(r, e);
}
@@ -4115,7 +4116,7 @@ mod tests {
17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32,
);
- let p = &a as *const _;
+ let p = ptr::addr_of!(a);
let r = _mm256_lddqu_si256(black_box(p));
#[rustfmt::skip]
let e = _mm256_setr_epi8(
@@ -4131,7 +4132,7 @@ mod tests {
unsafe fn test_mm256_stream_si256() {
let a = _mm256_setr_epi64x(1, 2, 3, 4);
let mut r = _mm256_undefined_si256();
- _mm256_stream_si256(&mut r as *mut _, a);
+ _mm256_stream_si256(ptr::addr_of_mut!(r), a);
assert_eq_m256i(r, a);
}
@@ -4144,7 +4145,7 @@ mod tests {
let a = _mm256_set1_pd(7.0);
let mut mem = Memory { data: [-1.0; 4] };
- _mm256_stream_pd(&mut mem.data[0] as *mut f64, a);
+ _mm256_stream_pd(ptr::addr_of_mut!(mem.data[0]), a);
for i in 0..4 {
assert_eq!(mem.data[i], get_m256d(a, i));
}
@@ -4159,7 +4160,7 @@ mod tests {
let a = _mm256_set1_ps(7.0);
let mut mem = Memory { data: [-1.0; 8] };
- _mm256_stream_ps(&mut mem.data[0] as *mut f32, a);
+ _mm256_stream_ps(ptr::addr_of_mut!(mem.data[0]), a);
for i in 0..8 {
assert_eq!(mem.data[i], get_m256(a, i));
}
@@ -4807,7 +4808,7 @@ mod tests {
1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16,
);
- let r = _mm256_loadu2_m128i(&hi as *const _ as *const _, &lo as *const _ as *const _);
+ let r = _mm256_loadu2_m128i(ptr::addr_of!(hi) as *const _, ptr::addr_of!(lo) as *const _);
#[rustfmt::skip]
let e = _mm256_setr_epi8(
1, 2, 3, 4, 5, 6, 7, 8,
@@ -4824,8 +4825,8 @@ mod tests {
let mut hi = _mm_undefined_ps();
let mut lo = _mm_undefined_ps();
_mm256_storeu2_m128(
- &mut hi as *mut _ as *mut f32,
- &mut lo as *mut _ as *mut f32,
+ ptr::addr_of_mut!(hi) as *mut f32,
+ ptr::addr_of_mut!(lo) as *mut f32,
a,
);
assert_eq_m128(hi, _mm_setr_ps(5., 6., 7., 8.));
@@ -4838,8 +4839,8 @@ mod tests {
let mut hi = _mm_undefined_pd();
let mut lo = _mm_undefined_pd();
_mm256_storeu2_m128d(
- &mut hi as *mut _ as *mut f64,
- &mut lo as *mut _ as *mut f64,
+ ptr::addr_of_mut!(hi) as *mut f64,
+ ptr::addr_of_mut!(lo) as *mut f64,
a,
);
assert_eq_m128d(hi, _mm_setr_pd(3., 4.));
@@ -4857,7 +4858,7 @@ mod tests {
);
let mut hi = _mm_undefined_si128();
let mut lo = _mm_undefined_si128();
- _mm256_storeu2_m128i(&mut hi as *mut _, &mut lo as *mut _, a);
+ _mm256_storeu2_m128i(ptr::addr_of_mut!(hi), ptr::addr_of_mut!(lo), a);
#[rustfmt::skip]
let e_hi = _mm_setr_epi8(
17, 18, 19, 20, 21, 22, 23, 24,
diff --git a/crates/core_arch/src/x86/sse.rs b/crates/core_arch/src/x86/sse.rs
index 4bbb3907ab..5d4daa351d 100644
--- a/crates/core_arch/src/x86/sse.rs
+++ b/crates/core_arch/src/x86/sse.rs
@@ -1167,7 +1167,7 @@ pub unsafe fn _mm_loadu_ps(p: *const f32) -> __m128 {
let mut dst = _mm_undefined_ps();
ptr::copy_nonoverlapping(
p as *const u8,
- &mut dst as *mut __m128 as *mut u8,
+ ptr::addr_of_mut!(dst) as *mut u8,
mem::size_of::<__m128>(),
);
dst
@@ -1300,7 +1300,7 @@ pub unsafe fn _mm_store_ps(p: *mut f32, a: __m128) {
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_storeu_ps(p: *mut f32, a: __m128) {
ptr::copy_nonoverlapping(
- &a as *const __m128 as *const u8,
+ ptr::addr_of!(a) as *const u8,
p as *mut u8,
mem::size_of::<__m128>(),
);
@@ -1448,7 +1448,7 @@ pub unsafe fn _mm_sfence() {
)]
pub unsafe fn _mm_getcsr() -> u32 {
let mut result = 0_i32;
- stmxcsr(&mut result as *mut _ as *mut i8);
+ stmxcsr(ptr::addr_of_mut!(result) as *mut i8);
result as u32
}
@@ -1598,7 +1598,7 @@ pub unsafe fn _mm_getcsr() -> u32 {
note = "see `_mm_setcsr` documentation - use inline assembly instead"
)]
pub unsafe fn _mm_setcsr(val: u32) {
- ldmxcsr(&val as *const _ as *const i8);
+ ldmxcsr(ptr::addr_of!(val) as *const i8);
}
/// See [`_mm_setcsr`](fn._mm_setcsr.html)
@@ -2018,7 +2018,7 @@ pub unsafe fn _mm_stream_ps(mem_addr: *mut f32, a: __m128) {
#[cfg(test)]
mod tests {
- use crate::{hint::black_box, mem::transmute};
+ use crate::{hint::black_box, mem::transmute, ptr};
use std::{boxed, f32::NAN};
use stdarch_test::simd_test;
@@ -3132,14 +3132,14 @@ mod tests {
#[simd_test(enable = "sse")]
unsafe fn test_mm_load_ss() {
let a = 42.0f32;
- let r = _mm_load_ss(&a as *const f32);
+ let r = _mm_load_ss(ptr::addr_of!(a));
assert_eq_m128(r, _mm_setr_ps(42.0, 0.0, 0.0, 0.0));
}
#[simd_test(enable = "sse")]
unsafe fn test_mm_load1_ps() {
let a = 42.0f32;
- let r = _mm_load1_ps(&a as *const f32);
+ let r = _mm_load1_ps(ptr::addr_of!(a));
assert_eq_m128(r, _mm_setr_ps(42.0, 42.0, 42.0, 42.0));
}
@@ -3198,7 +3198,7 @@ mod tests {
#[simd_test(enable = "sse2")]
unsafe fn test_mm_loadu_si64() {
let a = _mm_setr_epi64x(5, 6);
- let r = _mm_loadu_si64(&a as *const _ as *const _);
+ let r = _mm_loadu_si64(ptr::addr_of!(a) as *const _);
assert_eq_m128i(r, _mm_setr_epi64x(5, 0));
}
@@ -3428,7 +3428,7 @@ mod tests {
let a = _mm_set1_ps(7.0);
let mut mem = Memory { data: [-1.0; 4] };
- _mm_stream_ps(&mut mem.data[0] as *mut f32, a);
+ _mm_stream_ps(ptr::addr_of_mut!(mem.data[0]), a);
for i in 0..4 {
assert_eq!(mem.data[i], get_m128(a, i));
}
diff --git a/crates/core_arch/src/x86/sse2.rs b/crates/core_arch/src/x86/sse2.rs
index 8e4989008c..212b905608 100644
--- a/crates/core_arch/src/x86/sse2.rs
+++ b/crates/core_arch/src/x86/sse2.rs
@@ -1239,7 +1239,7 @@ pub unsafe fn _mm_loadu_si128(mem_addr: *const __m128i) -> __m128i {
let mut dst: __m128i = _mm_undefined_si128();
ptr::copy_nonoverlapping(
mem_addr as *const u8,
- &mut dst as *mut __m128i as *mut u8,
+ ptr::addr_of_mut!(dst) as *mut u8,
mem::size_of::<__m128i>(),
);
dst
@@ -1308,7 +1308,7 @@ pub unsafe fn _mm_storeu_si128(mem_addr: *mut __m128i, a: __m128i) {
)]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _mm_storel_epi64(mem_addr: *mut __m128i, a: __m128i) {
- ptr::copy_nonoverlapping(&a as *const _ as *const u8, mem_addr as *mut u8, 8);
+ ptr::copy_nonoverlapping(ptr::addr_of!(a) as *const u8, mem_addr as *mut u8, 8);
}
/// Stores a 128-bit integer vector to a 128-bit aligned memory location.
@@ -2708,7 +2708,7 @@ pub unsafe fn _mm_loadu_pd(mem_addr: *const f64) -> __m128d {
let mut dst = _mm_undefined_pd();
ptr::copy_nonoverlapping(
mem_addr as *const u8,
- &mut dst as *mut __m128d as *mut u8,
+ ptr::addr_of_mut!(dst) as *mut u8,
mem::size_of::<__m128d>(),
);
dst
@@ -2970,6 +2970,7 @@ mod tests {
f64::{self, NAN},
i32,
mem::{self, transmute},
+ ptr,
};
use stdarch_test::simd_test;
@@ -2981,7 +2982,7 @@ mod tests {
#[simd_test(enable = "sse2")]
unsafe fn test_mm_clflush() {
let x = 0_u8;
- _mm_clflush(&x as *const _);
+ _mm_clflush(ptr::addr_of!(x));
}
#[simd_test(enable = "sse2")]
@@ -3868,21 +3869,21 @@ mod tests {
#[simd_test(enable = "sse2")]
unsafe fn test_mm_loadl_epi64() {
let a = _mm_setr_epi64x(6, 5);
- let r = _mm_loadl_epi64(&a as *const _);
+ let r = _mm_loadl_epi64(ptr::addr_of!(a));
assert_eq_m128i(r, _mm_setr_epi64x(6, 0));
}
#[simd_test(enable = "sse2")]
unsafe fn test_mm_load_si128() {
let a = _mm_set_epi64x(5, 6);
- let r = _mm_load_si128(&a as *const _ as *const _);
+ let r = _mm_load_si128(ptr::addr_of!(a) as *const _);
assert_eq_m128i(a, r);
}
#[simd_test(enable = "sse2")]
unsafe fn test_mm_loadu_si128() {
let a = _mm_set_epi64x(5, 6);
- let r = _mm_loadu_si128(&a as *const _ as *const _);
+ let r = _mm_loadu_si128(ptr::addr_of!(a) as *const _);
assert_eq_m128i(a, r);
}
@@ -3898,7 +3899,7 @@ mod tests {
0, 0, 0, 0, 0, 0, 0, 0,
);
let mut r = _mm_set1_epi8(0);
- _mm_maskmoveu_si128(a, mask, &mut r as *mut _ as *mut i8);
+ _mm_maskmoveu_si128(a, mask, ptr::addr_of_mut!(r) as *mut i8);
let e = _mm_set_epi8(0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
assert_eq_m128i(r, e);
}
@@ -3934,7 +3935,7 @@ mod tests {
unsafe fn test_mm_stream_si128() {
let a = _mm_setr_epi32(1, 2, 3, 4);
let mut r = _mm_undefined_si128();
- _mm_stream_si128(&mut r as *mut _, a);
+ _mm_stream_si128(ptr::addr_of_mut!(r), a);
assert_eq_m128i(r, a);
}
@@ -3945,7 +3946,7 @@ mod tests {
unsafe fn test_mm_stream_si32() {
let a: i32 = 7;
let mut mem = boxed::Box::<i32>::new(-1);
- _mm_stream_si32(&mut *mem as *mut i32, a);
+ _mm_stream_si32(ptr::addr_of_mut!(*mem), a);
assert_eq!(a, *mem);
}
@@ -4641,7 +4642,7 @@ mod tests {
let a = _mm_set1_pd(7.0);
let mut mem = Memory { data: [-1.0; 2] };
- _mm_stream_pd(&mut mem.data[0] as *mut f64, a);
+ _mm_stream_pd(ptr::addr_of_mut!(mem.data[0]), a);
for i in 0..2 {
assert_eq!(mem.data[i], get_m128d(a, i));
}
diff --git a/crates/core_arch/src/x86_64/sse2.rs b/crates/core_arch/src/x86_64/sse2.rs
index a97688f7e9..ea3dbc41bc 100644
--- a/crates/core_arch/src/x86_64/sse2.rs
+++ b/crates/core_arch/src/x86_64/sse2.rs
@@ -158,6 +158,7 @@ pub unsafe fn _mm_cvtsi64x_sd(a: __m128d, b: i64) -> __m128d {
mod tests {
use crate::core_arch::arch::x86_64::*;
use std::boxed;
+ use std::ptr;
use stdarch_test::simd_test;
#[simd_test(enable = "sse2")]
@@ -196,7 +197,7 @@ mod tests {
unsafe fn test_mm_stream_si64() {
let a: i64 = 7;
let mut mem = boxed::Box::<i64>::new(-1);
- _mm_stream_si64(&mut *mem as *mut i64, a);
+ _mm_stream_si64(ptr::addr_of_mut!(*mem), a);
assert_eq!(a, *mem);
}