Add conditional compilation attributes

Author: onethumb

src/crc32/fusion/aarch64.rs

@@ -63,6 +63,7 @@ pub fn crc32_iso_hdlc(crc: u32, data: &[u8]) -> u32 {
 }
 
 #[inline]
+#[cfg(target_feature = "sha3")]
 #[target_feature(enable = "neon,aes")]
 unsafe fn clmul_lo_eor3(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
     // Polynomial multiply low parts - convert u128 result to uint64x2_t
@@ -71,6 +72,7 @@ unsafe fn clmul_lo_eor3(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
 }
 
 #[inline]
+#[cfg(target_feature = "sha3")]
 #[target_feature(enable = "neon,aes")]
 unsafe fn clmul_hi_eor3(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
     // Polynomial multiply high parts - convert u128 result to uint64x2_t
@@ -79,6 +81,7 @@ unsafe fn clmul_hi_eor3(a: uint64x2_t, b: uint64x2_t) -> uint64x2_t {
 }
 
 #[inline]
+#[cfg(target_feature = "sha3")]
 #[target_feature(enable = "neon,aes")]
 unsafe fn clmul_scalar(a: u32, b: u32) -> uint64x2_t {
     // Polynomial multiply scalars - convert u128 result to uint64x2_t
@@ -88,6 +91,7 @@ unsafe fn clmul_scalar(a: u32, b: u32) -> uint64x2_t {
 
 // x^n mod P, in log(n) time
 #[inline]
+#[cfg(target_feature = "sha3")]
 #[target_feature(enable = "neon,aes")]
 fn xnmodp_crc32_iscsi(mut n: u64) -> u32 {
     let mut stack = !1u64;
@@ -125,13 +129,15 @@ fn xnmodp_crc32_iscsi(mut n: u64) -> u32 {
 }
 
 #[inline]
+#[cfg(target_feature = "sha3")]
 #[target_feature(enable = "neon,aes")]
 unsafe fn crc_shift_iscsi(crc: u32, nbytes: usize) -> uint64x2_t {
     clmul_scalar(crc, xnmodp_crc32_iscsi((nbytes * 8 - 33) as u64))
 }
 
 // x^n mod P, in log(n) time
 #[inline]
+#[cfg(target_feature = "sha3")]
 #[target_feature(enable = "neon,aes")]
 fn xnmodp_iso_hdlc(mut n: u64) -> u32 {
     let mut stack = !1u64;
@@ -169,6 +175,7 @@ fn xnmodp_iso_hdlc(mut n: u64) -> u32 {
 }
 
 #[inline]
+#[cfg(target_feature = "sha3")]
 #[target_feature(enable = "neon,aes")]
 unsafe fn crc_shift_iso_hdlc(crc: u32, nbytes: usize) -> uint64x2_t {
     clmul_scalar(crc, xnmodp_iso_hdlc((nbytes * 8 - 33) as u64))
@@ -179,6 +186,7 @@ unsafe fn crc_shift_iso_hdlc(crc: u32, nbytes: usize) -> uint64x2_t {
 ///
 /// ./generate -i neon_eor3 -p crc32c -a v9s3x2e_s3
 #[inline]
+#[cfg(target_feature = "sha3")]
 #[target_feature(enable = "neon,aes,sha3")]
 unsafe fn crc32_iscsi_eor3_v9s3x2e_s3(mut crc0: u32, mut buf: *const u8, mut len: usize) -> u32 {
     // Align to 8-byte boundary
@@ -555,6 +563,7 @@ unsafe fn crc32_iscsi_v12e_v1(mut crc0: u32, mut buf: *const u8, mut len: usize)
 ///
 /// ./generate -i neon_eor3 -p crc32 -a v9s3x2e_s3
 #[inline]
+#[cfg(target_feature = "sha3")]
 #[target_feature(enable = "neon,aes,sha3")]
 unsafe fn crc32_iso_hdlc_eor3_v9s3x2e_s3(mut crc0: u32, mut buf: *const u8, mut len: usize) -> u32 {
     // Align to 8-byte boundary
@@ -916,7 +925,6 @@ mod tests {
     use crate::test::consts::TEST_CHECK_STRING;
     use crc::{Crc, Table};
     use rand::{rng, Rng};
-    use std::arch::is_aarch64_feature_detected;
 
     const RUST_CRC32_ISO_HDLC: Crc<u32, Table<16>> =
         Crc::<u32, Table<16>>::new(&crc::CRC_32_ISO_HDLC);
@@ -985,6 +993,7 @@ mod tests {
         }
     }
 
+    #[cfg(target_feature = "sha3")]
     fn crc32_iso_hdlc_random(len: usize) {
         let mut data = vec![0u8; len];
         rng().fill(&mut data[..]);
@@ -994,13 +1003,11 @@ mod tests {
         assert_eq!(crc32_iso_hdlc(0xffffffff, &data) ^ 0xffffffff, checksum);
 
         unsafe {
-            if is_aarch64_feature_detected!("sha3") {
-                assert_eq!(
-                    crc32_iso_hdlc_eor3_v9s3x2e_s3(0xffffffff, data.as_ptr(), data.len())
-                        ^ 0xffffffff,
-                    checksum
-                );
-            }
+            assert_eq!(
+                crc32_iso_hdlc_eor3_v9s3x2e_s3(0xffffffff, data.as_ptr(), data.len())
+                    ^ 0xffffffff,
+                checksum
+            );
 
             assert_eq!(
                 crc32_iso_hdlc_v12e_v1(0xffffffff, data.as_ptr(), data.len()) ^ 0xffffffff,
@@ -1009,6 +1016,24 @@ mod tests {
         }
     }
 
+    #[cfg(not(target_feature = "sha3"))]
+    fn crc32_iso_hdlc_random(len: usize) {
+        let mut data = vec![0u8; len];
+        rng().fill(&mut data[..]);
+
+        let checksum = RUST_CRC32_ISO_HDLC.checksum(&data);
+
+        assert_eq!(crc32_iso_hdlc(0xffffffff, &data) ^ 0xffffffff, checksum);
+
+        unsafe {
+            assert_eq!(
+                crc32_iso_hdlc_v12e_v1(0xffffffff, data.as_ptr(), data.len()) ^ 0xffffffff,
+                checksum
+            );
+        }
+    }
+
+    #[cfg(target_feature = "sha3")]
     fn crc32_iscsi_random(len: usize) {
         let mut data = vec![0u8; len];
         rng().fill(&mut data[..]);
@@ -1018,13 +1043,28 @@ mod tests {
         assert_eq!(crc32_iscsi(0xffffffff, &data) ^ 0xffffffff, checksum);
 
         unsafe {
-            if is_aarch64_feature_detected!("sha3") {
-                assert_eq!(
-                    crc32_iscsi_eor3_v9s3x2e_s3(0xffffffff, data.as_ptr(), data.len()) ^ 0xffffffff,
-                    checksum
-                );
-            }
+            assert_eq!(
+                crc32_iscsi_eor3_v9s3x2e_s3(0xffffffff, data.as_ptr(), data.len()) ^ 0xffffffff,
+                checksum
+            );
+
+            assert_eq!(
+                crc32_iscsi_v12e_v1(0xffffffff, data.as_ptr(), data.len()) ^ 0xffffffff,
+                checksum
+            );
+        }
+    }
+
+    #[cfg(not(target_feature = "sha3"))]
+    fn crc32_iscsi_random(len: usize) {
+        let mut data = vec![0u8; len];
+        rng().fill(&mut data[..]);
+
+        let checksum = RUST_CRC32_ISCSI.checksum(&data);
 
+        assert_eq!(crc32_iscsi(0xffffffff, &data) ^ 0xffffffff, checksum);
+
+        unsafe {
             assert_eq!(
                 crc32_iscsi_v12e_v1(0xffffffff, data.as_ptr(), data.len()) ^ 0xffffffff,
                 checksum

src/crc32/fusion/mod.rs

@@ -17,8 +17,8 @@ pub(crate) fn crc32_iso_hdlc(state: u32, data: &[u8]) -> u32 {
     #[cfg(target_arch = "aarch64")]
     return aarch64::crc32_iso_hdlc(state, data);
 
-    #[cfg(target_arch = "x86_64")]
-    panic!("CRC-32/ISO-HDLC with fusion is not supported on x86_64");
+    #[cfg(not(target_arch = "aarch64"))]
+    panic!("CRC-32/ISO-HDLC with fusion is only supported on AArch64 architecture");
 }
 
 #[inline(always)]
@@ -28,4 +28,7 @@ pub(crate) fn crc32_iscsi(state: u32, data: &[u8]) -> u32 {
 
     #[cfg(target_arch = "x86_64")]
     return x86::crc32_iscsi(state, data);
+
+    #[cfg(all(not(target_arch = "aarch64"), not(target_arch = "x86_64")))]
+    panic!("CRC-32/ISCSI with fusion is only supported on AArch64 and X86_64 architectures");
 }

src/crc32/mod.rs

@@ -4,4 +4,6 @@
 
 pub mod algorithm;
 pub mod consts;
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
 pub(crate) mod fusion;

src/lib.rs

@@ -109,7 +109,10 @@ use crate::crc32::consts::{
     CRC32_AIXM, CRC32_AUTOSAR, CRC32_BASE91_D, CRC32_BZIP2, CRC32_CD_ROM_EDC, CRC32_CKSUM,
     CRC32_ISCSI, CRC32_ISO_HDLC, CRC32_JAMCRC, CRC32_MEF, CRC32_MPEG_2, CRC32_XFER,
 };
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64"))]
 use crate::crc32::fusion;
+
 use crate::crc64::consts::{
     CRC64_ECMA_182, CRC64_GO_ISO, CRC64_MS, CRC64_NVME, CRC64_REDIS, CRC64_WE, CRC64_XZ,
 };
@@ -480,7 +483,12 @@ fn get_calculator_params(algorithm: CrcAlgorithm) -> (CalculatorFn, CrcParams) {
 #[inline(always)]
 fn crc32_iscsi_calculator(state: u64, data: &[u8], _params: CrcParams) -> u64 {
     // both aarch64 and x86 have native CRC-32/ISCSI support, so we can use fusion
-    fusion::crc32_iscsi(state as u32, data) as u64
+    #[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
+    return fusion::crc32_iscsi(state as u32, data) as u64;
+
+    #[cfg(all(not(target_arch = "aarch64"), not(target_arch = "x86_64")))]
+    // fallback to traditional calculation if not aarch64 or x86_64
+    Calculator::calculate(state, data, _params)
 }
 
 /// Calculates the CRC-32/ISO-HDLC ("crc32" in many, but not all, implementations) checksum.