Merge pull request #52 from shepmaster/32bit-sse42

Author: shepmaster

.github/actions/test/action.yml

@@ -0,0 +1,52 @@
+name: Run tests
+
+inputs:
+  toolchain:
+    default: "stable"
+    required: false
+    type: string
+
+  features:
+    default: ""
+    required: false
+    type: string
+
+  rustflags:
+    default: ""
+    required: false
+    type: string
+
+  target:
+    default: ""
+    required: false
+    type: string
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: ${{ inputs.toolchain }}
+        profile: minimal
+        default: true
+
+    - name: Configure cross
+      shell: bash
+      run: |
+        cat > Cross.toml <<EOF
+        [build.env]
+        passthrough = ["RUSTFLAGS", "RUSTDOCFLAGS"]
+        EOF
+
+    - name: Run tests
+      uses: actions-rs/cargo@v1
+      env:
+        RUSTFLAGS: "${{ env.RUSTFLAGS }} ${{ inputs.rustflags }}"
+      with:
+        command: test
+        args: >-
+          --all
+          ${{ inputs.features != '' && format('--features {0}', inputs.features) || '' }}
+          ${{ inputs.target != '' && format('--target {0}', inputs.target) || '' }}
+        use-cross: ${{ inputs.target != '' }}

.github/workflows/ci.yml

@@ -6,39 +6,65 @@ env:
   RUSTDOCFLAGS: -D warnings
 
 jobs:
-  primary:
+  toolchains:
     strategy:
       matrix:
-        os: [ubuntu-latest]
-        toolchain: [stable, beta, nightly]
-        features: ['']
+        toolchain: ["stable", "beta", "nightly"]
 
-        include:
-          - os: ubuntu-latest
-            toolchain: nightly
-            features: pattern
+    runs-on: ubuntu-latest
 
-          - os: windows-latest
-            toolchain: stable
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
+
+      - name: Run tests
+        uses: ./.github/actions/test
+        with:
+          toolchain: "${{ matrix.toolchain }}"
+
+  platforms:
+    strategy:
+      matrix:
+        platform: ["windows-latest", "macos-latest"]
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
 
-          - os: macos-latest
-            toolchain: stable
+      - name: Run tests
+        uses: ./.github/actions/test
+        with:
+          platform: "${{ matrix.platform }}"
 
-    runs-on: ${{ matrix.os }}
+  crate_features:
+    runs-on: ubuntu-latest
 
     steps:
       - name: Check out code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
+      - name: Run tests
+        uses: ./.github/actions/test
         with:
-          toolchain: ${{ matrix.toolchain }}
-          profile: minimal
-          default: true
+          toolchain: "nightly"
+          features: "pattern"
+
+  target_features:
+    strategy:
+      matrix:
+        target_feature: ["-sse4.2", "+sse4.2"]
+        target: ["", "i686-unknown-linux-gnu"]
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
 
       - name: Run tests
-        uses: actions-rs/cargo@v1
+        uses: ./.github/actions/test
         with:
-          command: test
-          args: --all --features=${{ matrix.features }}
+          rustflags: "-C target-feature=${{ matrix.target_feature }}"
+          target: "${{ matrix.target }}"

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::*;