Skip to content

Use addr_of! #1540

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Feb 24, 2024
Merged

Use addr_of! #1540

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
55 changes: 28 additions & 27 deletions crates/core_arch/src/x86/avx.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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::*;
Expand Down Expand Up @@ -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);
Expand All @@ -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);
Expand All @@ -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);
}

Expand All @@ -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);
}

Expand All @@ -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);
Expand All @@ -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);
Expand All @@ -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);
}

Expand All @@ -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);
}
Expand All @@ -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);
}
Expand All @@ -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);
}
Expand All @@ -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);
}
Expand Down Expand Up @@ -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(
Expand All @@ -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);
}

Expand All @@ -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));
}
Expand All @@ -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));
}
Expand Down Expand Up @@ -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,
Expand All @@ -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.));
Expand All @@ -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.));
Expand All @@ -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,
Expand Down
18 changes: 9 additions & 9 deletions crates/core_arch/src/x86/sse.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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>(),
);
Expand Down Expand Up @@ -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
}

Expand Down Expand Up @@ -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)
Expand Down Expand Up @@ -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;

Expand Down Expand Up @@ -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));
}

Expand Down Expand Up @@ -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));
}

Expand Down Expand Up @@ -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));
}
Expand Down
Loading