Remove some casts

marmeladema · marmeladema · commit d9a647b3d07a · 2022-04-14T01:28:13.000+02:00
diff --git a/src/aarch64.rs b/src/aarch64.rs
@@ -49,7 +49,7 @@ impl Vector for uint8x16_t {
     }
 
     #[inline]
-    unsafe fn to_bitmask(a: Self) -> i32 {
+    unsafe fn to_bitmask(a: Self) -> u32 {
         let extended = vreinterpretq_u8_s8(vshrq_n_s8(vreinterpretq_s8_u8(a), 7));
         let masked = vandq_u8(vld1q_u8(MD.as_ptr()), extended);
         let maskedhi = vextq_u8(masked, masked, 8);
@@ -82,7 +82,7 @@ impl Vector for uint8x8_t {
     }
 
     #[inline]
-    unsafe fn to_bitmask(a: Self) -> i32 {
+    unsafe fn to_bitmask(a: Self) -> u32 {
         vaddv_u8(vand_u8(
             vreinterpret_u8_s8(vshr_n_s8(vreinterpret_s8_u8(a), 7)),
             vld1_u8(MD.as_ptr()),
@@ -121,7 +121,7 @@ impl Vector for uint8x4_t {
     }
 
     #[inline]
-    unsafe fn to_bitmask(a: Self) -> i32 {
+    unsafe fn to_bitmask(a: Self) -> u32 {
         uint8x8_t::to_bitmask(a.0) & 0xF
     }
 }
@@ -162,7 +162,7 @@ impl Vector for uint8x2_t {
     }
 
     #[inline]
-    unsafe fn to_bitmask(a: Self) -> i32 {
+    unsafe fn to_bitmask(a: Self) -> u32 {
         uint8x8_t::to_bitmask(a.0) & 0x3
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -166,7 +166,7 @@ trait Vector: Copy {
 
     unsafe fn bitwise_and(a: Self::Mask, b: Self::Mask) -> Self::Mask;
 
-    unsafe fn to_bitmask(a: Self::Mask) -> i32;
+    unsafe fn to_bitmask(a: Self::Mask) -> u32;
 }
 
 /// Hash of the first and "last" bytes in the needle for use with the SIMD
@@ -209,10 +209,9 @@ trait Searcher<N: NeedleWithSize + ?Sized> {
     #[clone(target = "aarch64+neon")]
     unsafe fn vector_search_in_chunk<V: Vector>(
         &self,
-        haystack: &[u8],
         hash: &VectorHash<V>,
         start: *const u8,
-        mask: i32,
+        mask: u32,
     ) -> bool {
         let first = V::load(start);
         let last = V::load(start.add(self.position()));
@@ -221,10 +220,9 @@ trait Searcher<N: NeedleWithSize + ?Sized> {
         let eq_last = V::lanes_eq(hash.last, last);
 
         let eq = V::bitwise_and(eq_first, eq_last);
-        let mut eq = (V::to_bitmask(eq) & mask) as u32;
+        let mut eq = V::to_bitmask(eq) & mask;
 
-        let start = start as usize - haystack.as_ptr() as usize;
-        let chunk = haystack.as_ptr().add(start + 1);
+        let chunk = start.add(1);
         let needle = self.needle().as_bytes().as_ptr().add(1);
 
         while eq != 0 {
@@ -273,17 +271,17 @@ trait Searcher<N: NeedleWithSize + ?Sized> {
 
         let mut chunks = haystack[..end].chunks_exact(V::LANES);
         for chunk in &mut chunks {
-            if dispatch!(self.vector_search_in_chunk(haystack, hash, chunk.as_ptr(), -1)) {
+            if dispatch!(self.vector_search_in_chunk(hash, chunk.as_ptr(), u32::MAX)) {
                 return true;
             }
         }
 
         let remainder = chunks.remainder().len();
         if remainder > 0 {
             let start = haystack.as_ptr().add(end - V::LANES);
-            let mask = -1 << (V::LANES - remainder);
+            let mask = u32::MAX << (V::LANES - remainder);
 
-            if dispatch!(self.vector_search_in_chunk(haystack, hash, start, mask)) {
+            if dispatch!(self.vector_search_in_chunk(hash, start, mask)) {
                 return true;
             }
         }
diff --git a/src/stdsimd.rs b/src/stdsimd.rs
@@ -30,7 +30,7 @@ where
 
     #[inline]
     unsafe fn splat(a: u8) -> Self {
-        Simd::splat(a as u8)
+        Simd::splat(a)
     }
 
     #[inline]
@@ -49,8 +49,8 @@ where
     }
 
     #[inline]
-    unsafe fn to_bitmask(a: Self::Mask) -> i32 {
-        std::mem::transmute(a.to_fixed_bitmask())
+    unsafe fn to_bitmask(a: Self::Mask) -> u32 {
+        a.to_fixed_bitmask()
     }
 }
 
diff --git a/src/wasm32.rs b/src/wasm32.rs
@@ -34,8 +34,8 @@ impl Vector for v128 {
 
     #[inline]
     #[target_feature(enable = "simd128")]
-    unsafe fn to_bitmask(a: Self) -> i32 {
-        u8x16_bitmask(a) as i32
+    unsafe fn to_bitmask(a: Self) -> u32 {
+        u8x16_bitmask(a).into()
     }
 }
 
@@ -74,8 +74,8 @@ impl Vector for v64 {
 
     #[inline]
     #[target_feature(enable = "simd128")]
-    unsafe fn to_bitmask(a: Self) -> i32 {
-        (u8x16_bitmask(a.0) & 0xFF) as i32
+    unsafe fn to_bitmask(a: Self) -> u32 {
+        (u8x16_bitmask(a.0) & 0xFF).into()
     }
 }
 
@@ -120,8 +120,8 @@ impl Vector for v32 {
 
     #[inline]
     #[target_feature(enable = "simd128")]
-    unsafe fn to_bitmask(a: Self) -> i32 {
-        (u8x16_bitmask(a.0) & 0xF) as i32
+    unsafe fn to_bitmask(a: Self) -> u32 {
+        (u8x16_bitmask(a.0) & 0xF).into()
     }
 }
 
@@ -166,8 +166,8 @@ impl Vector for v16 {
 
     #[inline]
     #[target_feature(enable = "simd128")]
-    unsafe fn to_bitmask(a: Self) -> i32 {
-        (u8x16_bitmask(a.0) & 0x3) as i32
+    unsafe fn to_bitmask(a: Self) -> u32 {
+        (u8x16_bitmask(a.0) & 0x3).into()
     }
 }
 
diff --git a/src/x86.rs b/src/x86.rs
@@ -58,8 +58,8 @@ impl Vector for __m16i {
 
     #[inline]
     #[target_feature(enable = "avx2")]
-    unsafe fn to_bitmask(a: Self) -> i32 {
-        _mm_movemask_epi8(a.0) & 0x3
+    unsafe fn to_bitmask(a: Self) -> u32 {
+        std::mem::transmute(_mm_movemask_epi8(a.0) & 0x3)
     }
 }
 
@@ -105,8 +105,8 @@ impl Vector for __m32i {
 
     #[inline]
     #[target_feature(enable = "avx2")]
-    unsafe fn to_bitmask(a: Self) -> i32 {
-        _mm_movemask_epi8(a.0) & 0xF
+    unsafe fn to_bitmask(a: Self) -> u32 {
+        std::mem::transmute(_mm_movemask_epi8(a.0) & 0xF)
     }
 }
 
@@ -152,8 +152,8 @@ impl Vector for __m64i {
 
     #[inline]
     #[target_feature(enable = "avx2")]
-    unsafe fn to_bitmask(a: Self) -> i32 {
-        _mm_movemask_epi8(a.0) & 0xFF
+    unsafe fn to_bitmask(a: Self) -> u32 {
+        std::mem::transmute(_mm_movemask_epi8(a.0) & 0xFF)
     }
 }
 
@@ -194,8 +194,8 @@ impl Vector for __m128i {
 
     #[inline]
     #[target_feature(enable = "avx2")]
-    unsafe fn to_bitmask(a: Self) -> i32 {
-        _mm_movemask_epi8(a)
+    unsafe fn to_bitmask(a: Self) -> u32 {
+        std::mem::transmute(_mm_movemask_epi8(a))
     }
 }
 
@@ -229,8 +229,8 @@ impl Vector for __m256i {
 
     #[inline]
     #[target_feature(enable = "avx2")]
-    unsafe fn to_bitmask(a: Self) -> i32 {
-        _mm256_movemask_epi8(a)
+    unsafe fn to_bitmask(a: Self) -> u32 {
+        std::mem::transmute(_mm256_movemask_epi8(a))
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ impl Vector for uint8x16_t {`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`#[inline]`
`52`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
	`52`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
`53`	`53`	`let extended = vreinterpretq_u8_s8(vshrq_n_s8(vreinterpretq_s8_u8(a), 7));`
`54`	`54`	`let masked = vandq_u8(vld1q_u8(MD.as_ptr()), extended);`
`55`	`55`	`let maskedhi = vextq_u8(masked, masked, 8);`
`@@ -82,7 +82,7 @@ impl Vector for uint8x8_t {`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`#[inline]`
`85`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
	`85`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
`86`	`86`	`vaddv_u8(vand_u8(`
`87`	`87`	`vreinterpret_u8_s8(vshr_n_s8(vreinterpret_s8_u8(a), 7)),`
`88`	`88`	`vld1_u8(MD.as_ptr()),`
`@@ -121,7 +121,7 @@ impl Vector for uint8x4_t {`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`#[inline]`
`124`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
	`124`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
`125`	`125`	`uint8x8_t::to_bitmask(a.0) & 0xF`
`126`	`126`	`}`
`127`	`127`	`}`
`@@ -162,7 +162,7 @@ impl Vector for uint8x2_t {`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`#[inline]`
`165`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
	`165`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
`166`	`166`	`uint8x8_t::to_bitmask(a.0) & 0x3`
`167`	`167`	`}`
`168`	`168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ where`
`30`	`30`
`31`	`31`	`#[inline]`
`32`	`32`	`unsafe fn splat(a: u8) -> Self {`
`33`		`- Simd::splat(a as u8)`
	`33`	`+ Simd::splat(a)`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`#[inline]`
`@@ -49,8 +49,8 @@ where`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`#[inline]`
`52`		`- unsafe fn to_bitmask(a: Self::Mask) -> i32 {`
`53`		`- std::mem::transmute(a.to_fixed_bitmask())`
	`52`	`+ unsafe fn to_bitmask(a: Self::Mask) -> u32 {`
	`53`	`+ a.to_fixed_bitmask()`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
Original file line number	Diff line number	Diff line change
`@@ -34,8 +34,8 @@ impl Vector for v128 {`
`34`	`34`
`35`	`35`	`#[inline]`
`36`	`36`	`#[target_feature(enable = "simd128")]`
`37`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
`38`		`- u8x16_bitmask(a) as i32`
	`37`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
	`38`	`+ u8x16_bitmask(a).into()`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`@@ -74,8 +74,8 @@ impl Vector for v64 {`
`74`	`74`
`75`	`75`	`#[inline]`
`76`	`76`	`#[target_feature(enable = "simd128")]`
`77`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
`78`		`- (u8x16_bitmask(a.0) & 0xFF) as i32`
	`77`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
	`78`	`+ (u8x16_bitmask(a.0) & 0xFF).into()`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`@@ -120,8 +120,8 @@ impl Vector for v32 {`
`120`	`120`
`121`	`121`	`#[inline]`
`122`	`122`	`#[target_feature(enable = "simd128")]`
`123`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
`124`		`- (u8x16_bitmask(a.0) & 0xF) as i32`
	`123`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
	`124`	`+ (u8x16_bitmask(a.0) & 0xF).into()`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`
`@@ -166,8 +166,8 @@ impl Vector for v16 {`
`166`	`166`
`167`	`167`	`#[inline]`
`168`	`168`	`#[target_feature(enable = "simd128")]`
`169`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
`170`		`- (u8x16_bitmask(a.0) & 0x3) as i32`
	`169`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
	`170`	`+ (u8x16_bitmask(a.0) & 0x3).into()`
`171`	`171`	`}`
`172`	`172`	`}`
`173`	`173`
Original file line number	Diff line number	Diff line change
`@@ -58,8 +58,8 @@ impl Vector for __m16i {`
`58`	`58`
`59`	`59`	`#[inline]`
`60`	`60`	`#[target_feature(enable = "avx2")]`
`61`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
`62`		`- _mm_movemask_epi8(a.0) & 0x3`
	`61`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
	`62`	`+ std::mem::transmute(_mm_movemask_epi8(a.0) & 0x3)`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`@@ -105,8 +105,8 @@ impl Vector for __m32i {`
`105`	`105`
`106`	`106`	`#[inline]`
`107`	`107`	`#[target_feature(enable = "avx2")]`
`108`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
`109`		`- _mm_movemask_epi8(a.0) & 0xF`
	`108`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
	`109`	`+ std::mem::transmute(_mm_movemask_epi8(a.0) & 0xF)`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`@@ -152,8 +152,8 @@ impl Vector for __m64i {`
`152`	`152`
`153`	`153`	`#[inline]`
`154`	`154`	`#[target_feature(enable = "avx2")]`
`155`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
`156`		`- _mm_movemask_epi8(a.0) & 0xFF`
	`155`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
	`156`	`+ std::mem::transmute(_mm_movemask_epi8(a.0) & 0xFF)`
`157`	`157`	`}`
`158`	`158`	`}`
`159`	`159`
`@@ -194,8 +194,8 @@ impl Vector for __m128i {`
`194`	`194`
`195`	`195`	`#[inline]`
`196`	`196`	`#[target_feature(enable = "avx2")]`
`197`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
`198`		`- _mm_movemask_epi8(a)`
	`197`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
	`198`	`+ std::mem::transmute(_mm_movemask_epi8(a))`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`
`@@ -229,8 +229,8 @@ impl Vector for __m256i {`
`229`	`229`
`230`	`230`	`#[inline]`
`231`	`231`	`#[target_feature(enable = "avx2")]`
`232`		`- unsafe fn to_bitmask(a: Self) -> i32 {`
`233`		`- _mm256_movemask_epi8(a)`
	`232`	`+ unsafe fn to_bitmask(a: Self) -> u32 {`
	`233`	`+ std::mem::transmute(_mm256_movemask_epi8(a))`
`234`	`234`	`}`
`235`	`235`	`}`
`236`	`236`