Remove nightly ARM flag. (Requires version bump)

Signed-off-by: Tom Kaitchuck <Tom.Kaitchuck@gmail.com>

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ahash"
-version = "0.8.8"
+version = "0.9.0"
 authors = ["Tom Kaitchuck <Tom.Kaitchuck@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "A non-cryptographic hash function using AES-NI for high performance"
@@ -12,7 +12,7 @@ edition = "2018"
 readme = "README.md"
 build = "./build.rs"
 exclude = ["/smhasher", "/benchmark_tools"]
-rust-version = "1.60.0"
+rust-version = "1.72.0"
 
 [lib]
 name = "ahash"
@@ -44,9 +44,6 @@ no-rng = []
 # in case this is being used on an architecture lacking core::sync::atomic::AtomicUsize and friends
 atomic-polyfill = [ "dep:atomic-polyfill", "once_cell/atomic-polyfill"]
 
-# Nightly-only support for AES intrinsics on 32-bit ARM
-nightly-arm-aes = []
-
 [[bench]]
 name = "ahash"
 path = "tests/bench.rs"

README.md

@@ -57,7 +57,6 @@ The aHash package has the following flags:
 This is done using the [getrandom](https://github.com/rust-random/getrandom) crate.
 * `compile-time-rng`: For OS targets without access to a random number generator, `compile-time-rng` provides an alternative.
 If `getrandom` is unavailable and `compile-time-rng` is enabled, aHash will generate random numbers at compile time and embed them in the binary.
-* `nightly-arm-aes`: To use AES instructions on 32-bit ARM, which requires nightly. This is not needed on AArch64.
 This allows for DOS resistance even if there is no random number generator available at runtime (assuming the compiled binary is not public).
 This makes the binary non-deterministic. (If non-determinism is a problem see [constrandom's documentation](https://github.com/tkaitchuck/constrandom#deterministic-builds))
 

src/aes_hash.rs

@@ -206,10 +206,24 @@ impl Hasher for AHasher {
             }
         }
     }
+
     #[inline]
-    fn finish(&self) -> u64 {
+    #[cfg(any(target_arch = "aarch64", target_arch = "arm"))]
+    fn final_mix(&self) -> u128 {
+        let sum = aesenc(self.sum, self.key);
+        aesdec(aesdec(sum, self.enc), sum)
+    }
+
+    #[inline]
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    fn final_mix(&self) -> u128 {
         let combined = aesenc(self.sum, self.enc);
-        let result: [u64; 2] = aesdec(aesdec(combined, self.key), combined).convert();
+        aesdec(aesdec(combined, self.key), combined)
+    }
+
+    #[inline]
+    fn finish(&self) -> u64 {
+        let result: [u64; 2] = self.final_mix().convert();
         result[0]
     }
 }
@@ -330,15 +344,13 @@ impl Hasher for AHasherStr {
     fn write(&mut self, bytes: &[u8]) {
         if bytes.len() > 8 {
             self.0.write(bytes);
-            self.0.enc = aesenc(self.0.sum, self.0.enc);
-            self.0.enc = aesdec(aesdec(self.0.enc, self.0.key), self.0.enc);
+            self.0.enc = self.0.final_mix();
         } else {
             add_in_length(&mut self.0.enc, bytes.len() as u64);
 
             let value = read_small(bytes).convert();
             self.0.sum = shuffle_and_add(self.0.sum, value);
-            self.0.enc = aesenc(self.0.sum, self.0.enc);
-            self.0.enc = aesdec(aesdec(self.0.enc, self.0.key), self.0.enc);
+            self.0.enc = self.0.final_mix();
         }
     }
 

src/hash_quality_test.rs

@@ -440,7 +440,7 @@ mod fallback_tests {
 #[cfg(any(
     all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
     all(target_arch = "aarch64", target_feature = "aes", not(miri)),
-    all(feature = "nightly-arm-aes", target_arch = "arm", target_feature = "aes", not(miri)),
+    all(target_arch = "arm", target_feature = "aes", not(miri)),
 ))]
 #[cfg(test)]
 mod aes_tests {

src/lib.rs

@@ -98,7 +98,6 @@ Note the import of [HashMapExt]. This is needed for the constructor.
 #![allow(clippy::pedantic, clippy::cast_lossless, clippy::unreadable_literal)]
 #![cfg_attr(all(not(test), not(feature = "std")), no_std)]
 #![cfg_attr(feature = "specialize", feature(min_specialization))]
-#![cfg_attr(feature = "nightly-arm-aes", feature(stdarch_arm_neon_intrinsics))]
 
 #[macro_use]
 mod convert;
@@ -108,8 +107,8 @@ mod fallback_hash;
 cfg_if::cfg_if! {
     if #[cfg(any(
             all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
-            all(feature = "nightly-arm-aes", target_arch = "aarch64", target_feature = "aes", not(miri)),
-            all(feature = "nightly-arm-aes", target_arch = "arm", target_feature = "aes", not(miri)),
+            all(target_arch = "aarch64", target_feature = "aes", not(miri)),
+            all(target_arch = "arm", target_feature = "aes", not(miri)),
         ))] {
         mod aes_hash;
         pub use crate::aes_hash::AHasher;

src/operations.rs

@@ -112,8 +112,8 @@ pub(crate) fn aesenc(value: u128, xor: u128) -> u128 {
 }
 
 #[cfg(any(
-    all(feature = "nightly-arm-aes", target_arch = "aarch64", target_feature = "aes", not(miri)),
-    all(feature = "nightly-arm-aes", target_arch = "arm", target_feature = "aes", not(miri)),
+    all(target_arch = "aarch64", target_feature = "aes", not(miri)),
+    all(target_arch = "arm", target_feature = "aes", not(miri)),
 ))]
 #[allow(unused)]
 #[inline(always)]
@@ -122,9 +122,7 @@ pub(crate) fn aesenc(value: u128, xor: u128) -> u128 {
     use core::arch::aarch64::*;
     #[cfg(target_arch = "arm")]
     use core::arch::arm::*;
-    let res = unsafe { vaesmcq_u8(vaeseq_u8(transmute!(value), transmute!(0u128))) };
-    let value: u128 = transmute!(res);
-    xor ^ value
+    unsafe { transmute!(vaeseq_u8(transmute!(value), transmute!(xor))) };
 }
 
 #[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)))]
@@ -142,8 +140,8 @@ pub(crate) fn aesdec(value: u128, xor: u128) -> u128 {
 }
 
 #[cfg(any(
-    all(feature = "nightly-arm-aes", target_arch = "aarch64", target_feature = "aes", not(miri)),
-    all(feature = "nightly-arm-aes", target_arch = "arm", target_feature = "aes", not(miri)),
+    all(target_arch = "aarch64", target_feature = "aes", not(miri)),
+    all(target_arch = "arm", target_feature = "aes", not(miri)),
 ))]
 #[allow(unused)]
 #[inline(always)]
@@ -152,9 +150,7 @@ pub(crate) fn aesdec(value: u128, xor: u128) -> u128 {
     use core::arch::aarch64::*;
     #[cfg(target_arch = "arm")]
     use core::arch::arm::*;
-    let res = unsafe { vaesimcq_u8(vaesdq_u8(transmute!(value), transmute!(0u128))) };
-    let value: u128 = transmute!(res);
-    xor ^ value
+    unsafe { transmute!(vaesdq_u8(transmute!(value), transmute!(xor))) }
 }
 
 #[allow(unused)]

src/random_state.rs

@@ -2,8 +2,8 @@ use core::hash::Hash;
 cfg_if::cfg_if! {
     if #[cfg(any(
         all(any(target_arch = "x86", target_arch = "x86_64"), target_feature = "aes", not(miri)),
-        all(feature = "nightly-arm-aes", target_arch = "aarch64", target_feature = "aes", not(miri)),
-        all(feature = "nightly-arm-aes", target_arch = "arm", target_feature = "aes", not(miri)),
+        all(target_arch = "aarch64", target_feature = "aes", not(miri)),
+        all(target_arch = "arm", target_feature = "aes", not(miri)),
     ))] {
         use crate::aes_hash::*;
     } else {

tests/bench.rs

@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "specialize", feature(build_hasher_simple_hash_one))]
 
 use ahash::{AHasher, RandomState};
 use criterion::*;
@@ -14,13 +13,8 @@ const AHASH_IMPL: &str = if cfg!(any(
         target_feature = "aes",
         not(miri),
     ),
-    all(feature = "nightly-arm-aes", target_arch = "aarch64", target_feature = "aes", not(miri)),
-    all(
-        feature = "nightly-arm-aes",
-        target_arch = "arm",
-        target_feature = "aes",
-        not(miri)
-    ),
+    all(target_arch = "aarch64", target_feature = "aes", not(miri)),
+    all(target_arch = "arm", target_feature = "aes", not(miri)),
 )) {
     "aeshash"
 } else {

tests/map_tests.rs

@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "specialize", feature(build_hasher_simple_hash_one))]
 
 use std::hash::{BuildHasher, Hash, Hasher};