Formatting

Author: p32blo

src/lib.rs

@@ -194,10 +194,7 @@ mod v16 {
     define_ty! { u8x2, u8, u8 }
     define_impl! { u8x2, u8, 2, i8x2, x0, x1 }
 
-    define_casts!(
-        (i8x2, i64x2, as_i64x2),
-        (u8x2, i64x2, as_i64x2)
-    );
+    define_casts!((i8x2, i64x2, as_i64x2), (u8x2, i64x2, as_i64x2));
 }
 
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]

src/x86/sse41.rs

@@ -334,44 +334,49 @@ pub unsafe fn _mm_cvtepu8_epi64(a: u8x16) -> i64x2 {
     simd_shuffle2::<_, ::v16::u8x2>(a, a, [0, 1]).as_i64x2()
 }
 
-/// Zero extend packed unsigned 16-bit integers in `a` to packed 32-bit integers
+/// Zero extend packed unsigned 16-bit integers in `a`
+/// to packed 32-bit integers
 #[inline(always)]
 #[target_feature = "+sse4.1"]
 #[cfg_attr(test, assert_instr(pmovzxwd))]
 pub unsafe fn _mm_cvtepu16_epi32(a: u16x8) -> i32x4 {
     simd_shuffle4::<_, ::v64::u16x4>(a, a, [0, 1, 2, 3]).as_i32x4()
 }
 
-/// Zero extend packed unsigned 16-bit integers in `a` to packed 64-bit integers
+/// Zero extend packed unsigned 16-bit integers in `a`
+/// to packed 64-bit integers
 #[inline(always)]
 #[target_feature = "+sse4.1"]
 #[cfg_attr(test, assert_instr(pmovzxwq))]
 pub unsafe fn _mm_cvtepu16_epi64(a: u16x8) -> i64x2 {
     simd_shuffle2::<_, ::v32::u16x2>(a, a, [0, 1]).as_i64x2()
 }
 
-/// Zero extend packed unsigned 32-bit integers in `a` to packed 64-bit integers
+/// Zero extend packed unsigned 32-bit integers in `a`
+/// to packed 64-bit integers
 #[inline(always)]
 #[target_feature = "+sse4.1"]
 #[cfg_attr(test, assert_instr(pmovzxdq))]
 pub unsafe fn _mm_cvtepu32_epi64(a: u32x4) -> i64x2 {
     simd_shuffle2::<_, ::v64::u32x2>(a, a, [0, 1]).as_i64x2()
 }
 
-/// Multiply the low 32-bit integers from each packed 64-bit element in `a` and `b`
+/// Multiply the low 32-bit integers from each packed 64-bit
+/// element in `a` and `b`
 #[inline(always)]
 #[target_feature = "+sse4.1"]
 #[cfg_attr(test, assert_instr(pmuldq))]
-pub unsafe fn _mm_mul_epi32(a: i32x4, b:i32x4) -> i64x2 {
+pub unsafe fn _mm_mul_epi32(a: i32x4, b: i32x4) -> i64x2 {
     pmuldq(a, b)
 }
 
-/// Multiply the packed 32-bit integers in `a` and `b`, producing intermediate 64-bit integers,
-/// and return the low 32 bits of the intermediate integers.
+/// Multiply the packed 32-bit integers in `a` and `b`,
+/// producing intermediate 64-bit integers, and return
+/// the low 32 bits of the intermediate integers.
 #[inline(always)]
 #[target_feature = "+sse4.1"]
 #[cfg_attr(test, assert_instr(pmulld))]
-pub unsafe fn _mm_mullo_epi32 (a: i32x4, b:i32x4) -> i32x4 {
+pub unsafe fn _mm_mullo_epi32(a: i32x4, b: i32x4) -> i32x4 {
     a * b
 }
 
@@ -381,7 +386,8 @@ pub unsafe fn _mm_mullo_epi32 (a: i32x4, b:i32x4) -> i32x4 {
 /// Arguments:
 ///
 /// * `a` - A 128-bit integer vector containing the bits to be tested.
-/// * `mask` - A 128-bit integer vector selecting which bits to test in operand `a`.
+/// * `mask` - A 128-bit integer vector selecting which bits to test in
+///            operand `a`.
 ///
 /// Returns:
 ///
@@ -400,7 +406,8 @@ pub unsafe fn _mm_testz_si128(a: __m128i, mask: __m128i) -> i32 {
 /// Arguments:
 ///
 /// * `a` - A 128-bit integer vector containing the bits to be tested.
-/// * `mask` - A 128-bit integer vector selecting which bits to test in operand `a`.
+/// * `mask` - A 128-bit integer vector selecting which bits to test in
+///            operand `a`.
 ///
 /// Returns:
 ///
@@ -419,7 +426,8 @@ pub unsafe fn _mm_testc_si128(a: __m128i, mask: __m128i) -> i32 {
 /// Arguments:
 ///
 /// * `a` - A 128-bit integer vector containing the bits to be tested.
-/// * `mask` - A 128-bit integer vector selecting which bits to test in operand `a`.
+/// * `mask` - A 128-bit integer vector selecting which bits to test in
+///            operand `a`.
 ///
 /// Returns:
 ///
@@ -438,7 +446,8 @@ pub unsafe fn _mm_testnzc_si128(a: __m128i, mask: __m128i) -> i32 {
 /// Arguments:
 ///
 /// * `a` - A 128-bit integer vector containing the bits to be tested.
-/// * `mask` - A 128-bit integer vector selecting which bits to test in operand `a`.
+/// * `mask` - A 128-bit integer vector selecting which bits to test in
+///            operand `a`.
 ///
 /// Returns:
 ///
@@ -476,7 +485,8 @@ pub unsafe fn _mm_test_all_ones(a: __m128i) -> i32 {
 /// Arguments:
 ///
 /// * `a` - A 128-bit integer vector containing the bits to be tested.
-/// * `mask` - A 128-bit integer vector selecting which bits to test in operand `a`.
+/// * `mask` - A 128-bit integer vector selecting which bits to test in
+///            operand `a`.
 ///
 /// Returns:
 ///
@@ -758,7 +768,7 @@ pub unsafe fn _mm_minpos_epu16(a: u16x8) -> u16x8 {
 /// fields in the immediate operand.
 ///
 /// The following algorithm is performed:
-/// 
+///
 /// ```ignore
 /// i = imm8[2] * 4
 /// j = imm8[1:0] * 4
@@ -769,13 +779,13 @@ pub unsafe fn _mm_minpos_epu16(a: u16x8) -> u16x8 {
 ///     d3 = abs(a[i + k + 3] - b[j + 3])
 ///     r[k] = d0 + d1 + d2 + d3
 /// ```
-/// 
+///
 /// Arguments:
 ///
 /// * `a` - A 128-bit vector of type `i8x16`.
 /// * `b` - A 128-bit vector of type `i8x16`.
-/// * `imm8` - An 8-bit immediate operand specifying how the absolute differences are to
-///            be calculated
+/// * `imm8` - An 8-bit immediate operand specifying how the absolute
+///            differences are to be calculated
 ///     * Bit `[2]` specify the offset for operand `a`
 ///     * Bits `[1:0]` specify the offset for operand `b`
 ///
@@ -785,7 +795,7 @@ pub unsafe fn _mm_minpos_epu16(a: u16x8) -> u16x8 {
 ///   absolute differences between both operands.
 #[inline(always)]
 #[target_feature = "+sse4.1"]
-#[cfg_attr(test, assert_instr(mpsadbw, imm8=0))]
+#[cfg_attr(test, assert_instr(mpsadbw, imm8 = 0))]
 pub unsafe fn _mm_mpsadbw_epu8(a: u8x16, b: u8x16, imm8: u8) -> u16x8 {
     macro_rules! call {
         ($imm8:expr) => { mpsadbw(a, b, $imm8) }
@@ -1130,7 +1140,7 @@ mod tests {
         let r = sse41::_mm_cvtepi32_epi64(a);
         let e = i64x2::splat(10);
         assert_eq!(r, e);
-        let a =  i32x4::splat(-10);
+        let a = i32x4::splat(-10);
         let r = sse41::_mm_cvtepi32_epi64(a);
         let e = i64x2::splat(-10);
         assert_eq!(r, e);
@@ -1204,99 +1214,99 @@ mod tests {
 
     #[simd_test = "sse4.1"]
     unsafe fn _mm_testz_si128() {
-        let a    = __m128i::splat(1);
+        let a = __m128i::splat(1);
         let mask = __m128i::splat(0);
-        let r    = sse41::_mm_testz_si128(a, mask);
+        let r = sse41::_mm_testz_si128(a, mask);
         assert_eq!(r, 1);
-        let a    = __m128i::splat(0b101);
+        let a = __m128i::splat(0b101);
         let mask = __m128i::splat(0b110);
-        let r    = sse41::_mm_testz_si128(a, mask);
+        let r = sse41::_mm_testz_si128(a, mask);
         assert_eq!(r, 0);
-        let a    = __m128i::splat(0b011);
+        let a = __m128i::splat(0b011);
         let mask = __m128i::splat(0b100);
-        let r    = sse41::_mm_testz_si128(a, mask);
+        let r = sse41::_mm_testz_si128(a, mask);
         assert_eq!(r, 1);
     }
 
     #[simd_test = "sse4.1"]
     unsafe fn _mm_testc_si128() {
-        let a    = __m128i::splat(-1);
+        let a = __m128i::splat(-1);
         let mask = __m128i::splat(0);
-        let r    = sse41::_mm_testc_si128(a, mask);
+        let r = sse41::_mm_testc_si128(a, mask);
         assert_eq!(r, 1);
-        let a    = __m128i::splat(0b101);
+        let a = __m128i::splat(0b101);
         let mask = __m128i::splat(0b110);
-        let r    = sse41::_mm_testc_si128(a, mask);
+        let r = sse41::_mm_testc_si128(a, mask);
         assert_eq!(r, 0);
-        let a    = __m128i::splat(0b101);
+        let a = __m128i::splat(0b101);
         let mask = __m128i::splat(0b100);
-        let r    = sse41::_mm_testc_si128(a, mask);
+        let r = sse41::_mm_testc_si128(a, mask);
         assert_eq!(r, 1);
     }
 
     #[simd_test = "sse4.1"]
     unsafe fn _mm_testnzc_si128() {
-        let a    = __m128i::splat(0);
+        let a = __m128i::splat(0);
         let mask = __m128i::splat(1);
-        let r    = sse41::_mm_testnzc_si128(a, mask);
+        let r = sse41::_mm_testnzc_si128(a, mask);
         assert_eq!(r, 0);
-        let a    = __m128i::splat(-1);
+        let a = __m128i::splat(-1);
         let mask = __m128i::splat(0);
-        let r    = sse41::_mm_testnzc_si128(a, mask);
+        let r = sse41::_mm_testnzc_si128(a, mask);
         assert_eq!(r, 0);
-        let a    = __m128i::splat(0b101);
+        let a = __m128i::splat(0b101);
         let mask = __m128i::splat(0b110);
-        let r    = sse41::_mm_testnzc_si128(a, mask);
+        let r = sse41::_mm_testnzc_si128(a, mask);
         assert_eq!(r, 1);
-        let a    = __m128i::splat(0b101);
+        let a = __m128i::splat(0b101);
         let mask = __m128i::splat(0b101);
-        let r    = sse41::_mm_testnzc_si128(a, mask);
+        let r = sse41::_mm_testnzc_si128(a, mask);
         assert_eq!(r, 0);
     }
 
     #[simd_test = "sse4.1"]
     unsafe fn _mm_test_all_zeros() {
-        let a    = __m128i::splat(1);
+        let a = __m128i::splat(1);
         let mask = __m128i::splat(0);
-        let r    = sse41::_mm_test_all_zeros(a, mask);
+        let r = sse41::_mm_test_all_zeros(a, mask);
         assert_eq!(r, 1);
-        let a    = __m128i::splat(0b101);
+        let a = __m128i::splat(0b101);
         let mask = __m128i::splat(0b110);
-        let r    = sse41::_mm_test_all_zeros(a, mask);
+        let r = sse41::_mm_test_all_zeros(a, mask);
         assert_eq!(r, 0);
-        let a    = __m128i::splat(0b011);
+        let a = __m128i::splat(0b011);
         let mask = __m128i::splat(0b100);
-        let r    = sse41::_mm_test_all_zeros(a, mask);
+        let r = sse41::_mm_test_all_zeros(a, mask);
         assert_eq!(r, 1);
     }
 
     #[simd_test = "sse4.1"]
     unsafe fn _mm_test_all_ones() {
-        let a    = __m128i::splat(-1);
-        let r    = sse41::_mm_test_all_ones(a);
+        let a = __m128i::splat(-1);
+        let r = sse41::_mm_test_all_ones(a);
         assert_eq!(r, 1);
-        let a    = __m128i::splat(0b101);
-        let r    = sse41::_mm_test_all_ones(a);
+        let a = __m128i::splat(0b101);
+        let r = sse41::_mm_test_all_ones(a);
         assert_eq!(r, 0);
     }
 
     #[simd_test = "sse4.1"]
     unsafe fn _mm_test_mix_ones_zeros() {
-        let a    = __m128i::splat(0);
+        let a = __m128i::splat(0);
         let mask = __m128i::splat(1);
-        let r    = sse41::_mm_test_mix_ones_zeros(a, mask);
+        let r = sse41::_mm_test_mix_ones_zeros(a, mask);
         assert_eq!(r, 0);
-        let a    = __m128i::splat(-1);
+        let a = __m128i::splat(-1);
         let mask = __m128i::splat(0);
-        let r    = sse41::_mm_test_mix_ones_zeros(a, mask);
+        let r = sse41::_mm_test_mix_ones_zeros(a, mask);
         assert_eq!(r, 0);
-        let a    = __m128i::splat(0b101);
+        let a = __m128i::splat(0b101);
         let mask = __m128i::splat(0b110);
-        let r    = sse41::_mm_test_mix_ones_zeros(a, mask);
+        let r = sse41::_mm_test_mix_ones_zeros(a, mask);
         assert_eq!(r, 1);
-        let a    = __m128i::splat(0b101);
+        let a = __m128i::splat(0b101);
         let mask = __m128i::splat(0b101);
-        let r    = sse41::_mm_test_mix_ones_zeros(a, mask);
+        let r = sse41::_mm_test_mix_ones_zeros(a, mask);
         assert_eq!(r, 0);
     }
 
@@ -1436,7 +1446,8 @@ mod tests {
 
     #[simd_test = "sse4.1"]
     unsafe fn _mm_mpsadbw_epu8() {
-        let a = u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+        let a =
+            u8x16::new(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
 
         let r = sse41::_mm_mpsadbw_epu8(a, a, 0b000);
         let e = u16x8::new(0, 4, 8, 12, 16, 20, 24, 28);
@@ -1445,7 +1456,7 @@ mod tests {
         let r = sse41::_mm_mpsadbw_epu8(a, a, 0b001);
         let e = u16x8::new(16, 12, 8, 4, 0, 4, 8, 12);
         assert_eq!(r, e);
-        
+
         let r = sse41::_mm_mpsadbw_epu8(a, a, 0b100);
         let e = u16x8::new(16, 20, 24, 28, 32, 36, 40, 44);
         assert_eq!(r, e);