user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

use addr_of!

Browse source
This commit is contained in:
Pavel Grigorenko 2024-02-24 18:48:45 +03:00 • committed by Amanieu d'Antras
parent 8531e289b0
commit 1c16ce54e5
4 changed files with 51 additions and 48 deletions
Download patch file Download diff file Expand all files Collapse all files

55
library/stdarch/crates/core_arch/src/x86/avx.rs
View file

@ -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,

18
library/stdarch/crates/core_arch/src/x86/sse.rs
View file

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

23
library/stdarch/crates/core_arch/src/x86/sse2.rs
View file

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

3
library/stdarch/crates/core_arch/src/x86_64/sse2.rs
View file

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