cpu: Replace use of OnceNonZeroUsize::get() with get_unchecked().

Author: briansmith

src/cpu/arm.rs

@@ -148,14 +148,12 @@ pub(super) mod featureflags {
         // SAFETY: Since only `get_or_init()` could have created
         // `_cpu_features`, and it only does so after `FEATURES.get_or_init()`,
         // we know we are reading from `FEATURES` after initializing it.
-        //
-        // Also, 0 means "no features detected" to users, which is designed to
-        // be a safe configuration.
-        let features = FEATURES.get().map(NonZeroUsize::get).unwrap_or(0);
+        // The `get_or_init()` also did the synchronization.
+        let features = unsafe { FEATURES.get_unchecked() };
 
         // The truncation is lossless, as we set the value with a u32.
         #[allow(clippy::cast_possible_truncation)]
-        let features = features as u32;
+        let features = features.get() as u32;
 
         features
     }

src/cpu/intel.rs

@@ -72,14 +72,12 @@ pub(super) mod featureflags {
         // SAFETY: Since only `get_or_init()` could have created
         // `_cpu_features`, and it only does so after `FEATURES.get_or_init()`,
         // we know we are reading from `FEATURES` after initializing it.
-        //
-        // Also, 0 means "no features detected" to users, which is designed to
-        // be a safe configuration.
-        let features = FEATURES.get().map(NonZeroUsize::get).unwrap_or(0);
+        // The `get_or_init()` also did the synchronization.
+        let features = unsafe { FEATURES.get_unchecked() };
 
         // The truncation is lossless, as we set the value with a u32.
         #[allow(clippy::cast_possible_truncation)]
-        let features = features as u32;
+        let features = features.get() as u32;
 
         features
     }

src/polyfill/once_cell/race.rs

@@ -38,11 +38,45 @@ impl OnceNonZeroUsize {
         }
     }
 
-    /// Gets the underlying value.
-    #[inline]
-    pub fn get(&self) -> Option<NonZeroUsize> {
-        let val = self.inner.load(Ordering::Acquire);
-        NonZeroUsize::new(val)
+    /// Get the reference to the underlying value, without checking if the cell
+    /// is initialized.
+    ///
+    /// # Safety
+    ///
+    /// Caller must ensure that the cell is in initialized state, and that
+    /// the contents are acquired by (synchronized to) this thread.
+    pub unsafe fn get_unchecked(&self) -> NonZeroUsize {
+        #[inline(always)]
+        fn as_const_ptr(r: &AtomicUsize) -> *const usize {
+            use core::mem::align_of;
+
+            let p: *const AtomicUsize = r;
+            // SAFETY: "This type has the same size and bit validity as
+            // the underlying integer type, usize. However, the alignment of
+            // this type is always equal to its size, even on targets where
+            // usize has a lesser alignment."
+            const _ALIGNMENT_COMPATIBLE: () =
+                assert!(align_of::<AtomicUsize>() % align_of::<usize>() == 0);
+            p.cast::<usize>()
+        }
+
+        // TODO(MSRV-1.70): Use `AtomicUsize::as_ptr().cast_const()`
+        // See https://github.com/rust-lang/rust/issues/138246.
+        let p = as_const_ptr(&self.inner);
+
+        // SAFETY: The caller is responsible for ensuring that the value
+        // was initialized and that the contents have been acquired by
+        // this thread. Assuming that, we can assume there will be no
+        // conflicting writes to the value since the value will never
+        // change once initialized. This relies on the statement in
+        // https://doc.rust-lang.org/1.83.0/core/sync/atomic/ that "(A
+        // `compare_exchange` or `compare_exchange_weak` that does not
+        // succeed is not considered a write."
+        let val = unsafe { p.read() };
+
+        // SAFETY: The caller is responsible for ensuring the value is
+        // initialized and thus not zero.
+        unsafe { NonZeroUsize::new_unchecked(val) }
     }
 
     /// Gets the contents of the cell, initializing it with `f` if the cell was