crc-fast-rust: fixing the dead_code issue with no_std builds (CI); dropped wasm64 in CI because it's just not readily available yet. sad day for WASM, honestly.

Author: loadingalias

.github/workflows/tests.yml

@@ -204,9 +204,7 @@ jobs:
           # WASI preview 2 (32-bit) - nightly only (experimental)
           - target: wasm32-wasip2
             rust-toolchain: "nightly"
-          # WASM 3.0 (64-bit address space) - nightly only (experimental)
-          - target: wasm64-unknown-unknown
-            rust-toolchain: "nightly"
+          # Note: wasm64-unknown-unknown removed - not consistently available in nightly
     steps:
       - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust
       - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0

src/cache.rs

@@ -48,6 +48,7 @@ static CACHE: Once<RwLock<HashMap<CrcParamsCacheKey, [u64; 23]>>> = Once::new();
 ///
 /// The cache key implements `Hash`, `Eq`, and `PartialEq` to enable efficient
 /// HashMap storage and lookup operations.
+#[cfg(any(feature = "std", feature = "cache"))]
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct CrcParamsCacheKey {
     /// CRC width in bits (32 or 64)
@@ -58,6 +59,7 @@ pub(crate) struct CrcParamsCacheKey {
     pub reflected: bool,
 }
 
+#[cfg(any(feature = "std", feature = "cache"))]
 impl CrcParamsCacheKey {
     /// Create a new cache key from CRC parameters
     ///

src/feature_detection.rs

@@ -3,22 +3,41 @@
 //! Feature detection system for safe and efficient hardware acceleration across different
 //! platforms.
 
-#[cfg(not(feature = "std"))]
+#[cfg(all(
+    not(feature = "std"),
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
 use spin::Once;
-#[cfg(feature = "std")]
+#[cfg(all(
+    feature = "std",
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
 use std::sync::OnceLock;
 
 #[cfg(all(feature = "alloc", not(feature = "std")))]
 extern crate alloc;
-#[cfg(all(feature = "alloc", not(feature = "std")))]
+#[cfg(all(
+    feature = "alloc",
+    not(feature = "std"),
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
 use alloc::string::{String, ToString};
-#[cfg(feature = "std")]
+#[cfg(all(
+    feature = "std",
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
 use std::string::{String, ToString};
 
 /// Global ArchOps instance cache - initialized once based on feature detection results
-#[cfg(feature = "std")]
+#[cfg(all(
+    feature = "std",
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
 static ARCH_OPS_INSTANCE: OnceLock<ArchOpsInstance> = OnceLock::new();
-#[cfg(not(feature = "std"))]
+#[cfg(all(
+    not(feature = "std"),
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
 static ARCH_OPS_INSTANCE: Once<ArchOpsInstance> = Once::new();
 
 /// Performance tiers representing different hardware capability levels
@@ -61,7 +80,10 @@ pub struct ArchCapabilities {
 
 /// Helper function to convert a performance tier to a human-readable target string
 /// Format: {architecture}-{intrinsics-family}-{intrinsics-features}
-#[cfg(feature = "alloc")]
+#[cfg(all(
+    feature = "alloc",
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
 #[inline(always)]
 fn tier_to_target_string(tier: PerformanceTier) -> String {
     match tier {
@@ -79,6 +101,7 @@ fn tier_to_target_string(tier: PerformanceTier) -> String {
 ///
 /// # Safety
 /// Uses runtime feature detection which may access CPU-specific registers
+#[cfg(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"))]
 unsafe fn detect_arch_capabilities() -> ArchCapabilities {
     #[cfg(target_arch = "aarch64")]
     {
@@ -258,6 +281,7 @@ pub(crate) fn select_performance_tier(capabilities: &ArchCapabilities) -> Perfor
 
 /// Enum that holds the different ArchOps implementations for compile-time dispatch
 /// This avoids the need for trait objects while still providing factory-based selection
+#[cfg(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"))]
 #[rustversion::since(1.89)]
 #[derive(Debug, Clone, Copy)]
 pub enum ArchOpsInstance {
@@ -275,6 +299,7 @@ pub enum ArchOpsInstance {
     SoftwareFallback,
 }
 
+#[cfg(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"))]
 #[rustversion::before(1.89)]
 #[derive(Debug, Clone, Copy)]
 pub enum ArchOpsInstance {
@@ -288,6 +313,7 @@ pub enum ArchOpsInstance {
     SoftwareFallback,
 }
 
+#[cfg(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"))]
 impl ArchOpsInstance {
     #[inline(always)]
     #[rustversion::since(1.89)]
@@ -334,12 +360,18 @@ impl ArchOpsInstance {
 /// This function provides access to the cached ArchOps instance that was selected based on
 /// feature detection results at library initialization time, eliminating runtime feature
 /// detection overhead from hot paths.
-#[cfg(feature = "std")]
+#[cfg(all(
+    feature = "std",
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
 pub fn get_arch_ops() -> &'static ArchOpsInstance {
     ARCH_OPS_INSTANCE.get_or_init(create_arch_ops)
 }
 
-#[cfg(not(feature = "std"))]
+#[cfg(all(
+    not(feature = "std"),
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
 pub fn get_arch_ops() -> &'static ArchOpsInstance {
     ARCH_OPS_INSTANCE.call_once(create_arch_ops)
 }
@@ -349,6 +381,7 @@ pub fn get_arch_ops() -> &'static ArchOpsInstance {
 /// This function uses the cached feature detection results to select the optimal
 /// architecture-specific implementation at library initialization time, eliminating
 /// runtime feature detection overhead from hot paths.
+#[cfg(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"))]
 fn create_arch_ops() -> ArchOpsInstance {
     let capabilities = unsafe { detect_arch_capabilities() };
     let tier = select_performance_tier(&capabilities);
@@ -358,6 +391,7 @@ fn create_arch_ops() -> ArchOpsInstance {
 
 /// Helper function to create ArchOpsInstance from a performance tier for Rust 1.89+ (when AVX512
 /// stabilized)
+#[cfg(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"))]
 #[rustversion::since(1.89)]
 fn create_arch_ops_from_tier(tier: PerformanceTier) -> ArchOpsInstance {
     match tier {
@@ -400,6 +434,7 @@ fn create_arch_ops_from_tier(tier: PerformanceTier) -> ArchOpsInstance {
 
 /// Helper function to create ArchOpsInstance from a performance tier for Rust <1.89 (before AVX512
 /// stabilized)
+#[cfg(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"))]
 #[rustversion::before(1.89)]
 fn create_arch_ops_from_tier(tier: PerformanceTier) -> ArchOpsInstance {
     match tier {

src/lib.rs

@@ -860,14 +860,28 @@ pub fn checksum_combine_with_params(
 /// // "x86_64-avx512-vpclmulqdq" - x86_64 with VPCLMULQDQ support
 /// // "x86_64-sse-pclmulqdq" - x86_64 baseline with SSE4.1 and PCLMULQDQ
 /// ```
-#[cfg(feature = "alloc")]
+#[cfg(all(
+    feature = "alloc",
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
 pub fn get_calculator_target(_algorithm: CrcAlgorithm) -> String {
     use crate::feature_detection::get_arch_ops;
 
     let arch_ops = get_arch_ops();
     arch_ops.get_target_string()
 }
 
+/// Fallback version of get_calculator_target for unsupported architectures
+#[cfg(all(
+    feature = "alloc",
+    not(any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64"))
+))]
+pub fn get_calculator_target(_algorithm: CrcAlgorithm) -> String {
+    extern crate alloc;
+    use alloc::string::ToString;
+    "software-fallback-tables".to_string()
+}
+
 /// Returns the calculator function and parameters for the specified CRC algorithm.
 #[inline(always)]
 fn get_calculator_params(algorithm: CrcAlgorithm) -> (CalculatorFn, CrcParams) {