mirror of
https://github.com/rust-lang/rust.git
synced 2026-05-29 12:36:35 +03:00
crate: use unsafe in tests
This commit is contained in:
Andrew Gallant
@@ -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 @@ fn _mm256_round_pd() {
|
||||
}
|
||||
|
||||
#[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);
|
||||
}
|
||||
|
||||
+208
-208
@@ -1150,11 +1150,11 @@ mod tests {
|
||||
use std;
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_abs_epi32() {
|
||||
unsafe fn _mm256_abs_epi32() {
|
||||
let a = i32x8::new(
|
||||
0, 1, -1, std::i32::MAX,
|
||||
std::i32::MIN + 1, 100, -100, -32);
|
||||
let r = unsafe { avx2::_mm256_abs_epi32(a) };
|
||||
let r = avx2::_mm256_abs_epi32(a);
|
||||
let e = i32x8::new(
|
||||
0, 1, 1, std::i32::MAX,
|
||||
(std::i32::MIN + 1).abs(), 100, 100, 32);
|
||||
@@ -1162,13 +1162,13 @@ fn _mm256_abs_epi32() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_abs_epi16() {
|
||||
unsafe fn _mm256_abs_epi16() {
|
||||
let a = i16x16::new(
|
||||
0, 1, -1, 2,
|
||||
-2, 3, -3, 4,
|
||||
-4, 5, -5, std::i16::MAX,
|
||||
std::i16::MIN + 1, 100, -100, -32);
|
||||
let r = unsafe { avx2::_mm256_abs_epi16(a) };
|
||||
let r = avx2::_mm256_abs_epi16(a);
|
||||
let e = i16x16::new(
|
||||
0, 1, 1, 2,
|
||||
2, 3, 3, 4,
|
||||
@@ -1178,7 +1178,7 @@ fn _mm256_abs_epi16() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_abs_epi8() {
|
||||
unsafe fn _mm256_abs_epi8() {
|
||||
let a = i8x32::new(
|
||||
0, 1, -1, 2,
|
||||
-2, 3, -3, 4,
|
||||
@@ -1188,7 +1188,7 @@ fn _mm256_abs_epi8() {
|
||||
-2, 3, -3, 4,
|
||||
-4, 5, -5, std::i8::MAX,
|
||||
std::i8::MIN + 1, 100, -100, -32);
|
||||
let r = unsafe { avx2::_mm256_abs_epi8(a) };
|
||||
let r = avx2::_mm256_abs_epi8(a);
|
||||
let e = i8x32::new(
|
||||
0, 1, 1, 2, 2, 3, 3, 4,
|
||||
4, 5, 5, std::i8::MAX, (std::i8::MIN + 1).abs(), 100, 100, 32,
|
||||
@@ -1198,32 +1198,32 @@ fn _mm256_abs_epi8() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_add_epi64() {
|
||||
unsafe fn _mm256_add_epi64() {
|
||||
let a = i64x4::new(-10, 0, 100, 1_000_000_000);
|
||||
let b = i64x4::new(-1, 0, 1, 2);
|
||||
let r = unsafe { avx2::_mm256_add_epi64(a, b) };
|
||||
let r = avx2::_mm256_add_epi64(a, b);
|
||||
let e = i64x4::new(-11, 0, 101, 1_000_000_002);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_add_epi32() {
|
||||
unsafe fn _mm256_add_epi32() {
|
||||
let a = i32x8::new(-1, 0, 1, 2, 3, 4, 5, 6);
|
||||
let b = i32x8::new(1, 2, 3, 4, 5, 6, 7, 8);
|
||||
let r = unsafe { avx2::_mm256_add_epi32(a, b) };
|
||||
let r = avx2::_mm256_add_epi32(a, b);
|
||||
let e = i32x8::new(0, 2, 4, 6, 8, 10, 12, 14);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_add_epi16() {
|
||||
unsafe fn _mm256_add_epi16() {
|
||||
let a = i16x16::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7,
|
||||
8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let b = i16x16::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7,
|
||||
8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let r = unsafe { avx2::_mm256_add_epi16(a, b) };
|
||||
let r = avx2::_mm256_add_epi16(a, b);
|
||||
let e = i16x16::new(
|
||||
0, 2, 4, 6, 8, 10, 12, 14,
|
||||
16, 18, 20, 22, 24, 26, 28, 30);
|
||||
@@ -1231,7 +1231,7 @@ fn _mm256_add_epi16() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_add_epi8() {
|
||||
unsafe fn _mm256_add_epi8() {
|
||||
let a = i8x32::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7,
|
||||
8, 9, 10, 11, 12, 13, 14, 15,
|
||||
@@ -1242,7 +1242,7 @@ fn _mm256_add_epi8() {
|
||||
8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23,
|
||||
24, 25, 26, 27, 28, 29, 30, 31);
|
||||
let r = unsafe { avx2::_mm256_add_epi8(a, b) };
|
||||
let r = avx2::_mm256_add_epi8(a, b);
|
||||
let e = i8x32::new(
|
||||
0, 2, 4, 6, 8, 10, 12, 14, 16,
|
||||
18, 20, 22, 24, 26, 28, 30, 32,
|
||||
@@ -1252,14 +1252,14 @@ fn _mm256_add_epi8() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_adds_epi8() {
|
||||
unsafe fn _mm256_adds_epi8() {
|
||||
let a = i8x32::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
|
||||
let b = i8x32::new(
|
||||
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
|
||||
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63);
|
||||
let r = unsafe { avx2::_mm256_adds_epi8(a, b) };
|
||||
let r = avx2::_mm256_adds_epi8(a, b);
|
||||
let e = i8x32::new(
|
||||
32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62,
|
||||
64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94);
|
||||
@@ -1267,28 +1267,28 @@ fn _mm256_adds_epi8() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_adds_epi8_saturate_positive() {
|
||||
unsafe fn _mm256_adds_epi8_saturate_positive() {
|
||||
let a = i8x32::splat(0x7F);
|
||||
let b = i8x32::splat(1);
|
||||
let r = unsafe { avx2::_mm256_adds_epi8(a, b) };
|
||||
let r = avx2::_mm256_adds_epi8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_adds_epi8_saturate_negative() {
|
||||
unsafe fn _mm256_adds_epi8_saturate_negative() {
|
||||
let a = i8x32::splat(-0x80);
|
||||
let b = i8x32::splat(-1);
|
||||
let r = unsafe { avx2::_mm256_adds_epi8(a, b) };
|
||||
let r = avx2::_mm256_adds_epi8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_adds_epi16() {
|
||||
unsafe fn _mm256_adds_epi16() {
|
||||
let a = i16x16::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let b = i16x16::new(
|
||||
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47);
|
||||
let r = unsafe { avx2::_mm256_adds_epi16(a, b) };
|
||||
let r = avx2::_mm256_adds_epi16(a, b);
|
||||
let e = i16x16::new(
|
||||
32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62);
|
||||
|
||||
@@ -1296,30 +1296,30 @@ fn _mm256_adds_epi16() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_adds_epi16_saturate_positive() {
|
||||
unsafe fn _mm256_adds_epi16_saturate_positive() {
|
||||
let a = i16x16::splat(0x7FFF);
|
||||
let b = i16x16::splat(1);
|
||||
let r = unsafe { avx2::_mm256_adds_epi16(a, b) };
|
||||
let r = avx2::_mm256_adds_epi16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_adds_epi16_saturate_negative() {
|
||||
unsafe fn _mm256_adds_epi16_saturate_negative() {
|
||||
let a = i16x16::splat(-0x8000);
|
||||
let b = i16x16::splat(-1);
|
||||
let r = unsafe { avx2::_mm256_adds_epi16(a, b) };
|
||||
let r = avx2::_mm256_adds_epi16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_adds_epu8() {
|
||||
unsafe fn _mm256_adds_epu8() {
|
||||
let a = u8x32::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
|
||||
let b = u8x32::new(
|
||||
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
|
||||
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63);
|
||||
let r = unsafe { avx2::_mm256_adds_epu8(a, b) };
|
||||
let r = avx2::_mm256_adds_epu8(a, b);
|
||||
let e = u8x32::new(
|
||||
32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62,
|
||||
64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94);
|
||||
@@ -1327,21 +1327,21 @@ fn _mm256_adds_epu8() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_adds_epu8_saturate() {
|
||||
unsafe fn _mm256_adds_epu8_saturate() {
|
||||
let a = u8x32::splat(0xFF);
|
||||
let b = u8x32::splat(1);
|
||||
let r = unsafe { avx2::_mm256_adds_epu8(a, b) };
|
||||
let r = avx2::_mm256_adds_epu8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_adds_epu16() {
|
||||
unsafe fn _mm256_adds_epu16() {
|
||||
let a = u16x16::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let b = u16x16::new(
|
||||
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47);
|
||||
let r = unsafe { avx2::_mm256_adds_epu16(a, b) };
|
||||
let r = avx2::_mm256_adds_epu16(a, b);
|
||||
let e = u16x16::new(
|
||||
32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62);
|
||||
|
||||
@@ -1349,290 +1349,290 @@ fn _mm256_adds_epu16() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_adds_epu16_saturate() {
|
||||
unsafe fn _mm256_adds_epu16_saturate() {
|
||||
let a = u16x16::splat(0xFFFF);
|
||||
let b = u16x16::splat(1);
|
||||
let r = unsafe { avx2::_mm256_adds_epu16(a, b) };
|
||||
let r = avx2::_mm256_adds_epu16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_and_si256() {
|
||||
let got = unsafe {
|
||||
avx2::_mm256_and_si256(__m256i::splat(5), __m256i::splat(3))
|
||||
};
|
||||
unsafe fn _mm256_and_si256() {
|
||||
let a = __m256i::splat(5);
|
||||
let b = __m256i::splat(3);
|
||||
let got = avx2::_mm256_and_si256(a, b);
|
||||
assert_eq!(got, __m256i::splat(1));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_andnot_si256() {
|
||||
let got = unsafe {
|
||||
avx2::_mm256_andnot_si256(__m256i::splat(5), __m256i::splat(3))
|
||||
};
|
||||
unsafe fn _mm256_andnot_si256() {
|
||||
let a = __m256i::splat(5);
|
||||
let b = __m256i::splat(3);
|
||||
let got = avx2::_mm256_andnot_si256(a, b);
|
||||
assert_eq!(got, __m256i::splat(2));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_avg_epu8() {
|
||||
unsafe fn _mm256_avg_epu8() {
|
||||
let (a, b) = (u8x32::splat(3), u8x32::splat(9));
|
||||
let r = unsafe { avx2::_mm256_avg_epu8(a, b) };
|
||||
let r = avx2::_mm256_avg_epu8(a, b);
|
||||
assert_eq!(r, u8x32::splat(6));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_avg_epu16() {
|
||||
unsafe fn _mm256_avg_epu16() {
|
||||
let (a, b) = (u16x16::splat(3), u16x16::splat(9));
|
||||
let r = unsafe { avx2::_mm256_avg_epu16(a, b) };
|
||||
let r = avx2::_mm256_avg_epu16(a, b);
|
||||
assert_eq!(r, u16x16::splat(6));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_blendv_epi8() {
|
||||
unsafe fn _mm256_blendv_epi8() {
|
||||
let (a,b) = (i8x32::splat(4),i8x32::splat(2));
|
||||
let mask = i8x32::splat(0).replace(2,-1);
|
||||
let e = i8x32::splat(4).replace(2,2);
|
||||
let r= unsafe { avx2::_mm256_blendv_epi8(a,b,mask) };
|
||||
let r= avx2::_mm256_blendv_epi8(a,b,mask);
|
||||
assert_eq!(r,e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_cmpeq_epi8() {
|
||||
unsafe fn _mm256_cmpeq_epi8() {
|
||||
let a = i8x32::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
|
||||
let b = i8x32::new(
|
||||
31, 30, 2, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
|
||||
15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
let r = unsafe { avx2::_mm256_cmpeq_epi8(a, b) };
|
||||
let r = avx2::_mm256_cmpeq_epi8(a, b);
|
||||
assert_eq!(r, i8x32::splat(0).replace(2,0xFFu8 as i8));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_cmpeq_epi16() {
|
||||
unsafe fn _mm256_cmpeq_epi16() {
|
||||
let a = i16x16::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let b = i16x16::new(
|
||||
15, 14, 2, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
let r = unsafe { avx2::_mm256_cmpeq_epi16(a, b) };
|
||||
let r = avx2::_mm256_cmpeq_epi16(a, b);
|
||||
assert_eq!(r, i16x16::splat(0).replace(2, 0xFFFFu16 as i16));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_cmpeq_epi32() {
|
||||
unsafe fn _mm256_cmpeq_epi32() {
|
||||
let a = i32x8::new(0, 1, 2, 3,4,5,6,7);
|
||||
let b = i32x8::new(7,6,2,4,3, 2, 1, 0);
|
||||
let r = unsafe { avx2::_mm256_cmpeq_epi32(a, b) };
|
||||
let r = avx2::_mm256_cmpeq_epi32(a, b);
|
||||
assert_eq!(r, i32x8::splat(0).replace(2, 0xFFFFFFFFu32 as i32));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_cmpeq_epi64() {
|
||||
unsafe fn _mm256_cmpeq_epi64() {
|
||||
let a = i64x4::new(0, 1, 2, 3);
|
||||
let b = i64x4::new(3, 2, 2, 0);
|
||||
let r = unsafe { avx2::_mm256_cmpeq_epi64(a, b) };
|
||||
let r = avx2::_mm256_cmpeq_epi64(a, b);
|
||||
assert_eq!(r, i64x4::splat(0).replace(
|
||||
2, 0xFFFFFFFFFFFFFFFFu64 as i64));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_cmpgt_epi8() {
|
||||
unsafe fn _mm256_cmpgt_epi8() {
|
||||
let a = i8x32::splat(0).replace(0, 5);
|
||||
let b = i8x32::splat(0);
|
||||
let r = unsafe { avx2::_mm256_cmpgt_epi8(a, b) };
|
||||
let r = avx2::_mm256_cmpgt_epi8(a, b);
|
||||
assert_eq!(r, i8x32::splat(0).replace(0, 0xFFu8 as i8));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_cmpgt_epi16() {
|
||||
unsafe fn _mm256_cmpgt_epi16() {
|
||||
let a = i16x16::splat(0).replace(0, 5);
|
||||
let b = i16x16::splat(0);
|
||||
let r = unsafe { avx2::_mm256_cmpgt_epi16(a, b) };
|
||||
let r = avx2::_mm256_cmpgt_epi16(a, b);
|
||||
assert_eq!(r, i16x16::splat(0).replace(0, 0xFFFFu16 as i16));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_cmpgt_epi32() {
|
||||
unsafe fn _mm256_cmpgt_epi32() {
|
||||
let a = i32x8::splat(0).replace(0, 5);
|
||||
let b = i32x8::splat(0);
|
||||
let r = unsafe { avx2::_mm256_cmpgt_epi32(a, b) };
|
||||
let r = avx2::_mm256_cmpgt_epi32(a, b);
|
||||
assert_eq!(r, i32x8::splat(0).replace(0, 0xFFFFFFFFu32 as i32));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_cmpgt_epi64() {
|
||||
unsafe fn _mm256_cmpgt_epi64() {
|
||||
let a = i64x4::splat(0).replace(0, 5);
|
||||
let b = i64x4::splat(0);
|
||||
let r = unsafe { avx2::_mm256_cmpgt_epi64(a, b) };
|
||||
let r = avx2::_mm256_cmpgt_epi64(a, b);
|
||||
assert_eq!(r, i64x4::splat(0).replace(
|
||||
0, 0xFFFFFFFFFFFFFFFFu64 as i64));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_hadd_epi16() {
|
||||
unsafe fn _mm256_hadd_epi16() {
|
||||
let a = i16x16::splat(2);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_hadd_epi16(a, b) };
|
||||
let r = avx2::_mm256_hadd_epi16(a, b);
|
||||
let e = i16x16::new(4, 4, 4, 4, 8, 8, 8, 8, 4, 4, 4, 4, 8, 8, 8, 8);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_hadd_epi32() {
|
||||
unsafe fn _mm256_hadd_epi32() {
|
||||
let a = i32x8::splat(2);
|
||||
let b = i32x8::splat(4);
|
||||
let r = unsafe { avx2::_mm256_hadd_epi32(a, b) };
|
||||
let r = avx2::_mm256_hadd_epi32(a, b);
|
||||
let e = i32x8::new(4, 4, 8, 8, 4, 4, 8, 8);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_hadds_epi16() {
|
||||
unsafe fn _mm256_hadds_epi16() {
|
||||
let a = i16x16::splat(2).replace(0,0x7FFF).replace(1,1);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_hadds_epi16(a, b) };
|
||||
let r = avx2::_mm256_hadds_epi16(a, b);
|
||||
let e = i16x16::new(
|
||||
0x7FFF, 4, 4, 4, 8, 8, 8, 8, 4, 4, 4, 4, 8, 8, 8, 8);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_hsub_epi16() {
|
||||
unsafe fn _mm256_hsub_epi16() {
|
||||
let a = i16x16::splat(2);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_hsub_epi16(a, b) };
|
||||
let r = avx2::_mm256_hsub_epi16(a, b);
|
||||
let e = i16x16::splat(0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_hsub_epi32() {
|
||||
unsafe fn _mm256_hsub_epi32() {
|
||||
let a = i32x8::splat(2);
|
||||
let b = i32x8::splat(4);
|
||||
let r = unsafe { avx2::_mm256_hsub_epi32(a, b) };
|
||||
let r = avx2::_mm256_hsub_epi32(a, b);
|
||||
let e = i32x8::splat(0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_hsubs_epi16() {
|
||||
unsafe fn _mm256_hsubs_epi16() {
|
||||
let a = i16x16::splat(2).replace(0,0x7FFF).replace(1,-1);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_hsubs_epi16(a, b) };
|
||||
let r = avx2::_mm256_hsubs_epi16(a, b);
|
||||
let e = i16x16::splat(0).replace(0,0x7FFF);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_madd_epi16() {
|
||||
unsafe fn _mm256_madd_epi16() {
|
||||
let a = i16x16::splat(2);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_madd_epi16(a, b) };
|
||||
let r = avx2::_mm256_madd_epi16(a, b);
|
||||
let e = i32x8::splat(16);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_maddubs_epi16() {
|
||||
unsafe fn _mm256_maddubs_epi16() {
|
||||
let a = u8x32::splat(2);
|
||||
let b = u8x32::splat(4);
|
||||
let r = unsafe { avx2::_mm256_maddubs_epi16(a, b) };
|
||||
let r = avx2::_mm256_maddubs_epi16(a, b);
|
||||
let e = i16x16::splat(16);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_max_epi16() {
|
||||
unsafe fn _mm256_max_epi16() {
|
||||
let a = i16x16::splat(2);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_max_epi16(a, b) };
|
||||
let r = avx2::_mm256_max_epi16(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_max_epi32() {
|
||||
unsafe fn _mm256_max_epi32() {
|
||||
let a = i32x8::splat(2);
|
||||
let b = i32x8::splat(4);
|
||||
let r = unsafe { avx2::_mm256_max_epi32(a, b) };
|
||||
let r = avx2::_mm256_max_epi32(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_max_epi8() {
|
||||
unsafe fn _mm256_max_epi8() {
|
||||
let a = i8x32::splat(2);
|
||||
let b = i8x32::splat(4);
|
||||
let r = unsafe { avx2::_mm256_max_epi8(a, b) };
|
||||
let r = avx2::_mm256_max_epi8(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_max_epu16() {
|
||||
unsafe fn _mm256_max_epu16() {
|
||||
let a = u16x16::splat(2);
|
||||
let b = u16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_max_epu16(a, b) };
|
||||
let r = avx2::_mm256_max_epu16(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_max_epu32() {
|
||||
unsafe fn _mm256_max_epu32() {
|
||||
let a = u32x8::splat(2);
|
||||
let b = u32x8::splat(4);
|
||||
let r = unsafe { avx2::_mm256_max_epu32(a, b) };
|
||||
let r = avx2::_mm256_max_epu32(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_max_epu8() {
|
||||
unsafe fn _mm256_max_epu8() {
|
||||
let a = u8x32::splat(2);
|
||||
let b = u8x32::splat(4);
|
||||
let r = unsafe { avx2::_mm256_max_epu8(a, b) };
|
||||
let r = avx2::_mm256_max_epu8(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_min_epi16() {
|
||||
unsafe fn _mm256_min_epi16() {
|
||||
let a = i16x16::splat(2);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_min_epi16(a, b) };
|
||||
let r = avx2::_mm256_min_epi16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_min_epi32() {
|
||||
unsafe fn _mm256_min_epi32() {
|
||||
let a = i32x8::splat(2);
|
||||
let b = i32x8::splat(4);
|
||||
let r = unsafe { avx2::_mm256_min_epi32(a, b) };
|
||||
let r = avx2::_mm256_min_epi32(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_min_epi8() {
|
||||
unsafe fn _mm256_min_epi8() {
|
||||
let a = i8x32::splat(2);
|
||||
let b = i8x32::splat(4);
|
||||
let r = unsafe { avx2::_mm256_min_epi8(a, b) };
|
||||
let r = avx2::_mm256_min_epi8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_min_epu16() {
|
||||
unsafe fn _mm256_min_epu16() {
|
||||
let a = u16x16::splat(2);
|
||||
let b = u16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_min_epu16(a, b) };
|
||||
let r = avx2::_mm256_min_epu16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_min_epu32() {
|
||||
unsafe fn _mm256_min_epu32() {
|
||||
let a = u32x8::splat(2);
|
||||
let b = u32x8::splat(4);
|
||||
let r = unsafe { avx2::_mm256_min_epu32(a, b) };
|
||||
let r = avx2::_mm256_min_epu32(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_min_epu8() {
|
||||
unsafe fn _mm256_min_epu8() {
|
||||
let a = u8x32::splat(2);
|
||||
let b = u8x32::splat(4);
|
||||
let r = unsafe { avx2::_mm256_min_epu8(a, b) };
|
||||
let r = avx2::_mm256_min_epu8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
@@ -1641,7 +1641,7 @@ fn _mm256_min_epu8() {
|
||||
// TODO this fails in debug but not release, why?
|
||||
#[test]
|
||||
#[target_feature ="+avx2"]
|
||||
fn _mm256_movemask_epi8() {
|
||||
unsafe fn _mm256_movemask_epi8() {
|
||||
let a = i8x32::splat(-1);
|
||||
let r = avx2::_mm256_movemask_epi8(a);
|
||||
let e : i32 = -1;
|
||||
@@ -1651,7 +1651,7 @@ fn _mm256_movemask_epi8() {
|
||||
// TODO This fails in debug but not in release, whhhy?
|
||||
#[test]
|
||||
#[target_feature = "+avx2"]
|
||||
fn _mm256_mpsadbw_epu8() {
|
||||
unsafe fn _mm256_mpsadbw_epu8() {
|
||||
let a = u8x32::splat(2);
|
||||
let b = u8x32::splat(4);
|
||||
let r = avx2::_mm256_mpsadbw_epu8(a, b, 0);
|
||||
@@ -1661,81 +1661,81 @@ fn _mm256_mpsadbw_epu8() {
|
||||
**/
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_mul_epi32() {
|
||||
unsafe fn _mm256_mul_epi32() {
|
||||
let a = i32x8::new(0, 0, 0, 0, 2, 2, 2, 2);
|
||||
let b = i32x8::new(1, 2, 3, 4, 5, 6, 7, 8);
|
||||
let r = unsafe { avx2::_mm256_mul_epi32(a, b) };
|
||||
let r = avx2::_mm256_mul_epi32(a, b);
|
||||
let e = i64x4::new(0, 0, 10, 14);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_mul_epu32() {
|
||||
unsafe fn _mm256_mul_epu32() {
|
||||
let a = u32x8::new(0, 0, 0, 0, 2, 2, 2, 2);
|
||||
let b = u32x8::new(1, 2, 3, 4, 5, 6, 7, 8);
|
||||
let r = unsafe { avx2::_mm256_mul_epu32(a, b) };
|
||||
let r = avx2::_mm256_mul_epu32(a, b);
|
||||
let e = u64x4::new(0, 0, 10, 14);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_mulhi_epi16() {
|
||||
unsafe fn _mm256_mulhi_epi16() {
|
||||
let a = i16x16::splat(6535);
|
||||
let b = i16x16::splat(6535);
|
||||
let r = unsafe { avx2::_mm256_mulhi_epi16(a, b) };
|
||||
let r = avx2::_mm256_mulhi_epi16(a, b);
|
||||
let e = i16x16::splat(651);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_mulhi_epu16() {
|
||||
unsafe fn _mm256_mulhi_epu16() {
|
||||
let a = u16x16::splat(6535);
|
||||
let b = u16x16::splat(6535);
|
||||
let r = unsafe { avx2::_mm256_mulhi_epu16(a, b) };
|
||||
let r = avx2::_mm256_mulhi_epu16(a, b);
|
||||
let e = u16x16::splat(651);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_mullo_epi16() {
|
||||
unsafe fn _mm256_mullo_epi16() {
|
||||
let a = i16x16::splat(2);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_mullo_epi16(a, b) };
|
||||
let r = avx2::_mm256_mullo_epi16(a, b);
|
||||
let e = i16x16::splat(8);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_mullo_epi32() {
|
||||
unsafe fn _mm256_mullo_epi32() {
|
||||
let a = i32x8::splat(2);
|
||||
let b = i32x8::splat(4);
|
||||
let r = unsafe { avx2::_mm256_mullo_epi32(a, b) };
|
||||
let r = avx2::_mm256_mullo_epi32(a, b);
|
||||
let e = i32x8::splat(8);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_mulhrs_epi16() {
|
||||
unsafe fn _mm256_mulhrs_epi16() {
|
||||
let a = i16x16::splat(2);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_mullo_epi16(a, b) };
|
||||
let r = avx2::_mm256_mullo_epi16(a, b);
|
||||
let e = i16x16::splat(8);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_or_si256() {
|
||||
unsafe fn _mm256_or_si256() {
|
||||
let a = __m256i::splat(-1);
|
||||
let b = __m256i::splat(0);
|
||||
let r = unsafe { avx2::_mm256_or_si256(a, b) };
|
||||
let r = avx2::_mm256_or_si256(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_packs_epi16() {
|
||||
unsafe fn _mm256_packs_epi16() {
|
||||
let a = i16x16::splat(2);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_packs_epi16(a, b) };
|
||||
let r = avx2::_mm256_packs_epi16(a, b);
|
||||
let e = i8x32::new(
|
||||
2, 2, 2, 2, 2, 2, 2, 2,
|
||||
4, 4, 4, 4, 4, 4, 4, 4,
|
||||
@@ -1746,10 +1746,10 @@ fn _mm256_packs_epi16() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_packs_epi32() {
|
||||
unsafe fn _mm256_packs_epi32() {
|
||||
let a = i32x8::splat(2);
|
||||
let b = i32x8::splat(4);
|
||||
let r = unsafe { avx2::_mm256_packs_epi32(a, b) };
|
||||
let r = avx2::_mm256_packs_epi32(a, b);
|
||||
let e = i16x16::new(
|
||||
2, 2, 2, 2,
|
||||
4, 4, 4, 4,
|
||||
@@ -1760,10 +1760,10 @@ fn _mm256_packs_epi32() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_packus_epi16() {
|
||||
unsafe fn _mm256_packus_epi16() {
|
||||
let a = i16x16::splat(2);
|
||||
let b = i16x16::splat(4);
|
||||
let r = unsafe { avx2::_mm256_packus_epi16(a, b) };
|
||||
let r = avx2::_mm256_packus_epi16(a, b);
|
||||
let e = u8x32::new(
|
||||
2, 2, 2, 2, 2, 2, 2, 2,
|
||||
4, 4, 4, 4, 4, 4, 4, 4,
|
||||
@@ -1774,10 +1774,10 @@ fn _mm256_packus_epi16() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_packus_epi32() {
|
||||
unsafe fn _mm256_packus_epi32() {
|
||||
let a = i32x8::splat(2);
|
||||
let b = i32x8::splat(4);
|
||||
let r = unsafe { avx2::_mm256_packus_epi32(a, b) };
|
||||
let r = avx2::_mm256_packus_epi32(a, b);
|
||||
let e = u16x16::new(
|
||||
2, 2, 2, 2,
|
||||
4, 4, 4, 4,
|
||||
@@ -1788,321 +1788,321 @@ fn _mm256_packus_epi32() {
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sad_epu8() {
|
||||
unsafe fn _mm256_sad_epu8() {
|
||||
let a = u8x32::splat(2);
|
||||
let b = u8x32::splat(4);
|
||||
let r = unsafe { avx2::_mm256_sad_epu8(a, b) };
|
||||
let r = avx2::_mm256_sad_epu8(a, b);
|
||||
let e = u64x4::splat(16);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sign_epi16() {
|
||||
unsafe fn _mm256_sign_epi16() {
|
||||
let a = i16x16::splat(2);
|
||||
let b = i16x16::splat(-1);
|
||||
let r = unsafe { avx2::_mm256_sign_epi16(a, b) };
|
||||
let r = avx2::_mm256_sign_epi16(a, b);
|
||||
let e = i16x16::splat(-2);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sign_epi32() {
|
||||
unsafe fn _mm256_sign_epi32() {
|
||||
let a = i32x8::splat(2);
|
||||
let b = i32x8::splat(-1);
|
||||
let r = unsafe { avx2::_mm256_sign_epi32(a, b) };
|
||||
let r = avx2::_mm256_sign_epi32(a, b);
|
||||
let e = i32x8::splat(-2);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sign_epi8() {
|
||||
unsafe fn _mm256_sign_epi8() {
|
||||
let a = i8x32::splat(2);
|
||||
let b = i8x32::splat(-1);
|
||||
let r = unsafe { avx2::_mm256_sign_epi8(a, b) };
|
||||
let r = avx2::_mm256_sign_epi8(a, b);
|
||||
let e = i8x32::splat(-2);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sll_epi16() {
|
||||
unsafe fn _mm256_sll_epi16() {
|
||||
let a = i16x16::splat(0xFF);
|
||||
let b = i16x8::splat(0).replace(0, 4);
|
||||
let r = unsafe { avx2::_mm256_sll_epi16(a, b) };
|
||||
let r = avx2::_mm256_sll_epi16(a, b);
|
||||
assert_eq!(r, i16x16::splat(0xFF0));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sll_epi32() {
|
||||
unsafe fn _mm256_sll_epi32() {
|
||||
let a = i32x8::splat(0xFFFF);
|
||||
let b = i32x4::splat(0).replace(0, 4);
|
||||
let r = unsafe { avx2::_mm256_sll_epi32(a, b) };
|
||||
let r = avx2::_mm256_sll_epi32(a, b);
|
||||
assert_eq!(r, i32x8::splat(0xFFFF0));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sll_epi64() {
|
||||
unsafe fn _mm256_sll_epi64() {
|
||||
let a = i64x4::splat(0xFFFFFFFF);
|
||||
let b = i64x2::splat(0).replace(0, 4);
|
||||
let r = unsafe { avx2::_mm256_sll_epi64(a, b) };
|
||||
let r = avx2::_mm256_sll_epi64(a, b);
|
||||
assert_eq!(r, i64x4::splat(0xFFFFFFFF0));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_slli_epi16() {
|
||||
unsafe fn _mm256_slli_epi16() {
|
||||
assert_eq!(
|
||||
unsafe { avx2::_mm256_slli_epi16(i16x16::splat(0xFF), 4) },
|
||||
avx2::_mm256_slli_epi16(i16x16::splat(0xFF), 4),
|
||||
i16x16::splat(0xFF0));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_slli_epi32() {
|
||||
unsafe fn _mm256_slli_epi32() {
|
||||
assert_eq!(
|
||||
unsafe { avx2::_mm256_slli_epi32(i32x8::splat(0xFFFF), 4) },
|
||||
avx2::_mm256_slli_epi32(i32x8::splat(0xFFFF), 4),
|
||||
i32x8::splat(0xFFFF0));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_slli_epi64() {
|
||||
unsafe fn _mm256_slli_epi64() {
|
||||
assert_eq!(
|
||||
unsafe { avx2::_mm256_slli_epi64(i64x4::splat(0xFFFFFFFF), 4) },
|
||||
avx2::_mm256_slli_epi64(i64x4::splat(0xFFFFFFFF), 4),
|
||||
i64x4::splat(0xFFFFFFFF0));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm_sllv_epi32() {
|
||||
unsafe fn _mm_sllv_epi32() {
|
||||
let a = i32x4::splat(2);
|
||||
let b = i32x4::splat(1);
|
||||
let r = unsafe { avx2::_mm_sllv_epi32(a, b) };
|
||||
let r = avx2::_mm_sllv_epi32(a, b);
|
||||
let e = i32x4::splat(4);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sllv_epi32() {
|
||||
unsafe fn _mm256_sllv_epi32() {
|
||||
let a = i32x8::splat(2);
|
||||
let b = i32x8::splat(1);
|
||||
let r = unsafe { avx2::_mm256_sllv_epi32(a, b) };
|
||||
let r = avx2::_mm256_sllv_epi32(a, b);
|
||||
let e = i32x8::splat(4);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm_sllv_epi64() {
|
||||
unsafe fn _mm_sllv_epi64() {
|
||||
let a = i64x2::splat(2);
|
||||
let b = i64x2::splat(1);
|
||||
let r = unsafe { avx2::_mm_sllv_epi64(a, b) };
|
||||
let r = avx2::_mm_sllv_epi64(a, b);
|
||||
let e = i64x2::splat(4);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sllv_epi64() {
|
||||
unsafe fn _mm256_sllv_epi64() {
|
||||
let a = i64x4::splat(2);
|
||||
let b = i64x4::splat(1);
|
||||
let r = unsafe { avx2::_mm256_sllv_epi64(a, b) };
|
||||
let r = avx2::_mm256_sllv_epi64(a, b);
|
||||
let e = i64x4::splat(4);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sra_epi16() {
|
||||
unsafe fn _mm256_sra_epi16() {
|
||||
let a = i16x16::splat(-1);
|
||||
let b = i16x8::new(1, 0, 0, 0, 0, 0, 0, 0);
|
||||
let r = unsafe { avx2::_mm256_sra_epi16(a, b) };
|
||||
let r = avx2::_mm256_sra_epi16(a, b);
|
||||
assert_eq!(r, i16x16::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sra_epi32() {
|
||||
unsafe fn _mm256_sra_epi32() {
|
||||
let a = i32x8::splat(-1);
|
||||
let b = i32x4::splat(0).replace(0, 1);
|
||||
let r = unsafe { avx2::_mm256_sra_epi32(a, b) };
|
||||
let r = avx2::_mm256_sra_epi32(a, b);
|
||||
assert_eq!(r, i32x8::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srai_epi16() {
|
||||
unsafe fn _mm256_srai_epi16() {
|
||||
assert_eq!(
|
||||
unsafe { avx2::_mm256_srai_epi16(i16x16::splat(-1), 1) },
|
||||
avx2::_mm256_srai_epi16(i16x16::splat(-1), 1),
|
||||
i16x16::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srai_epi32() {
|
||||
unsafe fn _mm256_srai_epi32() {
|
||||
assert_eq!(
|
||||
unsafe { avx2::_mm256_srai_epi32(i32x8::splat(-1), 1) },
|
||||
avx2::_mm256_srai_epi32(i32x8::splat(-1), 1),
|
||||
i32x8::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm_srav_epi32() {
|
||||
unsafe fn _mm_srav_epi32() {
|
||||
let a = i32x4::splat(4);
|
||||
let count = i32x4::splat(1);
|
||||
let r = unsafe { avx2::_mm_srav_epi32(a, count) };
|
||||
let r = avx2::_mm_srav_epi32(a, count);
|
||||
let e = i32x4::splat(2);
|
||||
assert_eq!(r, e );
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srav_epi32() {
|
||||
unsafe fn _mm256_srav_epi32() {
|
||||
let a = i32x8::splat(4);
|
||||
let count = i32x8::splat(1);
|
||||
let r = unsafe { avx2::_mm256_srav_epi32(a, count) };
|
||||
let r = avx2::_mm256_srav_epi32(a, count);
|
||||
let e = i32x8::splat(2);
|
||||
assert_eq!(r, e );
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srl_epi16() {
|
||||
unsafe fn _mm256_srl_epi16() {
|
||||
let a = i16x16::splat(0xFF);
|
||||
let b = i16x8::splat(0).replace(0, 4);
|
||||
let r = unsafe { avx2::_mm256_srl_epi16(a, b) };
|
||||
let r = avx2::_mm256_srl_epi16(a, b);
|
||||
assert_eq!(r, i16x16::splat(0xF));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srl_epi32() {
|
||||
unsafe fn _mm256_srl_epi32() {
|
||||
let a = i32x8::splat(0xFFFF);
|
||||
let b = i32x4::splat(0).replace(0, 4);
|
||||
let r = unsafe { avx2::_mm256_srl_epi32(a, b) };
|
||||
let r = avx2::_mm256_srl_epi32(a, b);
|
||||
assert_eq!(r, i32x8::splat(0xFFF));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srl_epi64() {
|
||||
unsafe fn _mm256_srl_epi64() {
|
||||
let a = i64x4::splat(0xFFFFFFFF);
|
||||
let b = i64x2::splat(0).replace(0, 4);
|
||||
let r = unsafe { avx2::_mm256_srl_epi64(a, b) };
|
||||
let r = avx2::_mm256_srl_epi64(a, b);
|
||||
assert_eq!(r, i64x4::splat(0xFFFFFFF));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srli_epi16() {
|
||||
unsafe fn _mm256_srli_epi16() {
|
||||
assert_eq!(
|
||||
unsafe { avx2::_mm256_srli_epi16(i16x16::splat(0xFF), 4) },
|
||||
avx2::_mm256_srli_epi16(i16x16::splat(0xFF), 4),
|
||||
i16x16::splat(0xF));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srli_epi32() {
|
||||
unsafe fn _mm256_srli_epi32() {
|
||||
assert_eq!(
|
||||
unsafe { avx2::_mm256_srli_epi32(i32x8::splat(0xFFFF), 4) },
|
||||
avx2::_mm256_srli_epi32(i32x8::splat(0xFFFF), 4),
|
||||
i32x8::splat(0xFFF));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srli_epi64() {
|
||||
unsafe fn _mm256_srli_epi64() {
|
||||
assert_eq!(
|
||||
unsafe { avx2::_mm256_srli_epi64(i64x4::splat(0xFFFFFFFF), 4) },
|
||||
avx2::_mm256_srli_epi64(i64x4::splat(0xFFFFFFFF), 4),
|
||||
i64x4::splat(0xFFFFFFF));
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm_srlv_epi32() {
|
||||
unsafe fn _mm_srlv_epi32() {
|
||||
let a = i32x4::splat(2);
|
||||
let count = i32x4::splat(1);
|
||||
let r = unsafe { avx2::_mm_srlv_epi32(a, count) };
|
||||
let r = avx2::_mm_srlv_epi32(a, count);
|
||||
let e = i32x4::splat(1);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srlv_epi32() {
|
||||
unsafe fn _mm256_srlv_epi32() {
|
||||
let a = i32x8::splat(2);
|
||||
let count = i32x8::splat(1);
|
||||
let r = unsafe { avx2::_mm256_srlv_epi32(a, count) };
|
||||
let r = avx2::_mm256_srlv_epi32(a, count);
|
||||
let e = i32x8::splat(1);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm_srlv_epi64() {
|
||||
unsafe fn _mm_srlv_epi64() {
|
||||
let a = i64x2::splat(2);
|
||||
let count = i64x2::splat(1);
|
||||
let r = unsafe { avx2::_mm_srlv_epi64(a, count) };
|
||||
let r = avx2::_mm_srlv_epi64(a, count);
|
||||
let e = i64x2::splat(1);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_srlv_epi64() {
|
||||
unsafe fn _mm256_srlv_epi64() {
|
||||
let a = i64x4::splat(2);
|
||||
let count = i64x4::splat(1);
|
||||
let r = unsafe { avx2::_mm256_srlv_epi64(a, count) };
|
||||
let r = avx2::_mm256_srlv_epi64(a, count);
|
||||
let e = i64x4::splat(1);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sub_epi16() {
|
||||
unsafe fn _mm256_sub_epi16() {
|
||||
let a = i16x16::splat(4);
|
||||
let b = i16x16::splat(2);
|
||||
let r = unsafe { avx2::_mm256_sub_epi16(a, b) };
|
||||
let r = avx2::_mm256_sub_epi16(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sub_epi32() {
|
||||
unsafe fn _mm256_sub_epi32() {
|
||||
let a = i32x8::splat(4);
|
||||
let b = i32x8::splat(2);
|
||||
let r = unsafe { avx2::_mm256_sub_epi32(a, b) };
|
||||
let r = avx2::_mm256_sub_epi32(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sub_epi64() {
|
||||
unsafe fn _mm256_sub_epi64() {
|
||||
let a = i64x4::splat(4);
|
||||
let b = i64x4::splat(2);
|
||||
let r = unsafe { avx2::_mm256_sub_epi64(a, b) };
|
||||
let r = avx2::_mm256_sub_epi64(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_sub_epi8() {
|
||||
unsafe fn _mm256_sub_epi8() {
|
||||
let a = i8x32::splat(4);
|
||||
let b = i8x32::splat(2);
|
||||
let r = unsafe { avx2::_mm256_sub_epi8(a, b) };
|
||||
let r = avx2::_mm256_sub_epi8(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_subs_epi16() {
|
||||
unsafe fn _mm256_subs_epi16() {
|
||||
let a = i16x16::splat(4);
|
||||
let b = i16x16::splat(2);
|
||||
let r = unsafe { avx2::_mm256_subs_epi16(a, b) };
|
||||
let r = avx2::_mm256_subs_epi16(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_subs_epi8() {
|
||||
unsafe fn _mm256_subs_epi8() {
|
||||
let a = i8x32::splat(4);
|
||||
let b = i8x32::splat(2);
|
||||
let r = unsafe { avx2::_mm256_subs_epi8(a, b) };
|
||||
let r = avx2::_mm256_subs_epi8(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_subs_epu16() {
|
||||
unsafe fn _mm256_subs_epu16() {
|
||||
let a = u16x16::splat(4);
|
||||
let b = u16x16::splat(2);
|
||||
let r = unsafe { avx2::_mm256_subs_epu16(a, b) };
|
||||
let r = avx2::_mm256_subs_epu16(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_subs_epu8() {
|
||||
unsafe fn _mm256_subs_epu8() {
|
||||
let a = u8x32::splat(4);
|
||||
let b = u8x32::splat(2);
|
||||
let r = unsafe { avx2::_mm256_subs_epu8(a, b) };
|
||||
let r = avx2::_mm256_subs_epu8(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "avx2"]
|
||||
fn _mm256_xor_si256() {
|
||||
unsafe fn _mm256_xor_si256() {
|
||||
let a = __m256i::splat(5);
|
||||
let b = __m256i::splat(3);
|
||||
let r = unsafe { avx2::_mm256_xor_si256(a, b) };
|
||||
let r = avx2::_mm256_xor_si256(a, b);
|
||||
assert_eq!(r, __m256i::splat(6));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 @@ fn _pext_u32() {
|
||||
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 @@ fn _pext_u64() {
|
||||
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 @@ fn _pdep_u32() {
|
||||
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 @@ fn _pdep_u64() {
|
||||
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 @@ fn _mulx_u32() {
|
||||
|
||||
#[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);
|
||||
}
|
||||
}
|
||||
|
||||
+466
-542
@@ -1936,402 +1936,402 @@ mod tests {
|
||||
use x86::{__m128i, sse2};
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_pause() {
|
||||
unsafe { sse2::_mm_pause() };
|
||||
unsafe fn _mm_pause() {
|
||||
sse2::_mm_pause();
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_clflush() {
|
||||
unsafe fn _mm_clflush() {
|
||||
let x = 0;
|
||||
unsafe { sse2::_mm_clflush(&x as *const _ as *mut c_void); }
|
||||
sse2::_mm_clflush(&x as *const _ as *mut c_void);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_lfence() {
|
||||
unsafe { sse2::_mm_lfence() };
|
||||
unsafe fn _mm_lfence() {
|
||||
sse2::_mm_lfence();
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_mfence() {
|
||||
unsafe { sse2::_mm_mfence() };
|
||||
unsafe fn _mm_mfence() {
|
||||
sse2::_mm_mfence();
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_add_epi8() {
|
||||
unsafe fn _mm_add_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(
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
|
||||
let r = unsafe { sse2::_mm_add_epi8(a, b) };
|
||||
let r = sse2::_mm_add_epi8(a, b);
|
||||
let e = i8x16::new(
|
||||
16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_add_epi8_overflow() {
|
||||
unsafe fn _mm_add_epi8_overflow() {
|
||||
let a = i8x16::splat(0x7F);
|
||||
let b = i8x16::splat(1);
|
||||
let r = unsafe { sse2::_mm_add_epi8(a, b) };
|
||||
let r = sse2::_mm_add_epi8(a, b);
|
||||
assert_eq!(r, i8x16::splat(-128));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_add_epi16() {
|
||||
unsafe fn _mm_add_epi16() {
|
||||
let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
|
||||
let b = i16x8::new(8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let r = unsafe { sse2::_mm_add_epi16(a, b) };
|
||||
let r = sse2::_mm_add_epi16(a, b);
|
||||
let e = i16x8::new(8, 10, 12, 14, 16, 18, 20, 22);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_add_epi32() {
|
||||
unsafe fn _mm_add_epi32() {
|
||||
let a = i32x4::new(0, 1, 2, 3);
|
||||
let b = i32x4::new(4, 5, 6, 7);
|
||||
let r = unsafe { sse2::_mm_add_epi32(a, b) };
|
||||
let r = sse2::_mm_add_epi32(a, b);
|
||||
let e = i32x4::new(4, 6, 8, 10);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_add_epi64() {
|
||||
unsafe fn _mm_add_epi64() {
|
||||
let a = i64x2::new(0, 1);
|
||||
let b = i64x2::new(2, 3);
|
||||
let r = unsafe { sse2::_mm_add_epi64(a, b) };
|
||||
let r = sse2::_mm_add_epi64(a, b);
|
||||
let e = i64x2::new(2, 4);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_adds_epi8() {
|
||||
unsafe fn _mm_adds_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(
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
|
||||
let r = unsafe { sse2::_mm_adds_epi8(a, b) };
|
||||
let r = sse2::_mm_adds_epi8(a, b);
|
||||
let e = i8x16::new(
|
||||
16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_adds_epi8_saturate_positive() {
|
||||
unsafe fn _mm_adds_epi8_saturate_positive() {
|
||||
let a = i8x16::splat(0x7F);
|
||||
let b = i8x16::splat(1);
|
||||
let r = unsafe { sse2::_mm_adds_epi8(a, b) };
|
||||
let r = sse2::_mm_adds_epi8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_adds_epi8_saturate_negative() {
|
||||
unsafe fn _mm_adds_epi8_saturate_negative() {
|
||||
let a = i8x16::splat(-0x80);
|
||||
let b = i8x16::splat(-1);
|
||||
let r = unsafe { sse2::_mm_adds_epi8(a, b) };
|
||||
let r = sse2::_mm_adds_epi8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_adds_epi16() {
|
||||
unsafe fn _mm_adds_epi16() {
|
||||
let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
|
||||
let b = i16x8::new(8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let r = unsafe { sse2::_mm_adds_epi16(a, b) };
|
||||
let r = sse2::_mm_adds_epi16(a, b);
|
||||
let e = i16x8::new(8, 10, 12, 14, 16, 18, 20, 22);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_adds_epi16_saturate_positive() {
|
||||
unsafe fn _mm_adds_epi16_saturate_positive() {
|
||||
let a = i16x8::splat(0x7FFF);
|
||||
let b = i16x8::splat(1);
|
||||
let r = unsafe { sse2::_mm_adds_epi16(a, b) };
|
||||
let r = sse2::_mm_adds_epi16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_adds_epi16_saturate_negative() {
|
||||
unsafe fn _mm_adds_epi16_saturate_negative() {
|
||||
let a = i16x8::splat(-0x8000);
|
||||
let b = i16x8::splat(-1);
|
||||
let r = unsafe { sse2::_mm_adds_epi16(a, b) };
|
||||
let r = sse2::_mm_adds_epi16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_adds_epu8() {
|
||||
unsafe fn _mm_adds_epu8() {
|
||||
let a = u8x16::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let b = u8x16::new(
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
|
||||
let r = unsafe { sse2::_mm_adds_epu8(a, b) };
|
||||
let r = sse2::_mm_adds_epu8(a, b);
|
||||
let e = u8x16::new(
|
||||
16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_adds_epu8_saturate() {
|
||||
unsafe fn _mm_adds_epu8_saturate() {
|
||||
let a = u8x16::splat(0xFF);
|
||||
let b = u8x16::splat(1);
|
||||
let r = unsafe { sse2::_mm_adds_epu8(a, b) };
|
||||
let r = sse2::_mm_adds_epu8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_adds_epu16() {
|
||||
unsafe fn _mm_adds_epu16() {
|
||||
let a = u16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
|
||||
let b = u16x8::new(8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let r = unsafe { sse2::_mm_adds_epu16(a, b) };
|
||||
let r = sse2::_mm_adds_epu16(a, b);
|
||||
let e = u16x8::new(8, 10, 12, 14, 16, 18, 20, 22);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_adds_epu16_saturate() {
|
||||
unsafe fn _mm_adds_epu16_saturate() {
|
||||
let a = u16x8::splat(0xFFFF);
|
||||
let b = u16x8::splat(1);
|
||||
let r = unsafe { sse2::_mm_adds_epu16(a, b) };
|
||||
let r = sse2::_mm_adds_epu16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_avg_epu8() {
|
||||
unsafe fn _mm_avg_epu8() {
|
||||
let (a, b) = (u8x16::splat(3), u8x16::splat(9));
|
||||
let r = unsafe { sse2::_mm_avg_epu8(a, b) };
|
||||
let r = sse2::_mm_avg_epu8(a, b);
|
||||
assert_eq!(r, u8x16::splat(6));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_avg_epu16() {
|
||||
unsafe fn _mm_avg_epu16() {
|
||||
let (a, b) = (u16x8::splat(3), u16x8::splat(9));
|
||||
let r = unsafe { sse2::_mm_avg_epu16(a, b) };
|
||||
let r = sse2::_mm_avg_epu16(a, b);
|
||||
assert_eq!(r, u16x8::splat(6));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_madd_epi16() {
|
||||
unsafe fn _mm_madd_epi16() {
|
||||
let a = i16x8::new(1, 2, 3, 4, 5, 6, 7, 8);
|
||||
let b = i16x8::new(9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_madd_epi16(a, b) };
|
||||
let r = sse2::_mm_madd_epi16(a, b);
|
||||
let e = i32x4::new(29, 81, 149, 233);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_max_epi16() {
|
||||
unsafe fn _mm_max_epi16() {
|
||||
let a = i16x8::splat(1);
|
||||
let b = i16x8::splat(-1);
|
||||
let r = unsafe { sse2::_mm_max_epi16(a, b) };
|
||||
let r = sse2::_mm_max_epi16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_max_epu8() {
|
||||
unsafe fn _mm_max_epu8() {
|
||||
let a = u8x16::splat(1);
|
||||
let b = u8x16::splat(255);
|
||||
let r = unsafe { sse2::_mm_max_epu8(a, b) };
|
||||
let r = sse2::_mm_max_epu8(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_min_epi16() {
|
||||
unsafe fn _mm_min_epi16() {
|
||||
let a = i16x8::splat(1);
|
||||
let b = i16x8::splat(-1);
|
||||
let r = unsafe { sse2::_mm_min_epi16(a, b) };
|
||||
let r = sse2::_mm_min_epi16(a, b);
|
||||
assert_eq!(r, b);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_min_epu8() {
|
||||
unsafe fn _mm_min_epu8() {
|
||||
let a = u8x16::splat(1);
|
||||
let b = u8x16::splat(255);
|
||||
let r = unsafe { sse2::_mm_min_epu8(a, b) };
|
||||
let r = sse2::_mm_min_epu8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_mulhi_epi16() {
|
||||
unsafe fn _mm_mulhi_epi16() {
|
||||
let (a, b) = (i16x8::splat(1000), i16x8::splat(-1001));
|
||||
let r = unsafe { sse2::_mm_mulhi_epi16(a, b) };
|
||||
let r = sse2::_mm_mulhi_epi16(a, b);
|
||||
assert_eq!(r, i16x8::splat(-16));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_mulhi_epu16() {
|
||||
unsafe fn _mm_mulhi_epu16() {
|
||||
let (a, b) = (u16x8::splat(1000), u16x8::splat(1001));
|
||||
let r = unsafe { sse2::_mm_mulhi_epu16(a, b) };
|
||||
let r = sse2::_mm_mulhi_epu16(a, b);
|
||||
assert_eq!(r, u16x8::splat(15));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_mullo_epi16() {
|
||||
unsafe fn _mm_mullo_epi16() {
|
||||
let (a, b) = (i16x8::splat(1000), i16x8::splat(-1001));
|
||||
let r = unsafe { sse2::_mm_mullo_epi16(a, b) };
|
||||
let r = sse2::_mm_mullo_epi16(a, b);
|
||||
assert_eq!(r, i16x8::splat(-17960));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_mul_epu32() {
|
||||
unsafe fn _mm_mul_epu32() {
|
||||
let a = u32x4::from(u64x2::new(1_000_000_000, 1 << 34));
|
||||
let b = u32x4::from(u64x2::new(1_000_000_000, 1 << 35));
|
||||
let r = unsafe { sse2::_mm_mul_epu32(a, b) };
|
||||
let r = sse2::_mm_mul_epu32(a, b);
|
||||
let e = u64x2::new(1_000_000_000 * 1_000_000_000, 0);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sad_epu8() {
|
||||
unsafe fn _mm_sad_epu8() {
|
||||
let a = u8x16::new(
|
||||
255, 254, 253, 252, 1, 2, 3, 4,
|
||||
155, 154, 153, 152, 1, 2, 3, 4);
|
||||
let b = u8x16::new(
|
||||
0, 0, 0, 0, 2, 1, 2, 1,
|
||||
1, 1, 1, 1, 1, 2, 1, 2);
|
||||
let r = unsafe { sse2::_mm_sad_epu8(a, b) };
|
||||
let r = sse2::_mm_sad_epu8(a, b);
|
||||
let e = u64x2::new(1020, 614);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sub_epi8() {
|
||||
unsafe fn _mm_sub_epi8() {
|
||||
let (a, b) = (i8x16::splat(5), i8x16::splat(6));
|
||||
let r = unsafe { sse2::_mm_sub_epi8(a, b) };
|
||||
let r = sse2::_mm_sub_epi8(a, b);
|
||||
assert_eq!(r, i8x16::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sub_epi16() {
|
||||
unsafe fn _mm_sub_epi16() {
|
||||
let (a, b) = (i16x8::splat(5), i16x8::splat(6));
|
||||
let r = unsafe { sse2::_mm_sub_epi16(a, b) };
|
||||
let r = sse2::_mm_sub_epi16(a, b);
|
||||
assert_eq!(r, i16x8::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sub_epi32() {
|
||||
unsafe fn _mm_sub_epi32() {
|
||||
let (a, b) = (i32x4::splat(5), i32x4::splat(6));
|
||||
let r = unsafe { sse2::_mm_sub_epi32(a, b) };
|
||||
let r = sse2::_mm_sub_epi32(a, b);
|
||||
assert_eq!(r, i32x4::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sub_epi64() {
|
||||
unsafe fn _mm_sub_epi64() {
|
||||
let (a, b) = (i64x2::splat(5), i64x2::splat(6));
|
||||
let r = unsafe { sse2::_mm_sub_epi64(a, b) };
|
||||
let r = sse2::_mm_sub_epi64(a, b);
|
||||
assert_eq!(r, i64x2::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_subs_epi8() {
|
||||
unsafe fn _mm_subs_epi8() {
|
||||
let (a, b) = (i8x16::splat(5), i8x16::splat(2));
|
||||
let r = unsafe { sse2::_mm_subs_epi8(a, b) };
|
||||
let r = sse2::_mm_subs_epi8(a, b);
|
||||
assert_eq!(r, i8x16::splat(3));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_subs_epi8_saturate_positive() {
|
||||
unsafe fn _mm_subs_epi8_saturate_positive() {
|
||||
let a = i8x16::splat(0x7F);
|
||||
let b = i8x16::splat(-1);
|
||||
let r = unsafe { sse2::_mm_subs_epi8(a, b) };
|
||||
let r = sse2::_mm_subs_epi8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_subs_epi8_saturate_negative() {
|
||||
unsafe fn _mm_subs_epi8_saturate_negative() {
|
||||
let a = i8x16::splat(-0x80);
|
||||
let b = i8x16::splat(1);
|
||||
let r = unsafe { sse2::_mm_subs_epi8(a, b) };
|
||||
let r = sse2::_mm_subs_epi8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_subs_epi16() {
|
||||
unsafe fn _mm_subs_epi16() {
|
||||
let (a, b) = (i16x8::splat(5), i16x8::splat(2));
|
||||
let r = unsafe { sse2::_mm_subs_epi16(a, b) };
|
||||
let r = sse2::_mm_subs_epi16(a, b);
|
||||
assert_eq!(r, i16x8::splat(3));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_subs_epi16_saturate_positive() {
|
||||
unsafe fn _mm_subs_epi16_saturate_positive() {
|
||||
let a = i16x8::splat(0x7FFF);
|
||||
let b = i16x8::splat(-1);
|
||||
let r = unsafe { sse2::_mm_subs_epi16(a, b) };
|
||||
let r = sse2::_mm_subs_epi16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_subs_epi16_saturate_negative() {
|
||||
unsafe fn _mm_subs_epi16_saturate_negative() {
|
||||
let a = i16x8::splat(-0x8000);
|
||||
let b = i16x8::splat(1);
|
||||
let r = unsafe { sse2::_mm_subs_epi16(a, b) };
|
||||
let r = sse2::_mm_subs_epi16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_subs_epu8() {
|
||||
unsafe fn _mm_subs_epu8() {
|
||||
let (a, b) = (u8x16::splat(5), u8x16::splat(2));
|
||||
let r = unsafe { sse2::_mm_subs_epu8(a, b) };
|
||||
let r = sse2::_mm_subs_epu8(a, b);
|
||||
assert_eq!(r, u8x16::splat(3));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_subs_epu8_saturate() {
|
||||
unsafe fn _mm_subs_epu8_saturate() {
|
||||
let a = u8x16::splat(0);
|
||||
let b = u8x16::splat(1);
|
||||
let r = unsafe { sse2::_mm_subs_epu8(a, b) };
|
||||
let r = sse2::_mm_subs_epu8(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_subs_epu16() {
|
||||
unsafe fn _mm_subs_epu16() {
|
||||
let (a, b) = (u16x8::splat(5), u16x8::splat(2));
|
||||
let r = unsafe { sse2::_mm_subs_epu16(a, b) };
|
||||
let r = sse2::_mm_subs_epu16(a, b);
|
||||
assert_eq!(r, u16x8::splat(3));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_subs_epu16_saturate() {
|
||||
unsafe fn _mm_subs_epu16_saturate() {
|
||||
let a = u16x8::splat(0);
|
||||
let b = u16x8::splat(1);
|
||||
let r = unsafe { sse2::_mm_subs_epu16(a, b) };
|
||||
let r = sse2::_mm_subs_epu16(a, b);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_slli_si128() {
|
||||
unsafe fn _mm_slli_si128() {
|
||||
let a = __m128i::new(
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_slli_si128(a, 1) };
|
||||
let r = sse2::_mm_slli_si128(a, 1);
|
||||
let e = __m128i::new(
|
||||
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
|
||||
assert_eq!(r, e);
|
||||
|
||||
let a = __m128i::new(
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_slli_si128(a, 15) };
|
||||
let r = sse2::_mm_slli_si128(a, 15);
|
||||
let e = __m128i::new(
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
|
||||
assert_eq!(r, e);
|
||||
|
||||
let a = __m128i::new(
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_slli_si128(a, 16) };
|
||||
let r = sse2::_mm_slli_si128(a, 16);
|
||||
assert_eq!(r, __m128i::splat(0));
|
||||
|
||||
let a = __m128i::new(
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_slli_si128(a, -1) };
|
||||
let r = sse2::_mm_slli_si128(a, -1);
|
||||
assert_eq!(r, __m128i::splat(0));
|
||||
|
||||
let a = __m128i::new(
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_slli_si128(a, -0x80000000) };
|
||||
let r = sse2::_mm_slli_si128(a, -0x80000000);
|
||||
assert_eq!(r, __m128i::splat(0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_slli_epi16() {
|
||||
unsafe fn _mm_slli_epi16() {
|
||||
let a = i16x8::new(
|
||||
0xFFFF as u16 as i16, 0x0FFF, 0x00FF, 0x000F, 0, 0, 0, 0);
|
||||
let r = unsafe { sse2::_mm_slli_epi16(a, 4) };
|
||||
let r = sse2::_mm_slli_epi16(a, 4);
|
||||
let e = i16x8::new(
|
||||
0xFFF0 as u16 as i16,
|
||||
0xFFF0 as u16 as i16, 0x0FF0, 0x00F0, 0, 0, 0, 0);
|
||||
@@ -2339,111 +2339,107 @@ fn _mm_slli_epi16() {
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sll_epi16() {
|
||||
unsafe fn _mm_sll_epi16() {
|
||||
let a = i16x8::new(0xFF, 0, 0, 0, 0, 0, 0, 0);
|
||||
let r = unsafe {
|
||||
sse2::_mm_sll_epi16(a, i16x8::new(4, 0, 0, 0, 0, 0, 0, 0))
|
||||
};
|
||||
let r = sse2::_mm_sll_epi16(a, i16x8::new(4, 0, 0, 0, 0, 0, 0, 0));
|
||||
assert_eq!(r, i16x8::new(0xFF0, 0, 0, 0, 0, 0, 0, 0));
|
||||
let r = unsafe {
|
||||
sse2::_mm_sll_epi16(a, i16x8::new(0, 0, 0, 0, 4, 0, 0, 0))
|
||||
};
|
||||
let r = sse2::_mm_sll_epi16(a, i16x8::new(0, 0, 0, 0, 4, 0, 0, 0));
|
||||
assert_eq!(r, i16x8::new(0xFF, 0, 0, 0, 0, 0, 0, 0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_slli_epi32() {
|
||||
let r = unsafe { sse2::_mm_slli_epi32(i32x4::splat(0xFFFF), 4) };
|
||||
unsafe fn _mm_slli_epi32() {
|
||||
let r = sse2::_mm_slli_epi32(i32x4::splat(0xFFFF), 4);
|
||||
assert_eq!(r, i32x4::splat(0xFFFF0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sll_epi32() {
|
||||
unsafe fn _mm_sll_epi32() {
|
||||
let a = i32x4::splat(0xFFFF);
|
||||
let b = i32x4::new(4, 0, 0, 0);
|
||||
let r = unsafe { sse2::_mm_sll_epi32(a, b) };
|
||||
let r = sse2::_mm_sll_epi32(a, b);
|
||||
assert_eq!(r, i32x4::splat(0xFFFF0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_slli_epi64() {
|
||||
let r = unsafe { sse2::_mm_slli_epi64(i64x2::splat(0xFFFFFFFF), 4) };
|
||||
unsafe fn _mm_slli_epi64() {
|
||||
let r = sse2::_mm_slli_epi64(i64x2::splat(0xFFFFFFFF), 4);
|
||||
assert_eq!(r, i64x2::splat(0xFFFFFFFF0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sll_epi64() {
|
||||
unsafe fn _mm_sll_epi64() {
|
||||
let a = i64x2::splat(0xFFFFFFFF);
|
||||
let b = i64x2::new(4, 0);
|
||||
let r = unsafe { sse2::_mm_sll_epi64(a, b) };
|
||||
let r = sse2::_mm_sll_epi64(a, b);
|
||||
assert_eq!(r, i64x2::splat(0xFFFFFFFF0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_srai_epi16() {
|
||||
let r = unsafe { sse2::_mm_srai_epi16(i16x8::splat(-1), 1) };
|
||||
unsafe fn _mm_srai_epi16() {
|
||||
let r = sse2::_mm_srai_epi16(i16x8::splat(-1), 1);
|
||||
assert_eq!(r, i16x8::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sra_epi16() {
|
||||
unsafe fn _mm_sra_epi16() {
|
||||
let a = i16x8::splat(-1);
|
||||
let b = i16x8::new(1, 0, 0, 0, 0, 0, 0, 0);
|
||||
let r = unsafe { sse2::_mm_sra_epi16(a, b) };
|
||||
let r = sse2::_mm_sra_epi16(a, b);
|
||||
assert_eq!(r, i16x8::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_srai_epi32() {
|
||||
let r = unsafe { sse2::_mm_srai_epi32(i32x4::splat(-1), 1) };
|
||||
unsafe fn _mm_srai_epi32() {
|
||||
let r = sse2::_mm_srai_epi32(i32x4::splat(-1), 1);
|
||||
assert_eq!(r, i32x4::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sra_epi32() {
|
||||
unsafe fn _mm_sra_epi32() {
|
||||
let a = i32x4::splat(-1);
|
||||
let b = i32x4::new(1, 0, 0, 0);
|
||||
let r = unsafe { sse2::_mm_sra_epi32(a, b) };
|
||||
let r = sse2::_mm_sra_epi32(a, b);
|
||||
assert_eq!(r, i32x4::splat(-1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_srli_si128() {
|
||||
unsafe fn _mm_srli_si128() {
|
||||
let a = __m128i::new(
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_srli_si128(a, 1) };
|
||||
let r = sse2::_mm_srli_si128(a, 1);
|
||||
let e = __m128i::new(
|
||||
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0);
|
||||
assert_eq!(r, e);
|
||||
|
||||
let a = __m128i::new(
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_srli_si128(a, 15) };
|
||||
let r = sse2::_mm_srli_si128(a, 15);
|
||||
let e = __m128i::new(
|
||||
16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
||||
assert_eq!(r, e);
|
||||
|
||||
let a = __m128i::new(
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_srli_si128(a, 16) };
|
||||
let r = sse2::_mm_srli_si128(a, 16);
|
||||
assert_eq!(r, __m128i::splat(0));
|
||||
|
||||
let a = __m128i::new(
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_srli_si128(a, -1) };
|
||||
let r = sse2::_mm_srli_si128(a, -1);
|
||||
assert_eq!(r, __m128i::splat(0));
|
||||
|
||||
let a = __m128i::new(
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
|
||||
let r = unsafe { sse2::_mm_srli_si128(a, -0x80000000) };
|
||||
let r = sse2::_mm_srli_si128(a, -0x80000000);
|
||||
assert_eq!(r, __m128i::splat(0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_srli_epi16() {
|
||||
unsafe fn _mm_srli_epi16() {
|
||||
let a = i16x8::new(
|
||||
0xFFFF as u16 as i16, 0x0FFF, 0x00FF, 0x000F, 0, 0, 0, 0);
|
||||
let r = unsafe { sse2::_mm_srli_epi16(a, 4) };
|
||||
let r = sse2::_mm_srli_epi16(a, 4);
|
||||
let e = i16x8::new(
|
||||
0xFFF as u16 as i16,
|
||||
0xFF as u16 as i16, 0xF, 0, 0, 0, 0, 0);
|
||||
@@ -2451,236 +2447,230 @@ fn _mm_srli_epi16() {
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_srl_epi16() {
|
||||
unsafe fn _mm_srl_epi16() {
|
||||
let a = i16x8::new(0xFF, 0, 0, 0, 0, 0, 0, 0);
|
||||
let r = unsafe {
|
||||
sse2::_mm_srl_epi16(a, i16x8::new(4, 0, 0, 0, 0, 0, 0, 0))
|
||||
};
|
||||
let r = sse2::_mm_srl_epi16(a, i16x8::new(4, 0, 0, 0, 0, 0, 0, 0));
|
||||
assert_eq!(r, i16x8::new(0xF, 0, 0, 0, 0, 0, 0, 0));
|
||||
let r = unsafe {
|
||||
sse2::_mm_srl_epi16(a, i16x8::new(0, 0, 0, 0, 4, 0, 0, 0))
|
||||
};
|
||||
let r = sse2::_mm_srl_epi16(a, i16x8::new(0, 0, 0, 0, 4, 0, 0, 0));
|
||||
assert_eq!(r, i16x8::new(0xFF, 0, 0, 0, 0, 0, 0, 0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_srli_epi32() {
|
||||
let r = unsafe { sse2::_mm_srli_epi32(i32x4::splat(0xFFFF), 4) };
|
||||
unsafe fn _mm_srli_epi32() {
|
||||
let r = sse2::_mm_srli_epi32(i32x4::splat(0xFFFF), 4);
|
||||
assert_eq!(r, i32x4::splat(0xFFF));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_srl_epi32() {
|
||||
unsafe fn _mm_srl_epi32() {
|
||||
let a = i32x4::splat(0xFFFF);
|
||||
let b = i32x4::new(4, 0, 0, 0);
|
||||
let r = unsafe { sse2::_mm_srl_epi32(a, b) };
|
||||
let r = sse2::_mm_srl_epi32(a, b);
|
||||
assert_eq!(r, i32x4::splat(0xFFF));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_srli_epi64() {
|
||||
let r = unsafe { sse2::_mm_srli_epi64(i64x2::splat(0xFFFFFFFF), 4) };
|
||||
unsafe fn _mm_srli_epi64() {
|
||||
let r = sse2::_mm_srli_epi64(i64x2::splat(0xFFFFFFFF), 4);
|
||||
assert_eq!(r, i64x2::splat(0xFFFFFFF));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_srl_epi64() {
|
||||
unsafe fn _mm_srl_epi64() {
|
||||
let a = i64x2::splat(0xFFFFFFFF);
|
||||
let b = i64x2::new(4, 0);
|
||||
let r = unsafe { sse2::_mm_srl_epi64(a, b) };
|
||||
let r = sse2::_mm_srl_epi64(a, b);
|
||||
assert_eq!(r, i64x2::splat(0xFFFFFFF));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_and_si128() {
|
||||
unsafe fn _mm_and_si128() {
|
||||
let a = __m128i::splat(5);
|
||||
let b = __m128i::splat(3);
|
||||
let r = unsafe { sse2::_mm_and_si128(a, b) };
|
||||
let r = sse2::_mm_and_si128(a, b);
|
||||
assert_eq!(r, __m128i::splat(1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_andnot_si128() {
|
||||
unsafe fn _mm_andnot_si128() {
|
||||
let a = __m128i::splat(5);
|
||||
let b = __m128i::splat(3);
|
||||
let r = unsafe { sse2::_mm_andnot_si128(a, b) };
|
||||
let r = sse2::_mm_andnot_si128(a, b);
|
||||
assert_eq!(r, __m128i::splat(2));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_or_si128() {
|
||||
unsafe fn _mm_or_si128() {
|
||||
let a = __m128i::splat(5);
|
||||
let b = __m128i::splat(3);
|
||||
let r = unsafe { sse2::_mm_or_si128(a, b) };
|
||||
let r = sse2::_mm_or_si128(a, b);
|
||||
assert_eq!(r, __m128i::splat(7));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_xor_si128() {
|
||||
unsafe fn _mm_xor_si128() {
|
||||
let a = __m128i::splat(5);
|
||||
let b = __m128i::splat(3);
|
||||
let r = unsafe { sse2::_mm_xor_si128(a, b) };
|
||||
let r = sse2::_mm_xor_si128(a, b);
|
||||
assert_eq!(r, __m128i::splat(6));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpeq_epi8() {
|
||||
unsafe fn _mm_cmpeq_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(
|
||||
15, 14, 2, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
|
||||
let r = unsafe { sse2::_mm_cmpeq_epi8(a, b) };
|
||||
let r = sse2::_mm_cmpeq_epi8(a, b);
|
||||
assert_eq!(r, i8x16::new(
|
||||
0, 0, 0xFFu8 as i8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpeq_epi16() {
|
||||
unsafe fn _mm_cmpeq_epi16() {
|
||||
let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
|
||||
let b = i16x8::new(7, 6, 2, 4, 3, 2, 1, 0);
|
||||
let r = unsafe { sse2::_mm_cmpeq_epi16(a, b) };
|
||||
let r = sse2::_mm_cmpeq_epi16(a, b);
|
||||
assert_eq!(r, i16x8::splat(0).replace(2, 0xFFFFu16 as i16));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpeq_epi32() {
|
||||
unsafe fn _mm_cmpeq_epi32() {
|
||||
let a = i32x4::new(0, 1, 2, 3);
|
||||
let b = i32x4::new(3, 2, 2, 0);
|
||||
let r = unsafe { sse2::_mm_cmpeq_epi32(a, b) };
|
||||
let r = sse2::_mm_cmpeq_epi32(a, b);
|
||||
assert_eq!(r, i32x4::splat(0).replace(2, 0xFFFFFFFFu32 as i32));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpgt_epi8() {
|
||||
unsafe fn _mm_cmpgt_epi8() {
|
||||
let a = i8x16::splat(0).replace(0, 5);
|
||||
let b = i8x16::splat(0);
|
||||
let r = unsafe { sse2::_mm_cmpgt_epi8(a, b) };
|
||||
let r = sse2::_mm_cmpgt_epi8(a, b);
|
||||
assert_eq!(r, i8x16::splat(0).replace(0, 0xFFu8 as i8));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpgt_epi16() {
|
||||
unsafe fn _mm_cmpgt_epi16() {
|
||||
let a = i16x8::splat(0).replace(0, 5);
|
||||
let b = i16x8::splat(0);
|
||||
let r = unsafe { sse2::_mm_cmpgt_epi16(a, b) };
|
||||
let r = sse2::_mm_cmpgt_epi16(a, b);
|
||||
assert_eq!(r, i16x8::splat(0).replace(0, 0xFFFFu16 as i16));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpgt_epi32() {
|
||||
unsafe fn _mm_cmpgt_epi32() {
|
||||
let a = i32x4::splat(0).replace(0, 5);
|
||||
let b = i32x4::splat(0);
|
||||
let r = unsafe { sse2::_mm_cmpgt_epi32(a, b) };
|
||||
let r = sse2::_mm_cmpgt_epi32(a, b);
|
||||
assert_eq!(r, i32x4::splat(0).replace(0, 0xFFFFFFFFu32 as i32));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmplt_epi8() {
|
||||
unsafe fn _mm_cmplt_epi8() {
|
||||
let a = i8x16::splat(0);
|
||||
let b = i8x16::splat(0).replace(0, 5);
|
||||
let r = unsafe { sse2::_mm_cmplt_epi8(a, b) };
|
||||
let r = sse2::_mm_cmplt_epi8(a, b);
|
||||
assert_eq!(r, i8x16::splat(0).replace(0, 0xFFu8 as i8));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmplt_epi16() {
|
||||
unsafe fn _mm_cmplt_epi16() {
|
||||
let a = i16x8::splat(0);
|
||||
let b = i16x8::splat(0).replace(0, 5);
|
||||
let r = unsafe { sse2::_mm_cmplt_epi16(a, b) };
|
||||
let r = sse2::_mm_cmplt_epi16(a, b);
|
||||
assert_eq!(r, i16x8::splat(0).replace(0, 0xFFFFu16 as i16));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmplt_epi32() {
|
||||
unsafe fn _mm_cmplt_epi32() {
|
||||
let a = i32x4::splat(0);
|
||||
let b = i32x4::splat(0).replace(0, 5);
|
||||
let r = unsafe { sse2::_mm_cmplt_epi32(a, b) };
|
||||
let r = sse2::_mm_cmplt_epi32(a, b);
|
||||
assert_eq!(r, i32x4::splat(0).replace(0, 0xFFFFFFFFu32 as i32));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cvtepi32_pd() {
|
||||
let a = unsafe { sse2::_mm_set_epi32(35, 25, 15, 5) };
|
||||
let r = unsafe { sse2::_mm_cvtepi32_pd(a) };
|
||||
unsafe fn _mm_cvtepi32_pd() {
|
||||
let a = sse2::_mm_set_epi32(35, 25, 15, 5);
|
||||
let r = sse2::_mm_cvtepi32_pd(a);
|
||||
assert_eq!(r, f64x2::new(5.0, 15.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cvtsi32_sd() {
|
||||
unsafe fn _mm_cvtsi32_sd() {
|
||||
let a = f64x2::splat(3.5);
|
||||
let r = unsafe { sse2::_mm_cvtsi32_sd(a, 5) };
|
||||
let r = sse2::_mm_cvtsi32_sd(a, 5);
|
||||
assert_eq!(r, f64x2::new(5.0, 3.5));
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cvtsi64_sd() {
|
||||
unsafe fn _mm_cvtsi64_sd() {
|
||||
let a = f64x2::splat(3.5);
|
||||
let r = unsafe { sse2::_mm_cvtsi64_sd(a, 5) };
|
||||
let r = sse2::_mm_cvtsi64_sd(a, 5);
|
||||
assert_eq!(r, f64x2::new(5.0, 3.5));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cvtepi32_ps() {
|
||||
unsafe fn _mm_cvtepi32_ps() {
|
||||
let a = i32x4::new(1, 2, 3, 4);
|
||||
let r = unsafe { sse2::_mm_cvtepi32_ps(a) };
|
||||
let r = sse2::_mm_cvtepi32_ps(a);
|
||||
assert_eq!(r, f32x4::new(1.0, 2.0, 3.0, 4.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cvtsi32_si128() {
|
||||
let r = unsafe { sse2::_mm_cvtsi32_si128(5) };
|
||||
unsafe fn _mm_cvtsi32_si128() {
|
||||
let r = sse2::_mm_cvtsi32_si128(5);
|
||||
assert_eq!(r, i32x4::new(5, 0, 0, 0));
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cvtsi64_si128() {
|
||||
let r = unsafe { sse2::_mm_cvtsi64_si128(5) };
|
||||
unsafe fn _mm_cvtsi64_si128() {
|
||||
let r = sse2::_mm_cvtsi64_si128(5);
|
||||
assert_eq!(r, i64x2::new(5, 0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cvtsi128_si32() {
|
||||
let r = unsafe { sse2::_mm_cvtsi128_si32(i32x4::new(5, 0, 0, 0)) };
|
||||
unsafe fn _mm_cvtsi128_si32() {
|
||||
let r = sse2::_mm_cvtsi128_si32(i32x4::new(5, 0, 0, 0));
|
||||
assert_eq!(r, 5);
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cvtsi128_si64() {
|
||||
let r = unsafe { sse2::_mm_cvtsi128_si64(i64x2::new(5, 0)) };
|
||||
unsafe fn _mm_cvtsi128_si64() {
|
||||
let r = sse2::_mm_cvtsi128_si64(i64x2::new(5, 0));
|
||||
assert_eq!(r, 5);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_set_epi64x() {
|
||||
let r = unsafe { sse2::_mm_set_epi64x(0, 1) };
|
||||
unsafe fn _mm_set_epi64x() {
|
||||
let r = sse2::_mm_set_epi64x(0, 1);
|
||||
assert_eq!(r, i64x2::new(1, 0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_set_epi32() {
|
||||
let r = unsafe { sse2::_mm_set_epi32(0, 1, 2, 3) };
|
||||
unsafe fn _mm_set_epi32() {
|
||||
let r = sse2::_mm_set_epi32(0, 1, 2, 3);
|
||||
assert_eq!(r, i32x4::new(3, 2, 1, 0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_set_epi16() {
|
||||
let r = unsafe { sse2::_mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7) };
|
||||
unsafe fn _mm_set_epi16() {
|
||||
let r = sse2::_mm_set_epi16(0, 1, 2, 3, 4, 5, 6, 7);
|
||||
assert_eq!(r, i16x8::new(7, 6, 5, 4, 3, 2, 1, 0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_set_epi8() {
|
||||
let r = unsafe {
|
||||
sse2::_mm_set_epi8(
|
||||
0, 1, 2, 3,
|
||||
4, 5, 6, 7,
|
||||
8, 9, 10, 11,
|
||||
12, 13, 14, 15,
|
||||
)
|
||||
};
|
||||
unsafe fn _mm_set_epi8() {
|
||||
let r = sse2::_mm_set_epi8(
|
||||
0, 1, 2, 3,
|
||||
4, 5, 6, 7,
|
||||
8, 9, 10, 11,
|
||||
12, 13, 14, 15,
|
||||
);
|
||||
let e = i8x16::new(
|
||||
15, 14, 13, 12,
|
||||
11, 10, 9, 8,
|
||||
@@ -2691,51 +2681,49 @@ fn _mm_set_epi8() {
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_set1_epi64x() {
|
||||
let r = unsafe { sse2::_mm_set1_epi64x(1) };
|
||||
unsafe fn _mm_set1_epi64x() {
|
||||
let r = sse2::_mm_set1_epi64x(1);
|
||||
assert_eq!(r, i64x2::splat(1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_set1_epi32() {
|
||||
let r = unsafe { sse2::_mm_set1_epi32(1) };
|
||||
unsafe fn _mm_set1_epi32() {
|
||||
let r = sse2::_mm_set1_epi32(1);
|
||||
assert_eq!(r, i32x4::splat(1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_set1_epi16() {
|
||||
let r = unsafe { sse2::_mm_set1_epi16(1) };
|
||||
unsafe fn _mm_set1_epi16() {
|
||||
let r = sse2::_mm_set1_epi16(1);
|
||||
assert_eq!(r, i16x8::splat(1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_set1_epi8() {
|
||||
let r = unsafe { sse2::_mm_set1_epi8(1) };
|
||||
unsafe fn _mm_set1_epi8() {
|
||||
let r = sse2::_mm_set1_epi8(1);
|
||||
assert_eq!(r, i8x16::splat(1));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_setr_epi32() {
|
||||
let r = unsafe { sse2::_mm_setr_epi32(0, 1, 2, 3) };
|
||||
unsafe fn _mm_setr_epi32() {
|
||||
let r = sse2::_mm_setr_epi32(0, 1, 2, 3);
|
||||
assert_eq!(r, i32x4::new(0, 1, 2, 3));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_setr_epi16() {
|
||||
let r = unsafe { sse2::_mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7) };
|
||||
unsafe fn _mm_setr_epi16() {
|
||||
let r = sse2::_mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
|
||||
assert_eq!(r, i16x8::new(0, 1, 2, 3, 4, 5, 6, 7));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_setr_epi8() {
|
||||
let r = unsafe {
|
||||
sse2::_mm_setr_epi8(
|
||||
0, 1, 2, 3,
|
||||
4, 5, 6, 7,
|
||||
8, 9, 10, 11,
|
||||
12, 13, 14, 15,
|
||||
)
|
||||
};
|
||||
unsafe fn _mm_setr_epi8() {
|
||||
let r = sse2::_mm_setr_epi8(
|
||||
0, 1, 2, 3,
|
||||
4, 5, 6, 7,
|
||||
8, 9, 10, 11,
|
||||
12, 13, 14, 15,
|
||||
);
|
||||
let e = i8x16::new(
|
||||
0, 1, 2, 3,
|
||||
4, 5, 6, 7,
|
||||
@@ -2746,776 +2734,712 @@ fn _mm_setr_epi8() {
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_setzero_si128() {
|
||||
let r = unsafe { sse2::_mm_setzero_si128() };
|
||||
unsafe fn _mm_setzero_si128() {
|
||||
let r = sse2::_mm_setzero_si128();
|
||||
assert_eq!(r, __m128i::from(i64x2::splat(0)));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_loadl_epi64() {
|
||||
unsafe fn _mm_loadl_epi64() {
|
||||
let a = i64x2::new(6, 5);
|
||||
let r = unsafe { sse2::_mm_loadl_epi64(&a as *const _) };
|
||||
let r = sse2::_mm_loadl_epi64(&a as *const _);
|
||||
assert_eq!(r, i64x2::new(6, 0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_load_si128() {
|
||||
let a = unsafe { sse2::_mm_set_epi64x(5, 6) };
|
||||
let r = unsafe { sse2::_mm_load_si128(&a as *const _ as *const _) };
|
||||
unsafe fn _mm_load_si128() {
|
||||
let a = sse2::_mm_set_epi64x(5, 6);
|
||||
let r = sse2::_mm_load_si128(&a as *const _ as *const _);
|
||||
assert_eq!(a, i64x2::from(r));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_loadu_si128() {
|
||||
let a = unsafe { sse2::_mm_set_epi64x(5, 6) };
|
||||
let r = unsafe { sse2::_mm_loadu_si128(&a as *const _ as *const _) };
|
||||
unsafe fn _mm_loadu_si128() {
|
||||
let a = sse2::_mm_set_epi64x(5, 6);
|
||||
let r = sse2::_mm_loadu_si128(&a as *const _ as *const _);
|
||||
assert_eq!(a, i64x2::from(r));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_maskmoveu_si128() {
|
||||
unsafe fn _mm_maskmoveu_si128() {
|
||||
let a = i8x16::splat(9);
|
||||
let mask = i8x16::splat(0).replace(2, 0x80u8 as i8);
|
||||
let mut r = i8x16::splat(0);
|
||||
unsafe {
|
||||
sse2::_mm_maskmoveu_si128(a, mask, &mut r as *mut _ as *mut i8);
|
||||
}
|
||||
sse2::_mm_maskmoveu_si128(a, mask, &mut r as *mut _ as *mut i8);
|
||||
assert_eq!(r, i8x16::splat(0).replace(2, 9));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_store_si128() {
|
||||
unsafe fn _mm_store_si128() {
|
||||
let a = __m128i::splat(9);
|
||||
let mut r = __m128i::splat(0);
|
||||
unsafe {
|
||||
sse2::_mm_store_si128(&mut r as *mut _ as *mut __m128i, a);
|
||||
}
|
||||
sse2::_mm_store_si128(&mut r as *mut _ as *mut __m128i, a);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_storeu_si128() {
|
||||
unsafe fn _mm_storeu_si128() {
|
||||
let a = __m128i::splat(9);
|
||||
let mut r = __m128i::splat(0);
|
||||
unsafe {
|
||||
sse2::_mm_storeu_si128(&mut r as *mut _ as *mut __m128i, a);
|
||||
}
|
||||
sse2::_mm_storeu_si128(&mut r as *mut _ as *mut __m128i, a);
|
||||
assert_eq!(r, a);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_storel_epi64() {
|
||||
unsafe fn _mm_storel_epi64() {
|
||||
let a = __m128i::from(i64x2::new(2, 9));
|
||||
let mut r = __m128i::splat(0);
|
||||
unsafe {
|
||||
sse2::_mm_storel_epi64(&mut r as *mut _ as *mut __m128i, a);
|
||||
}
|
||||
sse2::_mm_storel_epi64(&mut r as *mut _ as *mut __m128i, a);
|
||||
assert_eq!(r, __m128i::from(i64x2::new(2, 0)));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_move_epi64() {
|
||||
unsafe fn _mm_move_epi64() {
|
||||
let a = i64x2::new(5, 6);
|
||||
let r = unsafe { sse2::_mm_move_epi64(a) };
|
||||
let r = sse2::_mm_move_epi64(a);
|
||||
assert_eq!(r, i64x2::new(5, 0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_packs_epi16() {
|
||||
unsafe fn _mm_packs_epi16() {
|
||||
let a = i16x8::new(0x80, -0x81, 0, 0, 0, 0, 0, 0);
|
||||
let b = i16x8::new(0, 0, 0, 0, 0, 0, -0x81, 0x80);
|
||||
let r = unsafe { sse2::_mm_packs_epi16(a, b) };
|
||||
let r = sse2::_mm_packs_epi16(a, b);
|
||||
assert_eq!(r, i8x16::new(
|
||||
0x7F, -0x80, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, -0x80, 0x7F));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_packs_epi32() {
|
||||
unsafe fn _mm_packs_epi32() {
|
||||
let a = i32x4::new(0x8000, -0x8001, 0, 0);
|
||||
let b = i32x4::new(0, 0, -0x8001, 0x8000);
|
||||
let r = unsafe { sse2::_mm_packs_epi32(a, b) };
|
||||
let r = sse2::_mm_packs_epi32(a, b);
|
||||
assert_eq!(
|
||||
r, i16x8::new(0x7FFF, -0x8000, 0, 0, 0, 0, -0x8000, 0x7FFF));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_packus_epi16() {
|
||||
unsafe fn _mm_packus_epi16() {
|
||||
let a = i16x8::new(0x100, -1, 0, 0, 0, 0, 0, 0);
|
||||
let b = i16x8::new(0, 0, 0, 0, 0, 0, -1, 0x100);
|
||||
let r = unsafe { sse2::_mm_packus_epi16(a, b) };
|
||||
let r = sse2::_mm_packus_epi16(a, b);
|
||||
assert_eq!(r, u8x16::new(
|
||||
0xFF, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0xFF));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_extract_epi16() {
|
||||
unsafe fn _mm_extract_epi16() {
|
||||
let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
|
||||
let r = unsafe { sse2::_mm_extract_epi16(a, 5) };
|
||||
let r = sse2::_mm_extract_epi16(a, 5);
|
||||
assert_eq!(r, 5);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_insert_epi16() {
|
||||
unsafe fn _mm_insert_epi16() {
|
||||
let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
|
||||
let r = unsafe { sse2::_mm_insert_epi16(a, 9, 0) };
|
||||
let r = sse2::_mm_insert_epi16(a, 9, 0);
|
||||
assert_eq!(r, a.replace(0, 9));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_movemask_epi8() {
|
||||
unsafe fn _mm_movemask_epi8() {
|
||||
let a = i8x16::from(u8x16::new(
|
||||
0b1000_0000, 0b0, 0b1000_0000, 0b01, 0b0101, 0b1111_0000, 0, 0,
|
||||
0, 0, 0b1111_0000, 0b0101, 0b01, 0b1000_0000, 0b0, 0b1000_0000));
|
||||
let r = unsafe { sse2::_mm_movemask_epi8(a) };
|
||||
let r = sse2::_mm_movemask_epi8(a);
|
||||
assert_eq!(r, 0b10100100_00100101);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_shuffle_epi32() {
|
||||
unsafe fn _mm_shuffle_epi32() {
|
||||
let a = i32x4::new(5, 10, 15, 20);
|
||||
let r = unsafe { sse2::_mm_shuffle_epi32(a, 0b00_01_01_11) };
|
||||
let r = sse2::_mm_shuffle_epi32(a, 0b00_01_01_11);
|
||||
let e = i32x4::new(20, 10, 10, 5);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_shufflehi_epi16() {
|
||||
unsafe fn _mm_shufflehi_epi16() {
|
||||
let a = i16x8::new(1, 2, 3, 4, 5, 10, 15, 20);
|
||||
let r = unsafe { sse2::_mm_shufflehi_epi16(a, 0b00_01_01_11) };
|
||||
let r = sse2::_mm_shufflehi_epi16(a, 0b00_01_01_11);
|
||||
let e = i16x8::new(1, 2, 3, 4, 20, 10, 10, 5);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_shufflelo_epi16() {
|
||||
unsafe fn _mm_shufflelo_epi16() {
|
||||
let a = i16x8::new(5, 10, 15, 20, 1, 2, 3, 4);
|
||||
let r = unsafe { sse2::_mm_shufflelo_epi16(a, 0b00_01_01_11) };
|
||||
let r = sse2::_mm_shufflelo_epi16(a, 0b00_01_01_11);
|
||||
let e = i16x8::new(20, 10, 10, 5, 1, 2, 3, 4);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_unpackhi_epi8() {
|
||||
unsafe fn _mm_unpackhi_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(
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
|
||||
let r = unsafe { sse2::_mm_unpackhi_epi8(a, b) };
|
||||
let r = sse2::_mm_unpackhi_epi8(a, b);
|
||||
let e = i8x16::new(
|
||||
8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_unpackhi_epi16() {
|
||||
unsafe fn _mm_unpackhi_epi16() {
|
||||
let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
|
||||
let b = i16x8::new(8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let r = unsafe { sse2::_mm_unpackhi_epi16(a, b) };
|
||||
let r = sse2::_mm_unpackhi_epi16(a, b);
|
||||
let e = i16x8::new(4, 12, 5, 13, 6, 14, 7, 15);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_unpackhi_epi32() {
|
||||
unsafe fn _mm_unpackhi_epi32() {
|
||||
let a = i32x4::new(0, 1, 2, 3);
|
||||
let b = i32x4::new(4, 5, 6, 7);
|
||||
let r = unsafe { sse2::_mm_unpackhi_epi32(a, b) };
|
||||
let r = sse2::_mm_unpackhi_epi32(a, b);
|
||||
let e = i32x4::new(2, 6, 3, 7);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_unpackhi_epi64() {
|
||||
unsafe fn _mm_unpackhi_epi64() {
|
||||
let a = i64x2::new(0, 1);
|
||||
let b = i64x2::new(2, 3);
|
||||
let r = unsafe { sse2::_mm_unpackhi_epi64(a, b) };
|
||||
let r = sse2::_mm_unpackhi_epi64(a, b);
|
||||
let e = i64x2::new(1, 3);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_unpacklo_epi8() {
|
||||
unsafe fn _mm_unpacklo_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(
|
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
|
||||
let r = unsafe { sse2::_mm_unpacklo_epi8(a, b) };
|
||||
let r = sse2::_mm_unpacklo_epi8(a, b);
|
||||
let e = i8x16::new(
|
||||
0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_unpacklo_epi16() {
|
||||
unsafe fn _mm_unpacklo_epi16() {
|
||||
let a = i16x8::new(0, 1, 2, 3, 4, 5, 6, 7);
|
||||
let b = i16x8::new(8, 9, 10, 11, 12, 13, 14, 15);
|
||||
let r = unsafe { sse2::_mm_unpacklo_epi16(a, b) };
|
||||
let r = sse2::_mm_unpacklo_epi16(a, b);
|
||||
let e = i16x8::new(0, 8, 1, 9, 2, 10, 3, 11);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_unpacklo_epi32() {
|
||||
unsafe fn _mm_unpacklo_epi32() {
|
||||
let a = i32x4::new(0, 1, 2, 3);
|
||||
let b = i32x4::new(4, 5, 6, 7);
|
||||
let r = unsafe { sse2::_mm_unpacklo_epi32(a, b) };
|
||||
let r = sse2::_mm_unpacklo_epi32(a, b);
|
||||
let e = i32x4::new(0, 4, 1, 5);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_unpacklo_epi64() {
|
||||
unsafe fn _mm_unpacklo_epi64() {
|
||||
let a = i64x2::new(0, 1);
|
||||
let b = i64x2::new(2, 3);
|
||||
let r = unsafe { sse2::_mm_unpacklo_epi64(a, b) };
|
||||
let r = sse2::_mm_unpacklo_epi64(a, b);
|
||||
let e = i64x2::new(0, 2);
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_add_sd() {
|
||||
unsafe fn _mm_add_sd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_add_sd(a, b) };
|
||||
let r = sse2::_mm_add_sd(a, b);
|
||||
assert_eq!(r, f64x2::new(6.0, 2.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_add_pd() {
|
||||
unsafe fn _mm_add_pd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_add_pd(a, b) };
|
||||
let r = sse2::_mm_add_pd(a, b);
|
||||
assert_eq!(r, f64x2::new(6.0, 12.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_div_sd() {
|
||||
unsafe fn _mm_div_sd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_div_sd(a, b) };
|
||||
let r = sse2::_mm_div_sd(a, b);
|
||||
assert_eq!(r, f64x2::new(0.2, 2.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_div_pd() {
|
||||
unsafe fn _mm_div_pd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_div_pd(a, b) };
|
||||
let r = sse2::_mm_div_pd(a, b);
|
||||
assert_eq!(r, f64x2::new(0.2, 0.2));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_max_sd() {
|
||||
unsafe fn _mm_max_sd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_max_sd(a, b) };
|
||||
let r = sse2::_mm_max_sd(a, b);
|
||||
assert_eq!(r, f64x2::new(5.0, 2.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_max_pd() {
|
||||
unsafe fn _mm_max_pd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_max_pd(a, b) };
|
||||
let r = sse2::_mm_max_pd(a, b);
|
||||
assert_eq!(r, f64x2::new(5.0, 10.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_min_sd() {
|
||||
unsafe fn _mm_min_sd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_min_sd(a, b) };
|
||||
let r = sse2::_mm_min_sd(a, b);
|
||||
assert_eq!(r, f64x2::new(1.0, 2.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_min_pd() {
|
||||
unsafe fn _mm_min_pd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_min_pd(a, b) };
|
||||
let r = sse2::_mm_min_pd(a, b);
|
||||
assert_eq!(r, f64x2::new(1.0, 2.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_mul_sd() {
|
||||
unsafe fn _mm_mul_sd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_mul_sd(a, b) };
|
||||
let r = sse2::_mm_mul_sd(a, b);
|
||||
assert_eq!(r, f64x2::new(5.0, 2.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_mul_pd() {
|
||||
unsafe fn _mm_mul_pd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_mul_pd(a, b) };
|
||||
let r = sse2::_mm_mul_pd(a, b);
|
||||
assert_eq!(r, f64x2::new(5.0, 20.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sqrt_sd() {
|
||||
unsafe fn _mm_sqrt_sd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_sqrt_sd(a, b) };
|
||||
let r = sse2::_mm_sqrt_sd(a, b);
|
||||
assert_eq!(r, f64x2::new(5.0f64.sqrt(), 2.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sqrt_pd() {
|
||||
let r = unsafe { sse2::_mm_sqrt_pd(f64x2::new(1.0, 2.0)) };
|
||||
unsafe fn _mm_sqrt_pd() {
|
||||
let r = sse2::_mm_sqrt_pd(f64x2::new(1.0, 2.0));
|
||||
assert_eq!(r, f64x2::new(1.0f64.sqrt(), 2.0f64.sqrt()));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sub_sd() {
|
||||
unsafe fn _mm_sub_sd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_sub_sd(a, b) };
|
||||
let r = sse2::_mm_sub_sd(a, b);
|
||||
assert_eq!(r, f64x2::new(-4.0, 2.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_sub_pd() {
|
||||
unsafe fn _mm_sub_pd() {
|
||||
let a = f64x2::new(1.0, 2.0);
|
||||
let b = f64x2::new(5.0, 10.0);
|
||||
let r = unsafe { sse2::_mm_sub_pd(a, b) };
|
||||
let r = sse2::_mm_sub_pd(a, b);
|
||||
assert_eq!(r, f64x2::new(-4.0, -8.0));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_and_pd() {
|
||||
unsafe fn _mm_and_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let a: f64x2 = transmute(i64x2::splat(5));
|
||||
let b: f64x2 = transmute(i64x2::splat(3));
|
||||
let r = sse2::_mm_and_pd(a, b);
|
||||
let e: f64x2 = transmute(i64x2::splat(1));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let a: f64x2 = transmute(i64x2::splat(5));
|
||||
let b: f64x2 = transmute(i64x2::splat(3));
|
||||
let r = sse2::_mm_and_pd(a, b);
|
||||
let e: f64x2 = transmute(i64x2::splat(1));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_andnot_pd() {
|
||||
unsafe fn _mm_andnot_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let a: f64x2 = transmute(i64x2::splat(5));
|
||||
let b: f64x2 = transmute(i64x2::splat(3));
|
||||
let r = sse2::_mm_andnot_pd(a, b);
|
||||
let e: f64x2 = transmute(i64x2::splat(2));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let a: f64x2 = transmute(i64x2::splat(5));
|
||||
let b: f64x2 = transmute(i64x2::splat(3));
|
||||
let r = sse2::_mm_andnot_pd(a, b);
|
||||
let e: f64x2 = transmute(i64x2::splat(2));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_or_pd() {
|
||||
unsafe fn _mm_or_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let a: f64x2 = transmute(i64x2::splat(5));
|
||||
let b: f64x2 = transmute(i64x2::splat(3));
|
||||
let r = sse2::_mm_or_pd(a, b);
|
||||
let e: f64x2 = transmute(i64x2::splat(7));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let a: f64x2 = transmute(i64x2::splat(5));
|
||||
let b: f64x2 = transmute(i64x2::splat(3));
|
||||
let r = sse2::_mm_or_pd(a, b);
|
||||
let e: f64x2 = transmute(i64x2::splat(7));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_xor_pd() {
|
||||
unsafe fn _mm_xor_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let a: f64x2 = transmute(i64x2::splat(5));
|
||||
let b: f64x2 = transmute(i64x2::splat(3));
|
||||
let r = sse2::_mm_xor_pd(a, b);
|
||||
let e: f64x2 = transmute(i64x2::splat(6));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let a: f64x2 = transmute(i64x2::splat(5));
|
||||
let b: f64x2 = transmute(i64x2::splat(3));
|
||||
let r = sse2::_mm_xor_pd(a, b);
|
||||
let e: f64x2 = transmute(i64x2::splat(6));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpeq_sd() {
|
||||
unsafe fn _mm_cmpeq_sd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpeq_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpeq_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmplt_sd() {
|
||||
unsafe fn _mm_cmplt_sd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmplt_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmplt_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmple_sd() {
|
||||
unsafe fn _mm_cmple_sd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmple_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmple_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpgt_sd() {
|
||||
unsafe fn _mm_cmpgt_sd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(5.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpgt_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(5.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpgt_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpge_sd() {
|
||||
unsafe fn _mm_cmpge_sd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpge_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpge_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpord_sd() {
|
||||
unsafe fn _mm_cmpord_sd() {
|
||||
use std::f64::NAN;
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(NAN, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpord_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(NAN, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpord_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpunord_sd() {
|
||||
unsafe fn _mm_cmpunord_sd() {
|
||||
use std::f64::NAN;
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(NAN, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpunord_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(NAN, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpunord_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpneq_sd() {
|
||||
unsafe fn _mm_cmpneq_sd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpneq_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(!0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpneq_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpnlt_sd() {
|
||||
unsafe fn _mm_cmpnlt_sd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnlt_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnlt_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpnle_sd() {
|
||||
unsafe fn _mm_cmpnle_sd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnle_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnle_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpngt_sd() {
|
||||
unsafe fn _mm_cmpngt_sd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(5.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpngt_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(5.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpngt_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpnge_sd() {
|
||||
unsafe fn _mm_cmpnge_sd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnge_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, transmute(2.0f64));
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnge_sd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpeq_pd() {
|
||||
unsafe fn _mm_cmpeq_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpeq_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpeq_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmplt_pd() {
|
||||
unsafe fn _mm_cmplt_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmplt_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmplt_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmple_pd() {
|
||||
unsafe fn _mm_cmple_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmple_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmple_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpgt_pd() {
|
||||
unsafe fn _mm_cmpgt_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpgt_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpgt_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpge_pd() {
|
||||
unsafe fn _mm_cmpge_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpge_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(!0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpge_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpord_pd() {
|
||||
unsafe fn _mm_cmpord_pd() {
|
||||
use std::f64::NAN;
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(NAN, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpord_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(NAN, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpord_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpunord_pd() {
|
||||
unsafe fn _mm_cmpunord_pd() {
|
||||
use std::f64::NAN;
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(NAN, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(!0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpunord_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(NAN, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(!0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpunord_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpneq_pd() {
|
||||
unsafe fn _mm_cmpneq_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(!0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpneq_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(!0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpneq_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpnlt_pd() {
|
||||
unsafe fn _mm_cmpnlt_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnlt_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(5.0, 3.0));
|
||||
let e = u64x2::new(0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnlt_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpnle_pd() {
|
||||
unsafe fn _mm_cmpnle_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnle_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, 0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnle_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpngt_pd() {
|
||||
unsafe fn _mm_cmpngt_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(5.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpngt_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(5.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpngt_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_cmpnge_pd() {
|
||||
unsafe fn _mm_cmpnge_pd() {
|
||||
use std::mem::transmute;
|
||||
|
||||
unsafe {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnge_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
let e = u64x2::new(0, !0);
|
||||
let r: u64x2 = transmute(sse2::_mm_cmpnge_pd(a, b));
|
||||
assert_eq!(r, e);
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_comieq_sd() {
|
||||
unsafe fn _mm_comieq_sd() {
|
||||
use std::f64::NAN;
|
||||
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { sse2::_mm_comieq_sd(a, b) });
|
||||
assert!(sse2::_mm_comieq_sd(a, b));
|
||||
|
||||
let (a, b) = (f64x2::new(NAN, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { !sse2::_mm_comieq_sd(a, b) });
|
||||
assert!(!sse2::_mm_comieq_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_comilt_sd() {
|
||||
unsafe fn _mm_comilt_sd() {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { !sse2::_mm_comilt_sd(a, b) });
|
||||
assert!(!sse2::_mm_comilt_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_comile_sd() {
|
||||
unsafe fn _mm_comile_sd() {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { sse2::_mm_comile_sd(a, b) });
|
||||
assert!(sse2::_mm_comile_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_comigt_sd() {
|
||||
unsafe fn _mm_comigt_sd() {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { !sse2::_mm_comigt_sd(a, b) });
|
||||
assert!(!sse2::_mm_comigt_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_comige_sd() {
|
||||
unsafe fn _mm_comige_sd() {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { sse2::_mm_comige_sd(a, b) });
|
||||
assert!(sse2::_mm_comige_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_comineq_sd() {
|
||||
unsafe fn _mm_comineq_sd() {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { !sse2::_mm_comineq_sd(a, b) });
|
||||
assert!(!sse2::_mm_comineq_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_ucomieq_sd() {
|
||||
unsafe fn _mm_ucomieq_sd() {
|
||||
use std::f64::NAN;
|
||||
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { sse2::_mm_ucomieq_sd(a, b) });
|
||||
assert!(sse2::_mm_ucomieq_sd(a, b));
|
||||
|
||||
let (a, b) = (f64x2::new(NAN, 2.0), f64x2::new(NAN, 3.0));
|
||||
assert!(unsafe { !sse2::_mm_ucomieq_sd(a, b) });
|
||||
assert!(!sse2::_mm_ucomieq_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_ucomilt_sd() {
|
||||
unsafe fn _mm_ucomilt_sd() {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { !sse2::_mm_ucomilt_sd(a, b) });
|
||||
assert!(!sse2::_mm_ucomilt_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_ucomile_sd() {
|
||||
unsafe fn _mm_ucomile_sd() {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { sse2::_mm_ucomile_sd(a, b) });
|
||||
assert!(sse2::_mm_ucomile_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_ucomigt_sd() {
|
||||
unsafe fn _mm_ucomigt_sd() {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { !sse2::_mm_ucomigt_sd(a, b) });
|
||||
assert!(!sse2::_mm_ucomigt_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_ucomige_sd() {
|
||||
unsafe fn _mm_ucomige_sd() {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { sse2::_mm_ucomige_sd(a, b) });
|
||||
assert!(sse2::_mm_ucomige_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_ucomineq_sd() {
|
||||
unsafe fn _mm_ucomineq_sd() {
|
||||
let (a, b) = (f64x2::new(1.0, 2.0), f64x2::new(1.0, 3.0));
|
||||
assert!(unsafe { !sse2::_mm_ucomineq_sd(a, b) });
|
||||
assert!(!sse2::_mm_ucomineq_sd(a, b));
|
||||
}
|
||||
|
||||
#[simd_test = "sse2"]
|
||||
fn _mm_movemask_pd() {
|
||||
let r = unsafe { sse2::_mm_movemask_pd(f64x2::new(-1.0, 5.0)) };
|
||||
unsafe fn _mm_movemask_pd() {
|
||||
let r = sse2::_mm_movemask_pd(f64x2::new(-1.0, 5.0));
|
||||
assert_eq!(r, 0b01);
|
||||
|
||||
let r = unsafe { sse2::_mm_movemask_pd(f64x2::new(-1.0, -5.0)) };
|
||||
let r = sse2::_mm_movemask_pd(f64x2::new(-1.0, -5.0));
|
||||
assert_eq!(r, 0b11);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 @@ fn _mm_blendv_epi8() {
|
||||
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 @@ fn _mm_shuffle_epi8() {
|
||||
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]
|
||||
|
||||
Reference in New Issue
Block a user