crate: use unsafe in tests
This commit is contained in:
Andrew Gallant
parent
6dfc65289c
commit
25cef3696a
12 changed files with 893 additions and 975 deletions
|
|
@ -48,22 +48,22 @@ mod tests {
|
|||
use x86::abm;
|
||||
|
||||
#[simd_test = "lzcnt"]
|
||||
fn _lzcnt_u32() {
|
||||
assert_eq!(unsafe { abm::_lzcnt_u32(0b0101_1010u32) }, 25u32);
|
||||
unsafe fn _lzcnt_u32() {
|
||||
assert_eq!(abm::_lzcnt_u32(0b0101_1010u32), 25u32);
|
||||
}
|
||||
|
||||
#[simd_test = "lzcnt"]
|
||||
fn _lzcnt_u64() {
|
||||
assert_eq!(unsafe { abm::_lzcnt_u64(0b0101_1010u64) }, 57u64);
|
||||
unsafe fn _lzcnt_u64() {
|
||||
assert_eq!(abm::_lzcnt_u64(0b0101_1010u64), 57u64);
|
||||
}
|
||||
|
||||
#[simd_test = "popcnt"]
|
||||
fn _popcnt32() {
|
||||
assert_eq!(unsafe { abm::_popcnt32(0b0101_1010u32) }, 4);
|
||||
unsafe fn _popcnt32() {
|
||||
assert_eq!(abm::_popcnt32(0b0101_1010u32), 4);
|
||||
}
|
||||
|
||||
#[simd_test = "popcnt"]
|
||||
fn _popcnt64() {
|
||||
assert_eq!(unsafe { abm::_popcnt64(0b0101_1010u64) }, 4);
|
||||
unsafe fn _popcnt64() {
|
||||
assert_eq!(abm::_popcnt64(0b0101_1010u64), 4);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -135,83 +135,83 @@ mod tests {
|
|||
use x86::avx;
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_add_pd() {
|
||||
unsafe fn _mm256_add_pd() {
|
||||
let a = f64x4::new(1.0, 2.0, 3.0, 4.0);
|
||||
let b = f64x4::new(5.0, 6.0, 7.0, 8.0);
|
||||
let r = unsafe { avx::_mm256_add_pd(a, b) };
|
||||
let r = avx::_mm256_add_pd(a, b);
|
||||
let e = f64x4::new(6.0, 8.0, 10.0, 12.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_add_ps() {
|
||||
unsafe fn _mm256_add_ps() {
|
||||
let a = f32x8::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
|
||||
let b = f32x8::new(9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
|
||||
let r = unsafe { avx::_mm256_add_ps(a, b) };
|
||||
let r = avx::_mm256_add_ps(a, b);
|
||||
let e = f32x8::new(10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_mul_pd() {
|
||||
unsafe fn _mm256_mul_pd() {
|
||||
let a = f64x4::new(1.0, 2.0, 3.0, 4.0);
|
||||
let b = f64x4::new(5.0, 6.0, 7.0, 8.0);
|
||||
let r = unsafe { avx::_mm256_mul_pd(a, b) };
|
||||
let r = avx::_mm256_mul_pd(a, b);
|
||||
let e = f64x4::new(5.0, 12.0, 21.0, 32.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_mul_ps() {
|
||||
unsafe fn _mm256_mul_ps() {
|
||||
let a = f32x8::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
|
||||
let b = f32x8::new(9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0);
|
||||
let r = unsafe { avx::_mm256_mul_ps(a, b) };
|
||||
let r = avx::_mm256_mul_ps(a, b);
|
||||
let e = f32x8::new(9.0, 20.0, 33.0, 48.0, 65.0, 84.0, 105.0, 128.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_addsub_pd() {
|
||||
unsafe fn _mm256_addsub_pd() {
|
||||
let a = f64x4::new(1.0, 2.0, 3.0, 4.0);
|
||||
let b = f64x4::new(5.0, 6.0, 7.0, 8.0);
|
||||
let r = unsafe { avx::_mm256_addsub_pd(a, b) };
|
||||
let r = avx::_mm256_addsub_pd(a, b);
|
||||
let e = f64x4::new(-4.0, 8.0, -4.0, 12.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_addsub_ps() {
|
||||
unsafe fn _mm256_addsub_ps() {
|
||||
let a = f32x8::new(1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0);
|
||||
let b = f32x8::new(5.0, 6.0, 7.0, 8.0, 5.0, 6.0, 7.0, 8.0);
|
||||
let r = unsafe { avx::_mm256_addsub_ps(a, b) };
|
||||
let r = avx::_mm256_addsub_ps(a, b);
|
||||
let e = f32x8::new(-4.0, 8.0, -4.0, 12.0, -4.0, 8.0, -4.0, 12.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_sub_pd() {
|
||||
unsafe fn _mm256_sub_pd() {
|
||||
let a = f64x4::new(1.0, 2.0, 3.0, 4.0);
|
||||
let b = f64x4::new(5.0, 6.0, 7.0, 8.0);
|
||||
let r = unsafe { avx::_mm256_sub_pd(a, b) };
|
||||
let r = avx::_mm256_sub_pd(a, b);
|
||||
let e = f64x4::new(-4.0,-4.0,-4.0,-4.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_sub_ps() {
|
||||
unsafe fn _mm256_sub_ps() {
|
||||
let a = f32x8::new(1.0, 2.0, 3.0, 4.0, -1.0, -2.0, -3.0, -4.0);
|
||||
let b = f32x8::new(5.0, 6.0, 7.0, 8.0, 3.0, 2.0, 1.0, 0.0);
|
||||
let r = unsafe { avx::_mm256_sub_ps(a, b) };
|
||||
let r = avx::_mm256_sub_ps(a, b);
|
||||
let e = f32x8::new(-4.0, -4.0, -4.0, -4.0, -4.0, -4.0, -4.0, -4.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_round_pd() {
|
||||
unsafe fn _mm256_round_pd() {
|
||||
let a = f64x4::new(1.55, 2.2, 3.99, -1.2);
|
||||
let result_closest = unsafe { avx::_mm256_round_pd(a, 0b00000000) };
|
||||
let result_down = unsafe { avx::_mm256_round_pd(a, 0b00000001) };
|
||||
let result_up = unsafe { avx::_mm256_round_pd(a, 0b00000010) };
|
||||
let result_closest = avx::_mm256_round_pd(a, 0b00000000);
|
||||
let result_down = avx::_mm256_round_pd(a, 0b00000001);
|
||||
let result_up = avx::_mm256_round_pd(a, 0b00000010);
|
||||
let expected_closest = f64x4::new(2.0, 2.0, 4.0, -1.0);
|
||||
let expected_down = f64x4::new(1.0, 2.0, 3.0, -2.0);
|
||||
let expected_up = f64x4::new(2.0, 3.0, 4.0, -1.0);
|
||||
|
|
@ -221,17 +221,17 @@ mod tests {
|
|||
}
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_floor_pd() {
|
||||
unsafe fn _mm256_floor_pd() {
|
||||
let a = f64x4::new(1.55, 2.2, 3.99, -1.2);
|
||||
let result_down = unsafe { avx::_mm256_floor_pd(a) };
|
||||
let result_down = avx::_mm256_floor_pd(a);
|
||||
let expected_down = f64x4::new(1.0, 2.0, 3.0, -2.0);
|
||||
assert_eq!(result_down, expected_down);
|
||||
}
|
||||
|
||||
#[simd_test = "avx"]
|
||||
fn _mm256_ceil_pd() {
|
||||
unsafe fn _mm256_ceil_pd() {
|
||||
let a = f64x4::new(1.55, 2.2, 3.99, -1.2);
|
||||
let result_up = unsafe { avx::_mm256_ceil_pd(a) };
|
||||
let result_up = avx::_mm256_ceil_pd(a);
|
||||
let expected_up = f64x4::new(2.0, 3.0, 4.0, -1.0);
|
||||
assert_eq!(result_up, expected_up);
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -190,123 +190,123 @@ mod tests {
|
|||
use x86::bmi;
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
fn _bextr_u32() {
|
||||
let r = unsafe { bmi::_bextr_u32(0b0101_0000u32, 4, 4) };
|
||||
unsafe fn _bextr_u32() {
|
||||
let r = bmi::_bextr_u32(0b0101_0000u32, 4, 4);
|
||||
assert_eq!(r, 0b0000_0101u32);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _bextr_u64() {
|
||||
let r = unsafe { bmi::_bextr_u64(0b0101_0000u64, 4, 4) };
|
||||
unsafe fn _bextr_u64() {
|
||||
let r = bmi::_bextr_u64(0b0101_0000u64, 4, 4);
|
||||
assert_eq!(r, 0b0000_0101u64);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
fn _andn_u32() {
|
||||
assert_eq!(unsafe { bmi::_andn_u32(0, 0) }, 0);
|
||||
assert_eq!(unsafe { bmi::_andn_u32(0, 1) }, 1);
|
||||
assert_eq!(unsafe { bmi::_andn_u32(1, 0) }, 0);
|
||||
assert_eq!(unsafe { bmi::_andn_u32(1, 1) }, 0);
|
||||
unsafe fn _andn_u32() {
|
||||
assert_eq!(bmi::_andn_u32(0, 0), 0);
|
||||
assert_eq!(bmi::_andn_u32(0, 1), 1);
|
||||
assert_eq!(bmi::_andn_u32(1, 0), 0);
|
||||
assert_eq!(bmi::_andn_u32(1, 1), 0);
|
||||
|
||||
let r = unsafe { bmi::_andn_u32(0b0000_0000u32, 0b0000_0000u32) };
|
||||
let r = bmi::_andn_u32(0b0000_0000u32, 0b0000_0000u32);
|
||||
assert_eq!(r, 0b0000_0000u32);
|
||||
|
||||
let r = unsafe { bmi::_andn_u32(0b0000_0000u32, 0b1111_1111u32) };
|
||||
let r = bmi::_andn_u32(0b0000_0000u32, 0b1111_1111u32);
|
||||
assert_eq!(r, 0b1111_1111u32);
|
||||
|
||||
let r = unsafe { bmi::_andn_u32(0b1111_1111u32, 0b0000_0000u32) };
|
||||
let r = bmi::_andn_u32(0b1111_1111u32, 0b0000_0000u32);
|
||||
assert_eq!(r, 0b0000_0000u32);
|
||||
|
||||
let r = unsafe { bmi::_andn_u32(0b1111_1111u32, 0b1111_1111u32) };
|
||||
let r = bmi::_andn_u32(0b1111_1111u32, 0b1111_1111u32);
|
||||
assert_eq!(r, 0b0000_0000u32);
|
||||
|
||||
let r = unsafe { bmi::_andn_u32(0b0100_0000u32, 0b0101_1101u32) };
|
||||
let r = bmi::_andn_u32(0b0100_0000u32, 0b0101_1101u32);
|
||||
assert_eq!(r, 0b0001_1101u32);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _andn_u64() {
|
||||
assert_eq!(unsafe { bmi::_andn_u64(0, 0) }, 0);
|
||||
assert_eq!(unsafe { bmi::_andn_u64(0, 1) }, 1);
|
||||
assert_eq!(unsafe { bmi::_andn_u64(1, 0) }, 0);
|
||||
assert_eq!(unsafe { bmi::_andn_u64(1, 1) }, 0);
|
||||
unsafe fn _andn_u64() {
|
||||
assert_eq!(bmi::_andn_u64(0, 0), 0);
|
||||
assert_eq!(bmi::_andn_u64(0, 1), 1);
|
||||
assert_eq!(bmi::_andn_u64(1, 0), 0);
|
||||
assert_eq!(bmi::_andn_u64(1, 1), 0);
|
||||
|
||||
let r = unsafe { bmi::_andn_u64(0b0000_0000u64, 0b0000_0000u64) };
|
||||
let r = bmi::_andn_u64(0b0000_0000u64, 0b0000_0000u64);
|
||||
assert_eq!(r, 0b0000_0000u64);
|
||||
|
||||
let r = unsafe { bmi::_andn_u64(0b0000_0000u64, 0b1111_1111u64) };
|
||||
let r = bmi::_andn_u64(0b0000_0000u64, 0b1111_1111u64);
|
||||
assert_eq!(r, 0b1111_1111u64);
|
||||
|
||||
let r = unsafe { bmi::_andn_u64(0b1111_1111u64, 0b0000_0000u64) };
|
||||
let r = bmi::_andn_u64(0b1111_1111u64, 0b0000_0000u64);
|
||||
assert_eq!(r, 0b0000_0000u64);
|
||||
|
||||
let r = unsafe { bmi::_andn_u64(0b1111_1111u64, 0b1111_1111u64) };
|
||||
let r = bmi::_andn_u64(0b1111_1111u64, 0b1111_1111u64);
|
||||
assert_eq!(r, 0b0000_0000u64);
|
||||
|
||||
let r = unsafe { bmi::_andn_u64(0b0100_0000u64, 0b0101_1101u64) };
|
||||
let r = bmi::_andn_u64(0b0100_0000u64, 0b0101_1101u64);
|
||||
assert_eq!(r, 0b0001_1101u64);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
fn _blsi_u32() {
|
||||
assert_eq!(unsafe { bmi::_blsi_u32(0b1101_0000u32) }, 0b0001_0000u32);
|
||||
unsafe fn _blsi_u32() {
|
||||
assert_eq!(bmi::_blsi_u32(0b1101_0000u32), 0b0001_0000u32);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _blsi_u64() {
|
||||
assert_eq!(unsafe { bmi::_blsi_u64(0b1101_0000u64) }, 0b0001_0000u64);
|
||||
unsafe fn _blsi_u64() {
|
||||
assert_eq!(bmi::_blsi_u64(0b1101_0000u64), 0b0001_0000u64);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
fn _blsmsk_u32() {
|
||||
let r = unsafe { bmi::_blsmsk_u32(0b0011_0000u32) };
|
||||
unsafe fn _blsmsk_u32() {
|
||||
let r = bmi::_blsmsk_u32(0b0011_0000u32);
|
||||
assert_eq!(r, 0b0001_1111u32);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _blsmsk_u64() {
|
||||
let r = unsafe { bmi::_blsmsk_u64(0b0011_0000u64) };
|
||||
unsafe fn _blsmsk_u64() {
|
||||
let r = bmi::_blsmsk_u64(0b0011_0000u64);
|
||||
assert_eq!(r, 0b0001_1111u64);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
fn _blsr_u32() {
|
||||
unsafe fn _blsr_u32() {
|
||||
// TODO: test the behavior when the input is 0
|
||||
let r = unsafe { bmi::_blsr_u32(0b0011_0000u32) };
|
||||
let r = bmi::_blsr_u32(0b0011_0000u32);
|
||||
assert_eq!(r, 0b0010_0000u32);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _blsr_u64() {
|
||||
unsafe fn _blsr_u64() {
|
||||
// TODO: test the behavior when the input is 0
|
||||
let r = unsafe { bmi::_blsr_u64(0b0011_0000u64) };
|
||||
let r = bmi::_blsr_u64(0b0011_0000u64);
|
||||
assert_eq!(r, 0b0010_0000u64);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
fn _tzcnt_u16() {
|
||||
assert_eq!(unsafe { bmi::_tzcnt_u16(0b0000_0001u16) }, 0u16);
|
||||
assert_eq!(unsafe { bmi::_tzcnt_u16(0b0000_0000u16) }, 16u16);
|
||||
assert_eq!(unsafe { bmi::_tzcnt_u16(0b1001_0000u16) }, 4u16);
|
||||
unsafe fn _tzcnt_u16() {
|
||||
assert_eq!(bmi::_tzcnt_u16(0b0000_0001u16), 0u16);
|
||||
assert_eq!(bmi::_tzcnt_u16(0b0000_0000u16), 16u16);
|
||||
assert_eq!(bmi::_tzcnt_u16(0b1001_0000u16), 4u16);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
fn _tzcnt_u32() {
|
||||
assert_eq!(unsafe { bmi::_tzcnt_u32(0b0000_0001u32) }, 0u32);
|
||||
assert_eq!(unsafe { bmi::_tzcnt_u32(0b0000_0000u32) }, 32u32);
|
||||
assert_eq!(unsafe { bmi::_tzcnt_u32(0b1001_0000u32) }, 4u32);
|
||||
unsafe fn _tzcnt_u32() {
|
||||
assert_eq!(bmi::_tzcnt_u32(0b0000_0001u32), 0u32);
|
||||
assert_eq!(bmi::_tzcnt_u32(0b0000_0000u32), 32u32);
|
||||
assert_eq!(bmi::_tzcnt_u32(0b1001_0000u32), 4u32);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _tzcnt_u64() {
|
||||
assert_eq!(unsafe { bmi::_tzcnt_u64(0b0000_0001u64) }, 0u64);
|
||||
assert_eq!(unsafe { bmi::_tzcnt_u64(0b0000_0000u64) }, 64u64);
|
||||
assert_eq!(unsafe { bmi::_tzcnt_u64(0b1001_0000u64) }, 4u64);
|
||||
unsafe fn _tzcnt_u64() {
|
||||
assert_eq!(bmi::_tzcnt_u64(0b0000_0001u64), 0u64);
|
||||
assert_eq!(bmi::_tzcnt_u64(0b0000_0000u64), 64u64);
|
||||
assert_eq!(bmi::_tzcnt_u64(0b1001_0000u64), 4u64);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ mod tests {
|
|||
use x86::bmi2;
|
||||
|
||||
#[simd_test = "bmi2"]
|
||||
fn _pext_u32() {
|
||||
unsafe fn _pext_u32() {
|
||||
let n = 0b1011_1110_1001_0011u32;
|
||||
|
||||
let m0 = 0b0110_0011_1000_0101u32;
|
||||
|
|
@ -126,13 +126,13 @@ mod tests {
|
|||
let m1 = 0b1110_1011_1110_1111u32;
|
||||
let s1 = 0b0001_0111_0100_0011u32;
|
||||
|
||||
assert_eq!(unsafe { bmi2::_pext_u32(n, m0) }, s0);
|
||||
assert_eq!(unsafe { bmi2::_pext_u32(n, m1) }, s1);
|
||||
assert_eq!(bmi2::_pext_u32(n, m0), s0);
|
||||
assert_eq!(bmi2::_pext_u32(n, m1), s1);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi2"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _pext_u64() {
|
||||
unsafe fn _pext_u64() {
|
||||
let n = 0b1011_1110_1001_0011u64;
|
||||
|
||||
let m0 = 0b0110_0011_1000_0101u64;
|
||||
|
|
@ -141,12 +141,12 @@ mod tests {
|
|||
let m1 = 0b1110_1011_1110_1111u64;
|
||||
let s1 = 0b0001_0111_0100_0011u64;
|
||||
|
||||
assert_eq!(unsafe { bmi2::_pext_u64(n, m0) }, s0);
|
||||
assert_eq!(unsafe { bmi2::_pext_u64(n, m1) }, s1);
|
||||
assert_eq!(bmi2::_pext_u64(n, m0), s0);
|
||||
assert_eq!(bmi2::_pext_u64(n, m1), s1);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi2"]
|
||||
fn _pdep_u32() {
|
||||
unsafe fn _pdep_u32() {
|
||||
let n = 0b1011_1110_1001_0011u32;
|
||||
|
||||
let m0 = 0b0110_0011_1000_0101u32;
|
||||
|
|
@ -155,13 +155,13 @@ mod tests {
|
|||
let m1 = 0b1110_1011_1110_1111u32;
|
||||
let s1 = 0b1110_1001_0010_0011u32;
|
||||
|
||||
assert_eq!(unsafe { bmi2::_pdep_u32(n, m0) }, s0);
|
||||
assert_eq!(unsafe { bmi2::_pdep_u32(n, m1) }, s1);
|
||||
assert_eq!(bmi2::_pdep_u32(n, m0), s0);
|
||||
assert_eq!(bmi2::_pdep_u32(n, m1), s1);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi2"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _pdep_u64() {
|
||||
unsafe fn _pdep_u64() {
|
||||
let n = 0b1011_1110_1001_0011u64;
|
||||
|
||||
let m0 = 0b0110_0011_1000_0101u64;
|
||||
|
|
@ -170,30 +170,30 @@ mod tests {
|
|||
let m1 = 0b1110_1011_1110_1111u64;
|
||||
let s1 = 0b1110_1001_0010_0011u64;
|
||||
|
||||
assert_eq!(unsafe { bmi2::_pdep_u64(n, m0) }, s0);
|
||||
assert_eq!(unsafe { bmi2::_pdep_u64(n, m1) }, s1);
|
||||
assert_eq!(bmi2::_pdep_u64(n, m0), s0);
|
||||
assert_eq!(bmi2::_pdep_u64(n, m1), s1);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi2"]
|
||||
fn _bzhi_u32() {
|
||||
unsafe fn _bzhi_u32() {
|
||||
let n = 0b1111_0010u32;
|
||||
let s = 0b0001_0010u32;
|
||||
assert_eq!(unsafe { bmi2::_bzhi_u32(n, 5) }, s);
|
||||
assert_eq!(bmi2::_bzhi_u32(n, 5), s);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi2"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _bzhi_u64() {
|
||||
unsafe fn _bzhi_u64() {
|
||||
let n = 0b1111_0010u64;
|
||||
let s = 0b0001_0010u64;
|
||||
assert_eq!(unsafe { bmi2::_bzhi_u64(n, 5) }, s);
|
||||
assert_eq!(bmi2::_bzhi_u64(n, 5), s);
|
||||
}
|
||||
|
||||
#[simd_test = "bmi2"]
|
||||
fn _mulx_u32() {
|
||||
unsafe fn _mulx_u32() {
|
||||
let a: u32 = 4_294_967_200;
|
||||
let b: u32 = 2;
|
||||
let (lo, hi): (u32, u32) = unsafe { bmi2::_mulx_u32(a, b) };
|
||||
let (lo, hi): (u32, u32) = bmi2::_mulx_u32(a, b);
|
||||
// result = 8589934400
|
||||
// = 0b0001_1111_1111_1111_1111_1111_1111_0100_0000u64
|
||||
// ^~hi ^~lo~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
|
@ -203,10 +203,10 @@ mod tests {
|
|||
|
||||
#[simd_test = "bmi2"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _mulx_u64() {
|
||||
unsafe fn _mulx_u64() {
|
||||
let a: u64 = 9_223_372_036_854_775_800;
|
||||
let b: u64 = 100;
|
||||
let (lo, hi): (u64, u64) = unsafe { bmi2::_mulx_u64(a, b) };
|
||||
let (lo, hi): (u64, u64) = bmi2::_mulx_u64(a, b);
|
||||
// result = 922337203685477580000
|
||||
// = 0b00110001_11111111_11111111_11111111_11111111_11111111_11111111_11111100_11100000u128
|
||||
// ^~hi~~~~ ^~lo~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
|
|
|||
|
|
@ -314,200 +314,196 @@ mod tests {
|
|||
use stdsimd_test::simd_test;
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_add_ps() {
|
||||
unsafe fn _mm_add_ps() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_add_ps(a, b) };
|
||||
let r = sse::_mm_add_ps(a, b);
|
||||
assert_eq!(r, f32x4::new(-101.0, 25.0, 0.0, -15.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_add_ss() {
|
||||
unsafe fn _mm_add_ss() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_add_ss(a, b) };
|
||||
let r = sse::_mm_add_ss(a, b);
|
||||
assert_eq!(r, f32x4::new(-101.0, 5.0, 0.0, -10.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_sub_ps() {
|
||||
unsafe fn _mm_sub_ps() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_sub_ps(a, b) };
|
||||
let r = sse::_mm_sub_ps(a, b);
|
||||
assert_eq!(r, f32x4::new(99.0, -15.0, 0.0, -5.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_sub_ss() {
|
||||
unsafe fn _mm_sub_ss() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_sub_ss(a, b) };
|
||||
let r = sse::_mm_sub_ss(a, b);
|
||||
assert_eq!(r, f32x4::new(99.0, 5.0, 0.0, -10.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_mul_ps() {
|
||||
unsafe fn _mm_mul_ps() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_mul_ps(a, b) };
|
||||
let r = sse::_mm_mul_ps(a, b);
|
||||
assert_eq!(r, f32x4::new(100.0, 100.0, 0.0, 50.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_mul_ss() {
|
||||
unsafe fn _mm_mul_ss() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_mul_ss(a, b) };
|
||||
let r = sse::_mm_mul_ss(a, b);
|
||||
assert_eq!(r, f32x4::new(100.0, 5.0, 0.0, -10.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_div_ps() {
|
||||
unsafe fn _mm_div_ps() {
|
||||
let a = f32x4::new(-1.0, 5.0, 2.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.2, -5.0);
|
||||
let r = unsafe { sse::_mm_div_ps(a, b) };
|
||||
let r = sse::_mm_div_ps(a, b);
|
||||
assert_eq!(r, f32x4::new(0.01, 0.25, 10.0, 2.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_div_ss() {
|
||||
unsafe fn _mm_div_ss() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_div_ss(a, b) };
|
||||
let r = sse::_mm_div_ss(a, b);
|
||||
assert_eq!(r, f32x4::new(0.01, 5.0, 0.0, -10.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_sqrt_ss() {
|
||||
unsafe fn _mm_sqrt_ss() {
|
||||
let a = f32x4::new(4.0, 13.0, 16.0, 100.0);
|
||||
let r = unsafe { sse::_mm_sqrt_ss(a) };
|
||||
let r = sse::_mm_sqrt_ss(a);
|
||||
let e = f32x4::new(2.0, 13.0, 16.0, 100.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_sqrt_ps() {
|
||||
unsafe fn _mm_sqrt_ps() {
|
||||
let a = f32x4::new(4.0, 13.0, 16.0, 100.0);
|
||||
let r = unsafe { sse::_mm_sqrt_ps(a) };
|
||||
let r = sse::_mm_sqrt_ps(a);
|
||||
let e = f32x4::new(2.0, 3.6055512, 4.0, 10.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_rcp_ss() {
|
||||
unsafe fn _mm_rcp_ss() {
|
||||
let a = f32x4::new(4.0, 13.0, 16.0, 100.0);
|
||||
let r = unsafe { sse::_mm_rcp_ss(a) };
|
||||
let r = sse::_mm_rcp_ss(a);
|
||||
let e = f32x4::new(0.24993896, 13.0, 16.0, 100.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_rcp_ps() {
|
||||
unsafe fn _mm_rcp_ps() {
|
||||
let a = f32x4::new(4.0, 13.0, 16.0, 100.0);
|
||||
let r = unsafe { sse::_mm_rcp_ps(a) };
|
||||
let r = sse::_mm_rcp_ps(a);
|
||||
let e = f32x4::new(0.24993896, 0.0769043, 0.06248474, 0.0099983215);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_rsqrt_ss() {
|
||||
unsafe fn _mm_rsqrt_ss() {
|
||||
let a = f32x4::new(4.0, 13.0, 16.0, 100.0);
|
||||
let r = unsafe { sse::_mm_rsqrt_ss(a) };
|
||||
let r = sse::_mm_rsqrt_ss(a);
|
||||
let e = f32x4::new(0.49987793, 13.0, 16.0, 100.0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_rsqrt_ps() {
|
||||
unsafe fn _mm_rsqrt_ps() {
|
||||
let a = f32x4::new(4.0, 13.0, 16.0, 100.0);
|
||||
let r = unsafe { sse::_mm_rsqrt_ps(a) };
|
||||
let r = sse::_mm_rsqrt_ps(a);
|
||||
let e = f32x4::new(0.49987793, 0.2772827, 0.24993896, 0.099990845);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_min_ss() {
|
||||
unsafe fn _mm_min_ss() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_min_ss(a, b) };
|
||||
let r = sse::_mm_min_ss(a, b);
|
||||
assert_eq!(r, f32x4::new(-100.0, 5.0, 0.0, -10.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_min_ps() {
|
||||
unsafe fn _mm_min_ps() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_min_ps(a, b) };
|
||||
let r = sse::_mm_min_ps(a, b);
|
||||
assert_eq!(r, f32x4::new(-100.0, 5.0, 0.0, -10.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_max_ss() {
|
||||
unsafe fn _mm_max_ss() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_max_ss(a, b) };
|
||||
let r = sse::_mm_max_ss(a, b);
|
||||
assert_eq!(r, f32x4::new(-1.0, 5.0, 0.0, -10.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_max_ps() {
|
||||
unsafe fn _mm_max_ps() {
|
||||
let a = f32x4::new(-1.0, 5.0, 0.0, -10.0);
|
||||
let b = f32x4::new(-100.0, 20.0, 0.0, -5.0);
|
||||
let r = unsafe { sse::_mm_max_ps(a, b) };
|
||||
let r = sse::_mm_max_ps(a, b);
|
||||
assert_eq!(r, f32x4::new(-1.0, 20.0, 0.0, -5.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_shuffle_ps() {
|
||||
unsafe fn _mm_shuffle_ps() {
|
||||
let a = f32x4::new(1.0, 2.0, 3.0, 4.0);
|
||||
let b = f32x4::new(5.0, 6.0, 7.0, 8.0);
|
||||
let mask = 0b00_01_01_11;
|
||||
let r = unsafe { sse::_mm_shuffle_ps(a, b, mask) };
|
||||
let r = sse::_mm_shuffle_ps(a, b, mask);
|
||||
assert_eq!(r, f32x4::new(4.0, 2.0, 6.0, 5.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_unpackhi_ps() {
|
||||
unsafe fn _mm_unpackhi_ps() {
|
||||
let a = f32x4::new(1.0, 2.0, 3.0, 4.0);
|
||||
let b = f32x4::new(5.0, 6.0, 7.0, 8.0);
|
||||
let r = unsafe { sse::_mm_unpackhi_ps(a, b) };
|
||||
let r = sse::_mm_unpackhi_ps(a, b);
|
||||
assert_eq!(r, f32x4::new(3.0, 7.0, 4.0, 8.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_unpacklo_ps() {
|
||||
unsafe fn _mm_unpacklo_ps() {
|
||||
let a = f32x4::new(1.0, 2.0, 3.0, 4.0);
|
||||
let b = f32x4::new(5.0, 6.0, 7.0, 8.0);
|
||||
let r = unsafe { sse::_mm_unpacklo_ps(a, b) };
|
||||
let r = sse::_mm_unpacklo_ps(a, b);
|
||||
assert_eq!(r, f32x4::new(1.0, 5.0, 2.0, 6.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_movehl_ps() {
|
||||
unsafe fn _mm_movehl_ps() {
|
||||
let a = f32x4::new(1.0, 2.0, 3.0, 4.0);
|
||||
let b = f32x4::new(5.0, 6.0, 7.0, 8.0);
|
||||
let r = unsafe { sse::_mm_movehl_ps(a, b) };
|
||||
let r = sse::_mm_movehl_ps(a, b);
|
||||
assert_eq!(r, f32x4::new(7.0, 8.0, 3.0, 4.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_movelh_ps() {
|
||||
unsafe fn _mm_movelh_ps() {
|
||||
let a = f32x4::new(1.0, 2.0, 3.0, 4.0);
|
||||
let b = f32x4::new(5.0, 6.0, 7.0, 8.0);
|
||||
let r = unsafe { sse::_mm_movelh_ps(a, b) };
|
||||
let r = sse::_mm_movelh_ps(a, b);
|
||||
assert_eq!(r, f32x4::new(1.0, 2.0, 5.0, 6.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse"]
|
||||
fn _mm_movemask_ps() {
|
||||
let r = unsafe {
|
||||
sse::_mm_movemask_ps(f32x4::new(-1.0, 5.0, -5.0, 0.0))
|
||||
};
|
||||
unsafe fn _mm_movemask_ps() {
|
||||
let r = sse::_mm_movemask_ps(f32x4::new(-1.0, 5.0, -5.0, 0.0));
|
||||
assert_eq!(r, 0b0101);
|
||||
|
||||
let r = unsafe {
|
||||
sse::_mm_movemask_ps(f32x4::new(-1.0, -5.0, -5.0, 0.0))
|
||||
};
|
||||
let r = sse::_mm_movemask_ps(f32x4::new(-1.0, -5.0, -5.0, 0.0));
|
||||
assert_eq!(r, 0b0111);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -79,7 +79,7 @@ mod tests {
|
|||
use x86::sse41;
|
||||
|
||||
#[simd_test = "sse4.1"]
|
||||
fn _mm_blendv_epi8() {
|
||||
unsafe fn _mm_blendv_epi8() {
|
||||
let a = i8x16::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let b = i8x16::new(
|
||||
|
|
@ -88,22 +88,22 @@ mod tests {
|
|||
0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1);
|
||||
let e = i8x16::new(
|
||||
0, 17, 2, 19, 4, 21, 6, 23, 8, 25, 10, 27, 12, 29, 14, 31);
|
||||
assert_eq!(unsafe { sse41::_mm_blendv_epi8(a, b, mask) }, e);
|
||||
assert_eq!(sse41::_mm_blendv_epi8(a, b, mask), e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse4.1"]
|
||||
fn _mm_dp_pd() {
|
||||
unsafe fn _mm_dp_pd() {
|
||||
let a = f64x2::new(2.0, 3.0);
|
||||
let b = f64x2::new(1.0, 4.0);
|
||||
let e = f64x2::new(14.0, 0.0);
|
||||
assert_eq!(unsafe { sse41::_mm_dp_pd(a, b, 0b00110001) }, e);
|
||||
assert_eq!(sse41::_mm_dp_pd(a, b, 0b00110001), e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse4.1"]
|
||||
fn _mm_dp_ps() {
|
||||
unsafe fn _mm_dp_ps() {
|
||||
let a = f32x4::new(2.0, 3.0, 1.0, 10.0);
|
||||
let b = f32x4::new(1.0, 4.0, 0.5, 10.0);
|
||||
let e = f32x4::new(14.5, 0.0, 14.5, 0.0);
|
||||
assert_eq!(unsafe { sse41::_mm_dp_ps(a, b, 0b01110101) }, e);
|
||||
assert_eq!(sse41::_mm_dp_ps(a, b, 0b01110101), e);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -56,15 +56,13 @@ mod tests {
|
|||
use x86::{__m128i, sse42};
|
||||
|
||||
#[simd_test = "sse4.2"]
|
||||
fn _mm_cmpestri() {
|
||||
unsafe fn _mm_cmpestri() {
|
||||
let a = &b"bar "[..];
|
||||
let b = &b"foobar "[..];
|
||||
let va = __m128i::from(u8x16::load(a, 0));
|
||||
let vb = __m128i::from(u8x16::load(b, 0));
|
||||
let i = unsafe {
|
||||
sse42::_mm_cmpestri(
|
||||
va, 3, vb, 6, sse42::_SIDD_CMP_EQUAL_ORDERED)
|
||||
};
|
||||
let i = sse42::_mm_cmpestri(
|
||||
va, 3, vb, 6, sse42::_SIDD_CMP_EQUAL_ORDERED);
|
||||
assert_eq!(3, i);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,13 +60,13 @@ mod tests {
|
|||
use x86::ssse3 as ssse3;
|
||||
|
||||
#[simd_test = "ssse3"]
|
||||
fn _mm_abs_epi8() {
|
||||
let r = unsafe { ssse3::_mm_abs_epi8(i8x16::splat(-5)) };
|
||||
unsafe fn _mm_abs_epi8() {
|
||||
let r = ssse3::_mm_abs_epi8(i8x16::splat(-5));
|
||||
assert_eq!(r, u8x16::splat(5));
|
||||
}
|
||||
|
||||
#[simd_test = "ssse3"]
|
||||
fn _mm_shuffle_epi8() {
|
||||
unsafe fn _mm_shuffle_epi8() {
|
||||
let a = u8x16::new(
|
||||
1, 2, 3, 4,
|
||||
5, 6, 7, 8,
|
||||
|
|
@ -85,7 +85,7 @@ mod tests {
|
|||
13, 6, 6, 11,
|
||||
5, 2, 9, 1,
|
||||
);
|
||||
let r = unsafe { ssse3::_mm_shuffle_epi8(a, b) };
|
||||
let r = ssse3::_mm_shuffle_epi8(a, b);
|
||||
assert_eq!(r, expected);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -260,186 +260,186 @@ mod tests {
|
|||
|
||||
/*
|
||||
#[simd_test = "tbm"]
|
||||
fn _bextr_u32() {
|
||||
unsafe fn _bextr_u32() {
|
||||
assert_eq!(tbm::_bextr_u32(0b0101_0000u32, 4, 4), 0b0000_0101u32);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
fn _bextr_u64() {
|
||||
unsafe fn _bextr_u64() {
|
||||
assert_eq!(tbm::_bextr_u64(0b0101_0000u64, 4, 4), 0b0000_0101u64);
|
||||
}
|
||||
*/
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
fn _blcfill_u32() {
|
||||
unsafe fn _blcfill_u32() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcfill_u32(0b0101_0111u32) },
|
||||
tbm::_blcfill_u32(0b0101_0111u32),
|
||||
0b0101_0000u32);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcfill_u32(0b1111_1111u32) },
|
||||
tbm::_blcfill_u32(0b1111_1111u32),
|
||||
0u32);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _blcfill_u64() {
|
||||
unsafe fn _blcfill_u64() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcfill_u64(0b0101_0111u64) },
|
||||
tbm::_blcfill_u64(0b0101_0111u64),
|
||||
0b0101_0000u64);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcfill_u64(0b1111_1111u64) },
|
||||
tbm::_blcfill_u64(0b1111_1111u64),
|
||||
0u64);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
fn _blci_u32() {
|
||||
unsafe fn _blci_u32() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blci_u32(0b0101_0000u32) },
|
||||
tbm::_blci_u32(0b0101_0000u32),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1110u32);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blci_u32(0b1111_1111u32) },
|
||||
tbm::_blci_u32(0b1111_1111u32),
|
||||
0b1111_1111_1111_1111_1111_1110_1111_1111u32);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _blci_u64() {
|
||||
unsafe fn _blci_u64() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blci_u64(0b0101_0000u64) },
|
||||
tbm::_blci_u64(0b0101_0000u64),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110u64);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blci_u64(0b1111_1111u64) },
|
||||
tbm::_blci_u64(0b1111_1111u64),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1110_1111_1111u64);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
fn _blcic_u32() {
|
||||
unsafe fn _blcic_u32() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcic_u32(0b0101_0001u32) },
|
||||
tbm::_blcic_u32(0b0101_0001u32),
|
||||
0b0000_0010u32);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcic_u32(0b1111_1111u32) },
|
||||
tbm::_blcic_u32(0b1111_1111u32),
|
||||
0b1_0000_0000u32);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _blcic_u64() {
|
||||
unsafe fn _blcic_u64() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcic_u64(0b0101_0001u64) },
|
||||
tbm::_blcic_u64(0b0101_0001u64),
|
||||
0b0000_0010u64);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcic_u64(0b1111_1111u64) },
|
||||
tbm::_blcic_u64(0b1111_1111u64),
|
||||
0b1_0000_0000u64);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
fn _blcmsk_u32() {
|
||||
unsafe fn _blcmsk_u32() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcmsk_u32(0b0101_0001u32) },
|
||||
tbm::_blcmsk_u32(0b0101_0001u32),
|
||||
0b0000_0011u32);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcmsk_u32(0b1111_1111u32) },
|
||||
tbm::_blcmsk_u32(0b1111_1111u32),
|
||||
0b1_1111_1111u32);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _blcmsk_u64() {
|
||||
unsafe fn _blcmsk_u64() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcmsk_u64(0b0101_0001u64) },
|
||||
tbm::_blcmsk_u64(0b0101_0001u64),
|
||||
0b0000_0011u64);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blcmsk_u64(0b1111_1111u64) },
|
||||
tbm::_blcmsk_u64(0b1111_1111u64),
|
||||
0b1_1111_1111u64);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
fn _blcs_u32() {
|
||||
assert_eq!(unsafe { tbm::_blcs_u32(0b0101_0001u32) }, 0b0101_0011u32);
|
||||
assert_eq!(unsafe { tbm::_blcs_u32(0b1111_1111u32) }, 0b1_1111_1111u32);
|
||||
unsafe fn _blcs_u32() {
|
||||
assert_eq!(tbm::_blcs_u32(0b0101_0001u32), 0b0101_0011u32);
|
||||
assert_eq!(tbm::_blcs_u32(0b1111_1111u32), 0b1_1111_1111u32);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _blcs_u64() {
|
||||
assert_eq!(unsafe { tbm::_blcs_u64(0b0101_0001u64) }, 0b0101_0011u64);
|
||||
assert_eq!(unsafe { tbm::_blcs_u64(0b1111_1111u64) }, 0b1_1111_1111u64);
|
||||
unsafe fn _blcs_u64() {
|
||||
assert_eq!(tbm::_blcs_u64(0b0101_0001u64), 0b0101_0011u64);
|
||||
assert_eq!(tbm::_blcs_u64(0b1111_1111u64), 0b1_1111_1111u64);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
fn _blsfill_u32() {
|
||||
unsafe fn _blsfill_u32() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blsfill_u32(0b0101_0100u32) },
|
||||
tbm::_blsfill_u32(0b0101_0100u32),
|
||||
0b0101_0111u32);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blsfill_u32(0u32) },
|
||||
tbm::_blsfill_u32(0u32),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1111u32);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _blsfill_u64() {
|
||||
unsafe fn _blsfill_u64() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blsfill_u64(0b0101_0100u64) },
|
||||
tbm::_blsfill_u64(0b0101_0100u64),
|
||||
0b0101_0111u64);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blsfill_u64(0u64) },
|
||||
tbm::_blsfill_u64(0u64),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111u64);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
fn _blsic_u32() {
|
||||
unsafe fn _blsic_u32() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blsic_u32(0b0101_0100u32) },
|
||||
tbm::_blsic_u32(0b0101_0100u32),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1011u32);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blsic_u32(0u32) },
|
||||
tbm::_blsic_u32(0u32),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1111u32);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _blsic_u64() {
|
||||
unsafe fn _blsic_u64() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blsic_u64(0b0101_0100u64) },
|
||||
tbm::_blsic_u64(0b0101_0100u64),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1011u64);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_blsic_u64(0u64) },
|
||||
tbm::_blsic_u64(0u64),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111u64);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
fn _t1mskc_u32() {
|
||||
unsafe fn _t1mskc_u32() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_t1mskc_u32(0b0101_0111u32) },
|
||||
tbm::_t1mskc_u32(0b0101_0111u32),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1000u32);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_t1mskc_u32(0u32) },
|
||||
tbm::_t1mskc_u32(0u32),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1111u32);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _t1mksc_u64() {
|
||||
unsafe fn _t1mksc_u64() {
|
||||
assert_eq!(
|
||||
unsafe { tbm::_t1mskc_u64(0b0101_0111u64) },
|
||||
tbm::_t1mskc_u64(0b0101_0111u64),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1000u64);
|
||||
assert_eq!(
|
||||
unsafe { tbm::_t1mskc_u64(0u64) },
|
||||
tbm::_t1mskc_u64(0u64),
|
||||
0b1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111u64);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
fn _tzmsk_u32() {
|
||||
assert_eq!(unsafe { tbm::_tzmsk_u32(0b0101_1000u32) }, 0b0000_0111u32);
|
||||
assert_eq!(unsafe { tbm::_tzmsk_u32(0b0101_1001u32) }, 0b0000_0000u32);
|
||||
unsafe fn _tzmsk_u32() {
|
||||
assert_eq!(tbm::_tzmsk_u32(0b0101_1000u32), 0b0000_0111u32);
|
||||
assert_eq!(tbm::_tzmsk_u32(0b0101_1001u32), 0b0000_0000u32);
|
||||
}
|
||||
|
||||
#[simd_test = "tbm"]
|
||||
#[cfg(not(target_arch = "x86"))]
|
||||
fn _tzmsk_u64() {
|
||||
assert_eq!(unsafe { tbm::_tzmsk_u64(0b0101_1000u64) }, 0b0000_0111u64);
|
||||
assert_eq!(unsafe { tbm::_tzmsk_u64(0b0101_1001u64) }, 0b0000_0000u64);
|
||||
unsafe fn _tzmsk_u64() {
|
||||
assert_eq!(tbm::_tzmsk_u64(0b0101_1000u64), 0b0000_0111u64);
|
||||
assert_eq!(tbm::_tzmsk_u64(0b0101_1001u64), 0b0000_0000u64);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ pub fn simd_test(attr: proc_macro::TokenStream,
|
|||
#[test]
|
||||
fn #name() {
|
||||
if cfg_feature_enabled!(#target_feature) {
|
||||
return #name();
|
||||
return unsafe { #name() };
|
||||
}
|
||||
|
||||
#[target_feature = #enable_feature]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue