Add table-based software fallback

onethumb · onethumb · commit 9432876eb47e · 2025-05-06T15:04:19.000-07:00
For unsupported architectures, there’s now a software fallback using
relatively fast table lookups via the ‘crc’ crate.
diff --git a/src/algorithm.rs b/src/algorithm.rs
@@ -13,6 +13,8 @@
 //! The main entry point is the `update` function, which takes the current CRC state,
 //! the input data, CRC parameters, and architecture-specific operations.
 
+#![cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
+
 use crate::consts::CRC_CHUNK_SIZE;
 use crate::enums::{DataChunkProcessor, Reflector};
 use crate::structs::{CrcParams, CrcState};
diff --git a/src/arch/mod.rs b/src/arch/mod.rs
@@ -5,8 +5,13 @@
 //! It dispatches to the appropriate architecture-specific implementation
 //! based on the target architecture.
 
+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
 use crate::algorithm;
-use crate::structs::{CrcParams, Width32, Width64};
+
+use crate::structs::CrcParams;
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
+use crate::structs::{Width32, Width64};
 
 #[cfg(target_arch = "aarch64")]
 use crate::arch::aarch64::AArch64Ops;
@@ -18,6 +23,7 @@ use crate::arch::x86::X86Ops;
 use crate::arch::vpclmulqdq::VpclmulqdqOps;
 
 pub(crate) mod aarch64;
+mod software;
 mod vpclmulqdq;
 pub(crate) mod x86;
 
@@ -70,10 +76,8 @@ pub(crate) unsafe fn update(state: u64, bytes: &[u8], params: CrcParams) -> u64
         }
     }
 
-    #[cfg(not(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")))]
-    {
-        compile_error!("Unsupported architecture for SIMD CRC calculation");
-    }
+    #[cfg(not(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64")))]
+    return software::update(state, bytes, params);
 }
 
 pub fn get_target() -> String {
@@ -88,7 +92,7 @@ pub fn get_target() -> String {
     return "internal-x86-sse-pclmulqdq".to_string();
 
     #[cfg(not(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")))]
-    compile_error!("Unsupported architecture for SIMD CRC calculation");
+    return "software-fallback".to_string();
 }
 
 #[cfg(test)]
diff --git a/src/arch/software.rs b/src/arch/software.rs
@@ -0,0 +1,140 @@
+// Copyright 2025 Don MacAskill. Licensed under MIT or Apache-2.0.
+
+//! This module contains a software fallback for unsupported architectures.
+
+#![cfg(not(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64")))]
+
+use crate::consts::CRC_64_NVME;
+use crate::structs::CrcParams;
+use crate::CrcAlgorithm;
+use crc::Table;
+
+const RUST_CRC32_AIXM: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_AIXM);
+
+const RUST_CRC32_AUTOSAR: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_AUTOSAR);
+
+const RUST_CRC32_BASE91_D: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_BASE91_D);
+
+const RUST_CRC32_BZIP2: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_BZIP2);
+
+const RUST_CRC32_CD_ROM_EDC: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_CD_ROM_EDC);
+
+const RUST_CRC32_CKSUM: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_CKSUM);
+
+const RUST_CRC32_ISCSI: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_ISCSI);
+
+const RUST_CRC32_ISO_HDLC: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_ISO_HDLC);
+
+const RUST_CRC32_JAMCRC: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_JAMCRC);
+
+const RUST_CRC32_MEF: crc::Crc<u32, Table<16>> = crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_MEF);
+
+const RUST_CRC32_MPEG_2: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_MPEG_2);
+
+const RUST_CRC32_XFER: crc::Crc<u32, Table<16>> =
+    crc::Crc::<u32, Table<16>>::new(&crc::CRC_32_XFER);
+
+const RUST_CRC64_ECMA_182: crc::Crc<u64, Table<16>> =
+    crc::Crc::<u64, Table<16>>::new(&crc::CRC_64_ECMA_182);
+
+const RUST_CRC64_GO_ISO: crc::Crc<u64, Table<16>> =
+    crc::Crc::<u64, Table<16>>::new(&crc::CRC_64_GO_ISO);
+
+const RUST_CRC64_MS: crc::Crc<u64, Table<16>> = crc::Crc::<u64, Table<16>>::new(&crc::CRC_64_MS);
+
+const RUST_CRC64_NVME: crc::Crc<u64, Table<16>> = crc::Crc::<u64, Table<16>>::new(&CRC_64_NVME);
+
+const RUST_CRC64_REDIS: crc::Crc<u64, Table<16>> =
+    crc::Crc::<u64, Table<16>>::new(&crc::CRC_64_REDIS);
+
+const RUST_CRC64_WE: crc::Crc<u64, Table<16>> = crc::Crc::<u64, Table<16>>::new(&crc::CRC_64_WE);
+
+const RUST_CRC64_XZ: crc::Crc<u64, Table<16>> = crc::Crc::<u64, Table<16>>::new(&crc::CRC_64_XZ);
+
+// Dispatch function that handles the generic case
+pub(crate) fn update(state: u64, data: &[u8], params: CrcParams) -> u64 {
+    match params.width {
+        32 => {
+            let params = match params.algorithm {
+                CrcAlgorithm::Crc32Aixm => RUST_CRC32_AIXM,
+                CrcAlgorithm::Crc32Autosar => RUST_CRC32_AUTOSAR,
+                CrcAlgorithm::Crc32Base91D => RUST_CRC32_BASE91_D,
+                CrcAlgorithm::Crc32Bzip2 => RUST_CRC32_BZIP2,
+                CrcAlgorithm::Crc32CdRomEdc => RUST_CRC32_CD_ROM_EDC,
+                CrcAlgorithm::Crc32Cksum => RUST_CRC32_CKSUM,
+                CrcAlgorithm::Crc32Iscsi => RUST_CRC32_ISCSI,
+                CrcAlgorithm::Crc32IsoHdlc => RUST_CRC32_ISO_HDLC,
+                CrcAlgorithm::Crc32Jamcrc => RUST_CRC32_JAMCRC,
+                CrcAlgorithm::Crc32Mef => RUST_CRC32_MEF,
+                CrcAlgorithm::Crc32Mpeg2 => RUST_CRC32_MPEG_2,
+                CrcAlgorithm::Crc32Xfer => RUST_CRC32_XFER,
+                _ => panic!("Invalid algorithm for u32 CRC"),
+            };
+            update_u32(state as u32, data, params) as u64
+        }
+        64 => {
+            let params = match params.algorithm {
+                CrcAlgorithm::Crc64Ecma182 => RUST_CRC64_ECMA_182,
+                CrcAlgorithm::Crc64GoIso => RUST_CRC64_GO_ISO,
+                CrcAlgorithm::Crc64Ms => RUST_CRC64_MS,
+                CrcAlgorithm::Crc64Nvme => RUST_CRC64_NVME,
+                CrcAlgorithm::Crc64Redis => RUST_CRC64_REDIS,
+                CrcAlgorithm::Crc64We => RUST_CRC64_WE,
+                CrcAlgorithm::Crc64Xz => RUST_CRC64_XZ,
+                _ => panic!("Invalid algorithm for u64 CRC"),
+            };
+            update_u64(state, data, params)
+        }
+        _ => panic!("Unsupported CRC width: {}", params.width),
+    }
+}
+
+// Specific implementation for u32
+fn update_u32(state: u32, data: &[u8], params: crc::Crc<u32, Table<16>>) -> u32 {
+    // apply REFIN if necessary
+    let initial = if params.algorithm.refin {
+        state.reverse_bits()
+    } else {
+        state
+    };
+
+    let mut digest = params.digest_with_initial(initial);
+    digest.update(data);
+
+    let checksum = digest.finalize();
+
+    println!(
+        "finalized checksum  {:#16x}, xor'd {:#16x}",
+        checksum,
+        checksum ^ params.algorithm.xorout
+    );
+
+    // remove XOR since this will be applied in the library Digest::finalize() step instead
+    checksum ^ params.algorithm.xorout
+}
+
+// Specific implementation for u64
+fn update_u64(state: u64, data: &[u8], params: crc::Crc<u64, Table<16>>) -> u64 {
+    // apply REFIN if necessary
+    let initial = if params.algorithm.refin {
+        state.reverse_bits()
+    } else {
+        state
+    };
+
+    let mut digest = params.digest_with_initial(initial);
+    digest.update(data);
+
+    // remove XOR since this will be applied in the library Digest::finalize() step instead
+    digest.finalize() ^ params.algorithm.xorout
+}
diff --git a/src/consts.rs b/src/consts.rs
@@ -90,3 +90,43 @@ pub(crate) const CRC64_EXPONENTS: [u64; 21] = [
     64 * 4,
     64 * 5,
 ];
+
+// for software fallbacks and testing
+pub(crate) const RUST_CRC32_AIXM: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_AIXM);
+
+pub(crate) const RUST_CRC32_AUTOSAR: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_AUTOSAR);
+
+pub(crate) const RUST_CRC32_BASE91_D: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_BASE91_D);
+
+pub(crate) const RUST_CRC32_BZIP2: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_BZIP2);
+
+pub(crate) const RUST_CRC32_CD_ROM_EDC: crc::Crc<u32> =
+    crc::Crc::<u32>::new(&crc::CRC_32_CD_ROM_EDC);
+
+pub(crate) const RUST_CRC32_CKSUM: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_CKSUM);
+
+pub(crate) const RUST_CRC32_ISCSI: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_ISCSI);
+
+pub(crate) const RUST_CRC32_ISO_HDLC: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_ISO_HDLC);
+
+pub(crate) const RUST_CRC32_JAMCRC: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_JAMCRC);
+
+pub(crate) const RUST_CRC32_MEF: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_MEF);
+
+pub(crate) const RUST_CRC32_MPEG_2: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_MPEG_2);
+
+pub(crate) const RUST_CRC32_XFER: crc::Crc<u32> = crc::Crc::<u32>::new(&crc::CRC_32_XFER);
+
+pub(crate) const RUST_CRC64_ECMA_182: crc::Crc<u64> = crc::Crc::<u64>::new(&crc::CRC_64_ECMA_182);
+
+pub(crate) const RUST_CRC64_GO_ISO: crc::Crc<u64> = crc::Crc::<u64>::new(&crc::CRC_64_GO_ISO);
+
+pub(crate) const RUST_CRC64_MS: crc::Crc<u64> = crc::Crc::<u64>::new(&crc::CRC_64_MS);
+
+pub(crate) const RUST_CRC64_NVME: crc::Crc<u64> = crc::Crc::<u64>::new(&CRC_64_NVME);
+
+pub(crate) const RUST_CRC64_REDIS: crc::Crc<u64> = crc::Crc::<u64>::new(&crc::CRC_64_REDIS);
+
+pub(crate) const RUST_CRC64_WE: crc::Crc<u64> = crc::Crc::<u64>::new(&crc::CRC_64_WE);
+
+pub(crate) const RUST_CRC64_XZ: crc::Crc<u64> = crc::Crc::<u64>::new(&crc::CRC_64_XZ);
diff --git a/src/crc32/algorithm.rs b/src/crc32/algorithm.rs
@@ -3,6 +3,8 @@
 //! This module provides the CRC-32 algorithm implementations for areas where it differs from
 //! CRC-64.
 
+#![cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
+
 use crate::algorithm;
 use crate::consts::CRC_CHUNK_SIZE;
 use crate::crc32::consts::{PSHUFB_SHF_TABLE_FORWARD, PSHUFB_SHF_TABLE_REVERSE, SIMD_CONSTANTS};
diff --git a/src/crc64/algorithm.rs b/src/crc64/algorithm.rs
@@ -2,6 +2,8 @@
 
 //! This module provides the CRC-64 implementation for areas where it differs from CRC-32.
 
+#![cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
+
 use crate::algorithm;
 use crate::consts::{CRC_CHUNK_SIZE, CRC_HALF_CHUNK_SIZE};
 use crate::crc64::consts::SIMD_CONSTANTS;
diff --git a/src/crc64/utils.rs b/src/crc64/utils.rs
@@ -1,12 +1,15 @@
 // Copyright 2025 Don MacAskill. Licensed under MIT or Apache-2.0.
 
+#![cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
+
 #[cfg(target_arch = "aarch64")]
 use std::arch::aarch64::*;
 
 #[cfg(target_arch = "x86")]
 use std::arch::x86::*;
 
 use crate::traits::ArchOps;
+
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
diff --git a/src/enums.rs b/src/enums.rs
@@ -60,12 +60,14 @@ impl Display for CrcAlgorithm {
     }
 }
 
+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
 #[derive(Debug, Copy, Clone)]
 pub(crate) enum Reflector<T> {
     NoReflector,
     ForwardReflector { smask: T },
 }
 
+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
 /// Different processing strategies based on data length
 pub(crate) enum DataChunkProcessor {
     From0To15,   // 0-15 bytes
@@ -74,6 +76,7 @@ pub(crate) enum DataChunkProcessor {
     From32To255, // 32-255 bytes
 }
 
+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
 impl DataChunkProcessor {
     /// Select the appropriate processor based on data length
     pub fn for_length(len: usize) -> Self {
diff --git a/src/lib.rs b/src/lib.rs
@@ -859,12 +859,14 @@ mod lib {
 
     /// Tests whether the CRC-32/ISO-HDLC bindings are up-to-date
     #[test]
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
     fn test_crc32_iso_hdlc_bindings() -> Result<(), String> {
         build_bindgen("crc32_iso_hdlc", "src/bindings/crc32_iso_hdlc.rs")
     }
 
     /// Tests whether the CRC-32/ISCSI bindings are up-to-date
     #[test]
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
     fn test_crc32_iscsi_bindings() -> Result<(), String> {
         build_bindgen("crc32_iscsi", "src/bindings/crc32_iscsi.rs")
     }
diff --git a/src/test/consts.rs b/src/test/consts.rs
diff --git a/src/test/enums.rs b/src/test/enums.rs
diff --git a/src/test/structs.rs b/src/test/structs.rs
diff --git a/src/traits.rs b/src/traits.rs

Original file line number	Diff line number	Diff line change
`@@ -60,12 +60,14 @@ impl Display for CrcAlgorithm {`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`
	`63`	`+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]`
`63`	`64`	`#[derive(Debug, Copy, Clone)]`
`64`	`65`	`pub(crate) enum Reflector<T> {`
`65`	`66`	`NoReflector,`
`66`	`67`	`ForwardReflector { smask: T },`
`67`	`68`	`}`
`68`	`69`
	`70`	`+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]`
`69`	`71`	`/// Different processing strategies based on data length`
`70`	`72`	`pub(crate) enum DataChunkProcessor {`
`71`	`73`	`From0To15, // 0-15 bytes`
`@@ -74,6 +76,7 @@ pub(crate) enum DataChunkProcessor {`
`74`	`76`	`From32To255, // 32-255 bytes`
`75`	`77`	`}`
`76`	`78`
	`79`	`+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]`
`77`	`80`	`impl DataChunkProcessor {`
`78`	`81`	`/// Select the appropriate processor based on data length`
`79`	`82`	`pub fn for_length(len: usize) -> Self {`
Original file line number	Diff line number	Diff line change
`@@ -859,12 +859,14 @@ mod lib {`
`859`	`859`
`860`	`860`	`/// Tests whether the CRC-32/ISO-HDLC bindings are up-to-date`
`861`	`861`	`#[test]`
	`862`	`+ #[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]`
`862`	`863`	`fn test_crc32_iso_hdlc_bindings() -> Result<(), String> {`
`863`	`864`	`build_bindgen("crc32_iso_hdlc", "src/bindings/crc32_iso_hdlc.rs")`
`864`	`865`	`}`
`865`	`866`
`866`	`867`	`/// Tests whether the CRC-32/ISCSI bindings are up-to-date`
`867`	`868`	`#[test]`
	`869`	`+ #[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]`
`868`	`870`	`fn test_crc32_iscsi_bindings() -> Result<(), String> {`
`869`	`871`	`build_bindgen("crc32_iscsi", "src/bindings/crc32_iscsi.rs")`
`870`	`872`	`}`