diff --git a/library/stdarch/src/x86/abm.rs b/library/stdarch/src/x86/abm.rs index ea779fabfc2e..4b9b49e81595 100644 --- a/library/stdarch/src/x86/abm.rs +++ b/library/stdarch/src/x86/abm.rs @@ -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); } } diff --git a/library/stdarch/src/x86/avx.rs b/library/stdarch/src/x86/avx.rs index e53f5670043f..828aeefe6e80 100644 --- a/library/stdarch/src/x86/avx.rs +++ b/library/stdarch/src/x86/avx.rs @@ -135,83 +135,83 @@ mod tests { use x86::avx; #[simd_test = "avx"] - fn _mm256_add_pd() { + unsafe fn _mm256_add_pd() { let a = f64x4::new(1.0, 2.0, 3.0, 4.0); let b = f64x4::new(5.0, 6.0, 7.0, 8.0); - let r = unsafe { avx::_mm256_add_pd(a, b) }; + let r = avx::_mm256_add_pd(a, b); let e = f64x4::new(6.0, 8.0, 10.0, 12.0); assert_eq!(r, e); } #[simd_test = "avx"] - fn _mm256_add_ps() { + unsafe fn _mm256_add_ps() { let a = f32x8::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0); let b = f32x8::new(9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0); - let r = unsafe { avx::_mm256_add_ps(a, b) }; + let r = avx::_mm256_add_ps(a, b); let e = f32x8::new(10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0); assert_eq!(r, e); } #[simd_test = "avx"] - fn _mm256_mul_pd() { + unsafe fn _mm256_mul_pd() { let a = f64x4::new(1.0, 2.0, 3.0, 4.0); let b = f64x4::new(5.0, 6.0, 7.0, 8.0); - let r = unsafe { avx::_mm256_mul_pd(a, b) }; + let r = avx::_mm256_mul_pd(a, b); let e = f64x4::new(5.0, 12.0, 21.0, 32.0); assert_eq!(r, e); } #[simd_test = "avx"] - fn _mm256_mul_ps() { + unsafe fn _mm256_mul_ps() { let a = f32x8::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0); let b = f32x8::new(9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0); - let r = unsafe { avx::_mm256_mul_ps(a, b) }; + let r = avx::_mm256_mul_ps(a, b); let e = f32x8::new(9.0, 20.0, 33.0, 48.0, 65.0, 84.0, 105.0, 128.0); assert_eq!(r, e); } #[simd_test = "avx"] - fn _mm256_addsub_pd() { + unsafe fn _mm256_addsub_pd() { let a = f64x4::new(1.0, 2.0, 3.0, 4.0); let b = f64x4::new(5.0, 6.0, 7.0, 8.0); - let r = unsafe { avx::_mm256_addsub_pd(a, b) }; + let r = avx::_mm256_addsub_pd(a, b); let e = f64x4::new(-4.0, 8.0, -4.0, 12.0); assert_eq!(r, e); } #[simd_test = "avx"] - fn _mm256_addsub_ps() { + unsafe fn _mm256_addsub_ps() { let a = f32x8::new(1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4.0); let b = f32x8::new(5.0, 6.0, 7.0, 8.0, 5.0, 6.0, 7.0, 8.0); - let r = unsafe { avx::_mm256_addsub_ps(a, b) }; + let r = avx::_mm256_addsub_ps(a, b); let e = f32x8::new(-4.0, 8.0, -4.0, 12.0, -4.0, 8.0, -4.0, 12.0); assert_eq!(r, e); } #[simd_test = "avx"] - fn _mm256_sub_pd() { + unsafe fn _mm256_sub_pd() { let a = f64x4::new(1.0, 2.0, 3.0, 4.0); let b = f64x4::new(5.0, 6.0, 7.0, 8.0); - let r = unsafe { avx::_mm256_sub_pd(a, b) }; + let r = avx::_mm256_sub_pd(a, b); let e = f64x4::new(-4.0,-4.0,-4.0,-4.0); assert_eq!(r, e); } #[simd_test = "avx"] - fn _mm256_sub_ps() { + unsafe fn _mm256_sub_ps() { let a = f32x8::new(1.0, 2.0, 3.0, 4.0, -1.0, -2.0, -3.0, -4.0); let b = f32x8::new(5.0, 6.0, 7.0, 8.0, 3.0, 2.0, 1.0, 0.0); - let r = unsafe { avx::_mm256_sub_ps(a, b) }; + let r = avx::_mm256_sub_ps(a, b); let e = f32x8::new(-4.0, -4.0, -4.0, -4.0, -4.0, -4.0, -4.0, -4.0); assert_eq!(r, e); } #[simd_test = "avx"] - fn _mm256_round_pd() { + unsafe fn _mm256_round_pd() { let a = f64x4::new(1.55, 2.2, 3.99, -1.2); - let result_closest = unsafe { avx::_mm256_round_pd(a, 0b00000000) }; - let result_down = unsafe { avx::_mm256_round_pd(a, 0b00000001) }; - let result_up = unsafe { avx::_mm256_round_pd(a, 0b00000010) }; + let result_closest = avx::_mm256_round_pd(a, 0b00000000); + let result_down = avx::_mm256_round_pd(a, 0b00000001); + let result_up = avx::_mm256_round_pd(a, 0b00000010); let expected_closest = f64x4::new(2.0, 2.0, 4.0, -1.0); let expected_down = f64x4::new(1.0, 2.0, 3.0, -2.0); let expected_up = f64x4::new(2.0, 3.0, 4.0, -1.0); @@ -221,17 +221,17 @@ mod tests { } #[simd_test = "avx"] - fn _mm256_floor_pd() { + unsafe fn _mm256_floor_pd() { let a = f64x4::new(1.55, 2.2, 3.99, -1.2); - let result_down = unsafe { avx::_mm256_floor_pd(a) }; + let result_down = avx::_mm256_floor_pd(a); let expected_down = f64x4::new(1.0, 2.0, 3.0, -2.0); assert_eq!(result_down, expected_down); } #[simd_test = "avx"] - fn _mm256_ceil_pd() { + unsafe fn _mm256_ceil_pd() { let a = f64x4::new(1.55, 2.2, 3.99, -1.2); - let result_up = unsafe { avx::_mm256_ceil_pd(a) }; + let result_up = avx::_mm256_ceil_pd(a); let expected_up = f64x4::new(2.0, 3.0, 4.0, -1.0); assert_eq!(result_up, expected_up); } diff --git a/library/stdarch/src/x86/avx2.rs b/library/stdarch/src/x86/avx2.rs index 6e3629f0e6ce..25868ed91cb6 100644 --- a/library/stdarch/src/x86/avx2.rs +++ b/library/stdarch/src/x86/avx2.rs @@ -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 @@ mod tests { } #[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 @@ mod tests { } #[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 @@ mod tests { -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 @@ mod tests { } #[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 @@ mod tests { } #[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 @@ mod tests { 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 @@ mod tests { } #[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 @@ mod tests { } #[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 @@ mod tests { } #[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 @@ mod tests { } #[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 @@ mod tests { } #[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 @@ mod tests { // 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 @@ mod tests { // 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 @@ mod tests { **/ #[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 @@ mod tests { } #[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 @@ mod tests { } #[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 @@ mod tests { } #[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 @@ mod tests { } #[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)); } } diff --git a/library/stdarch/src/x86/bmi.rs b/library/stdarch/src/x86/bmi.rs index a422410f918a..039318991551 100644 --- a/library/stdarch/src/x86/bmi.rs +++ b/library/stdarch/src/x86/bmi.rs @@ -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); } } diff --git a/library/stdarch/src/x86/bmi2.rs b/library/stdarch/src/x86/bmi2.rs index 7779fac68f50..22cd3b4dc14e 100644 --- a/library/stdarch/src/x86/bmi2.rs +++ b/library/stdarch/src/x86/bmi2.rs @@ -117,7 +117,7 @@ mod tests { use x86::bmi2; #[simd_test = "bmi2"] - fn _pext_u32() { + unsafe fn _pext_u32() { let n = 0b1011_1110_1001_0011u32; let m0 = 0b0110_0011_1000_0101u32; @@ -126,13 +126,13 @@ mod tests { let m1 = 0b1110_1011_1110_1111u32; let s1 = 0b0001_0111_0100_0011u32; - assert_eq!(unsafe { bmi2::_pext_u32(n, m0) }, s0); - assert_eq!(unsafe { bmi2::_pext_u32(n, m1) }, s1); + assert_eq!(bmi2::_pext_u32(n, m0), s0); + assert_eq!(bmi2::_pext_u32(n, m1), s1); } #[simd_test = "bmi2"] #[cfg(not(target_arch = "x86"))] - fn _pext_u64() { + unsafe fn _pext_u64() { let n = 0b1011_1110_1001_0011u64; let m0 = 0b0110_0011_1000_0101u64; @@ -141,12 +141,12 @@ mod tests { let m1 = 0b1110_1011_1110_1111u64; let s1 = 0b0001_0111_0100_0011u64; - assert_eq!(unsafe { bmi2::_pext_u64(n, m0) }, s0); - assert_eq!(unsafe { bmi2::_pext_u64(n, m1) }, s1); + assert_eq!(bmi2::_pext_u64(n, m0), s0); + assert_eq!(bmi2::_pext_u64(n, m1), s1); } #[simd_test = "bmi2"] - fn _pdep_u32() { + unsafe fn _pdep_u32() { let n = 0b1011_1110_1001_0011u32; let m0 = 0b0110_0011_1000_0101u32; @@ -155,13 +155,13 @@ mod tests { let m1 = 0b1110_1011_1110_1111u32; let s1 = 0b1110_1001_0010_0011u32; - assert_eq!(unsafe { bmi2::_pdep_u32(n, m0) }, s0); - assert_eq!(unsafe { bmi2::_pdep_u32(n, m1) }, s1); + assert_eq!(bmi2::_pdep_u32(n, m0), s0); + assert_eq!(bmi2::_pdep_u32(n, m1), s1); } #[simd_test = "bmi2"] #[cfg(not(target_arch = "x86"))] - fn _pdep_u64() { + unsafe fn _pdep_u64() { let n = 0b1011_1110_1001_0011u64; let m0 = 0b0110_0011_1000_0101u64; @@ -170,30 +170,30 @@ mod tests { let m1 = 0b1110_1011_1110_1111u64; let s1 = 0b1110_1001_0010_0011u64; - assert_eq!(unsafe { bmi2::_pdep_u64(n, m0) }, s0); - assert_eq!(unsafe { bmi2::_pdep_u64(n, m1) }, s1); + assert_eq!(bmi2::_pdep_u64(n, m0), s0); + assert_eq!(bmi2::_pdep_u64(n, m1), s1); } #[simd_test = "bmi2"] - fn _bzhi_u32() { + unsafe fn _bzhi_u32() { let n = 0b1111_0010u32; let s = 0b0001_0010u32; - assert_eq!(unsafe { bmi2::_bzhi_u32(n, 5) }, s); + assert_eq!(bmi2::_bzhi_u32(n, 5), s); } #[simd_test = "bmi2"] #[cfg(not(target_arch = "x86"))] - fn _bzhi_u64() { + unsafe fn _bzhi_u64() { let n = 0b1111_0010u64; let s = 0b0001_0010u64; - assert_eq!(unsafe { bmi2::_bzhi_u64(n, 5) }, s); + assert_eq!(bmi2::_bzhi_u64(n, 5), s); } #[simd_test = "bmi2"] - fn _mulx_u32() { + unsafe fn _mulx_u32() { let a: u32 = 4_294_967_200; let b: u32 = 2; - let (lo, hi): (u32, u32) = unsafe { bmi2::_mulx_u32(a, b) }; + let (lo, hi): (u32, u32) = bmi2::_mulx_u32(a, b); // result = 8589934400 // = 0b0001_1111_1111_1111_1111_1111_1111_0100_0000u64 // ^~hi ^~lo~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -203,10 +203,10 @@ mod tests { #[simd_test = "bmi2"] #[cfg(not(target_arch = "x86"))] - fn _mulx_u64() { + unsafe fn _mulx_u64() { let a: u64 = 9_223_372_036_854_775_800; let b: u64 = 100; - let (lo, hi): (u64, u64) = unsafe { bmi2::_mulx_u64(a, b) }; + let (lo, hi): (u64, u64) = bmi2::_mulx_u64(a, b); // result = 922337203685477580000 // = 0b00110001_11111111_11111111_11111111_11111111_11111111_11111111_11111100_11100000u128 // ^~hi~~~~ ^~lo~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/library/stdarch/src/x86/sse.rs b/library/stdarch/src/x86/sse.rs index b557cd0445ce..217bbd8b4637 100644 --- a/library/stdarch/src/x86/sse.rs +++ b/library/stdarch/src/x86/sse.rs @@ -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); } } diff --git a/library/stdarch/src/x86/sse2.rs b/library/stdarch/src/x86/sse2.rs index 80fac197facb..28d798edc825 100644 --- a/library/stdarch/src/x86/sse2.rs +++ b/library/stdarch/src/x86/sse2.rs @@ -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 @@ mod tests { } #[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 @@ mod tests { } #[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 @@ mod tests { } #[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 @@ mod tests { } #[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); } } diff --git a/library/stdarch/src/x86/sse41.rs b/library/stdarch/src/x86/sse41.rs index 6b81b2d51b06..11519c8f1169 100644 --- a/library/stdarch/src/x86/sse41.rs +++ b/library/stdarch/src/x86/sse41.rs @@ -79,7 +79,7 @@ mod tests { use x86::sse41; #[simd_test = "sse4.1"] - fn _mm_blendv_epi8() { + unsafe fn _mm_blendv_epi8() { let a = i8x16::new( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); let b = i8x16::new( @@ -88,22 +88,22 @@ mod tests { 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1); let e = i8x16::new( 0, 17, 2, 19, 4, 21, 6, 23, 8, 25, 10, 27, 12, 29, 14, 31); - assert_eq!(unsafe { sse41::_mm_blendv_epi8(a, b, mask) }, e); + assert_eq!(sse41::_mm_blendv_epi8(a, b, mask), e); } #[simd_test = "sse4.1"] - fn _mm_dp_pd() { + unsafe fn _mm_dp_pd() { let a = f64x2::new(2.0, 3.0); let b = f64x2::new(1.0, 4.0); let e = f64x2::new(14.0, 0.0); - assert_eq!(unsafe { sse41::_mm_dp_pd(a, b, 0b00110001) }, e); + assert_eq!(sse41::_mm_dp_pd(a, b, 0b00110001), e); } #[simd_test = "sse4.1"] - fn _mm_dp_ps() { + unsafe fn _mm_dp_ps() { let a = f32x4::new(2.0, 3.0, 1.0, 10.0); let b = f32x4::new(1.0, 4.0, 0.5, 10.0); let e = f32x4::new(14.5, 0.0, 14.5, 0.0); - assert_eq!(unsafe { sse41::_mm_dp_ps(a, b, 0b01110101) }, e); + assert_eq!(sse41::_mm_dp_ps(a, b, 0b01110101), e); } } diff --git a/library/stdarch/src/x86/sse42.rs b/library/stdarch/src/x86/sse42.rs index 70e024f79639..8a18f31264be 100644 --- a/library/stdarch/src/x86/sse42.rs +++ b/library/stdarch/src/x86/sse42.rs @@ -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); } } diff --git a/library/stdarch/src/x86/ssse3.rs b/library/stdarch/src/x86/ssse3.rs index 1f6c7488a1a1..461e6f8f2a50 100644 --- a/library/stdarch/src/x86/ssse3.rs +++ b/library/stdarch/src/x86/ssse3.rs @@ -60,13 +60,13 @@ mod tests { use x86::ssse3 as ssse3; #[simd_test = "ssse3"] - fn _mm_abs_epi8() { - let r = unsafe { ssse3::_mm_abs_epi8(i8x16::splat(-5)) }; + unsafe fn _mm_abs_epi8() { + let r = ssse3::_mm_abs_epi8(i8x16::splat(-5)); assert_eq!(r, u8x16::splat(5)); } #[simd_test = "ssse3"] - fn _mm_shuffle_epi8() { + unsafe fn _mm_shuffle_epi8() { let a = u8x16::new( 1, 2, 3, 4, 5, 6, 7, 8, @@ -85,7 +85,7 @@ mod tests { 13, 6, 6, 11, 5, 2, 9, 1, ); - let r = unsafe { ssse3::_mm_shuffle_epi8(a, b) }; + let r = ssse3::_mm_shuffle_epi8(a, b); assert_eq!(r, expected); } } diff --git a/library/stdarch/src/x86/tbm.rs b/library/stdarch/src/x86/tbm.rs index 8611eed58172..d38fc3fa10f4 100644 --- a/library/stdarch/src/x86/tbm.rs +++ b/library/stdarch/src/x86/tbm.rs @@ -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); } } diff --git a/library/stdarch/stdsimd-test/simd-test-macro/src/lib.rs b/library/stdarch/stdsimd-test/simd-test-macro/src/lib.rs index 35581fb45695..fd41c0f7f5b6 100644 --- a/library/stdarch/stdsimd-test/simd-test-macro/src/lib.rs +++ b/library/stdarch/stdsimd-test/simd-test-macro/src/lib.rs @@ -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]