Support 32-bit x86 with SSE4.2 as well

Author: shepmaster

build.rs

@@ -4,11 +4,28 @@ use std::io::prelude::*;
 use std::path::{Path, PathBuf};
 
 fn main() {
+    cfg();
     macros();
     simd_macros();
     println!("cargo:rerun-if-changed=build.rs");
 }
 
+fn cfg() {
+    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
+    let target_feature = env::var("CARGO_CFG_TARGET_FEATURE").unwrap_or_default();
+
+    let ok_arch = matches!(&*target_arch, "x86" | "x86_64");
+    let sse4_2_guaranteed = target_feature.split(',').any(|f| f == "sse4.2");
+
+    if sse4_2_guaranteed {
+        println!(r#"cargo:rustc-cfg=jetscii_sse4_2="yes""#);
+    } else if ok_arch {
+        println!(r#"cargo:rustc-cfg=jetscii_sse4_2="maybe""#);
+    } else {
+        println!(r#"cargo:rustc-cfg=jetscii_sse4_2="no""#);
+    }
+}
+
 fn macros() {
     let mut base: PathBuf = env::var_os("OUT_DIR").unwrap().into();
     base.push("src");

src/lib.rs

@@ -85,7 +85,7 @@
 //!
 //! ## What's so special about this library?
 //!
-//! We use a particular set of x86-64 SSE 4.2 instructions (`PCMPESTRI`
+//! We use a particular set of SSE 4.2 instructions (`PCMPESTRI`
 //! and `PCMPESTRM`) to gain great speedups. This method stays fast even
 //! when searching for a byte in a set of up to 16 choices.
 //!
@@ -155,10 +155,10 @@ use std::marker::PhantomData;
 
 include!(concat!(env!("OUT_DIR"), "/src/macros.rs"));
 
-#[cfg(target_arch = "x86_64")]
+#[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
 mod simd;
 
-#[cfg(not(target_feature = "sse4.2"))]
+#[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
 mod fallback;
 
 #[cfg(feature = "pattern")]
@@ -168,21 +168,21 @@ macro_rules! dispatch {
     (simd: $simd:expr,fallback: $fallback:expr,) => {
         // If we can tell at compile time that we have support,
         // call the optimized code directly.
-        #[cfg(target_feature = "sse4.2")]
+        #[cfg(jetscii_sse4_2 = "yes")]
         {
             $simd
         }
 
         // If we can tell at compile time that we will *never* have
         // support, call the fallback directly.
-        #[cfg(not(target_arch = "x86_64"))]
+        #[cfg(jetscii_sse4_2 = "no")]
         {
             $fallback
         }
 
         // Otherwise, we will be run on a machine with or without
         // support, so we perform runtime detection.
-        #[cfg(all(target_arch = "x86_64", not(target_feature = "sse4.2")))]
+        #[cfg(jetscii_sse4_2 = "maybe")]
         {
             if is_x86_feature_detected!("sse4.2") {
                 $simd
@@ -198,14 +198,10 @@ pub struct Bytes<F>
 where
     F: Fn(u8) -> bool,
 {
-    // Include this implementation only when compiling for x86_64 as
-    // that's the only platform that we support.
-    #[cfg(target_arch = "x86_64")]
+    #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
     simd: simd::Bytes,
 
-    // If we are *guaranteed* to have SSE 4.2, then there's no reason
-    // to have this implementation.
-    #[cfg(not(target_feature = "sse4.2"))]
+    #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
     fallback: fallback::Bytes<F>,
 
     // Since we might not use the fallback implementation, we add this
@@ -226,10 +222,10 @@ where
     #[allow(unused_variables)]
     pub /* const */ fn new(bytes: [u8; 16], len: i32, fallback: F) -> Self {
         Bytes {
-            #[cfg(target_arch = "x86_64")]
+            #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
             simd: simd::Bytes::new(bytes, len),
 
-            #[cfg(not(target_feature = "sse4.2"))]
+            #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
             fallback: fallback::Bytes::new(fallback),
 
             _fallback: PhantomData,
@@ -288,24 +284,20 @@ pub type AsciiCharsConst = AsciiChars<fn(u8) -> bool>;
 
 /// Searches a slice for the first occurence of the subslice.
 pub struct ByteSubstring<'a> {
-    // Include this implementation only when compiling for x86_64 as
-    // that's the only platform that we support.
-    #[cfg(target_arch = "x86_64")]
+    #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
     simd: simd::ByteSubstring<'a>,
 
-    // If we are *guaranteed* to have SSE 4.2, then there's no reason
-    // to have this implementation.
-    #[cfg(not(target_feature = "sse4.2"))]
+    #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
     fallback: fallback::ByteSubstring<'a>,
 }
 
 impl<'a> ByteSubstring<'a> {
     pub /* const */ fn new(needle: &'a [u8]) -> Self {
         ByteSubstring {
-            #[cfg(target_arch = "x86_64")]
+            #[cfg(any(jetscii_sse4_2 = "yes", jetscii_sse4_2 = "maybe"))]
             simd: simd::ByteSubstring::new(needle),
 
-            #[cfg(not(target_feature = "sse4.2"))]
+            #[cfg(any(jetscii_sse4_2 = "maybe", jetscii_sse4_2 = "no"))]
             fallback: fallback::ByteSubstring::new(needle),
         }
     }

src/simd.rs

@@ -2,12 +2,16 @@
 //
 // Everything in this module assumes that the SSE 4.2 feature is available.
 
-use std::{
-    arch::x86_64::{
-        __m128i, _mm_cmpestri, _mm_cmpestrm, _mm_extract_epi16, _mm_loadu_si128, _SIDD_CMP_EQUAL_ORDERED,
-    },
-    cmp::min,
-    slice,
+use std::{cmp::min, slice};
+
+#[cfg(target_arch = "x86")]
+use std::arch::x86 as target_arch;
+#[cfg(target_arch = "x86_64")]
+use std::arch::x86_64 as target_arch;
+
+use self::target_arch::{
+    __m128i, _mm_cmpestri, _mm_cmpestrm, _mm_extract_epi16, _mm_loadu_si128,
+    _SIDD_CMP_EQUAL_ORDERED,
 };
 
 include!(concat!(env!("OUT_DIR"), "/src/simd_macros.rs"));
@@ -298,8 +302,6 @@ impl<'a, 'b> PackedCompareControl for &'b ByteSubstring<'a> {
     }
 }
 
-// TODO: Does x86 actually support this instruction?
-
 #[cfg(test)]
 mod test {
     use proptest::prelude::*;