Move aarch64 outline-atomic initialization to sys::arch

Create a private module to hold the bootstrap code needed enable LSE
at startup on aarch64-*-linux-gnu* targets when rust implements the
intrinsics.

This is a bit more heavyweight than compiler-rt's LSE initialization,
but has the benefit of initializing the aarch64 cpu feature detection
for other uses.

Using the rust initialization code does use some atomic operations,
that's OK. Mixing LSE and non-LSE operations should work while the
update flag propagates.

Author: pmur

library/compiler-builtins/compiler-builtins/src/aarch64_linux.rs

@@ -24,33 +24,12 @@
 use core::sync::atomic::{AtomicU8, Ordering};
 
 /// non-zero if the host supports LSE atomics.
-#[cfg(not(feature = "c"))]
 static HAVE_LSE_ATOMICS: AtomicU8 = AtomicU8::new(0);
 
-/// outline-atomics are only enabled with glibc support, add a .init_array entry to
-/// check and enable LSE via getauxval. This behavior is similar to compiler rt.
-#[cfg(target_env = "gnu")]
-#[unsafe(link_section = ".init_array.90")]
-pub static RUST_LSE_INIT: extern "C" fn() = {
-    extern "C" fn aarch64_rust_init_lse_atomics() {
-        const AT_HWCAP: core::ffi::c_ulong = 16;
-        const HWCAP_ATOMICS: core::ffi::c_ulong = 0x100;
-        let hwcap;
-
-        // The most straightforward path to querying for LSE support is the host's libc.
-        // We can't use the libc crate here, we are a dependency.
-        unsafe extern "C" {
-            fn getauxval(num: core::ffi::c_ulong) -> core::ffi::c_ulong;
-        }
-        unsafe {
-            hwcap = getauxval(AT_HWCAP);
-        }
-        if hwcap & HWCAP_ATOMICS != 0 {
-            HAVE_LSE_ATOMICS.store(1, Ordering::Relaxed);
-        }
-    }
-    aarch64_rust_init_lse_atomics
-};
+/// Call to enable LSE atomic operations.
+pub fn enable_lse() {
+    HAVE_LSE_ATOMICS.store(1, Ordering::Relaxed);
+}
 
 /// Translate a byte size to a Rust type.
 #[rustfmt::skip]

library/std/src/sys/configure_builtins.rs

@@ -0,0 +1,22 @@
+/// Hook into .init_array to enable LSE atomic operations at startup, if
+/// supported. outline-atomics is only enabled on aarch64-*-gnu* targets,
+/// initialization is limited to those targets.
+#[cfg(all(
+    target_arch = "aarch64",
+    target_os = "linux",
+    target_env = "gnu",
+    not(feature = "compiler-builtins-c")
+))]
+#[used]
+#[unsafe(link_section = ".init_array.90")]
+static RUST_LSE_INIT: extern "C" fn() = {
+    extern "C" fn init_lse() {
+        use compiler_builtins::aarch64_linux;
+
+        use crate::arch;
+        if arch::is_aarch64_feature_detected!("lse") {
+            aarch64_linux::enable_lse();
+        }
+    }
+    init_lse
+};

library/std/src/sys/mod.rs

@@ -1,5 +1,10 @@
 #![allow(unsafe_op_in_unsafe_fn)]
 
+/// The configure builtins provides runtime support compiler-builtin features
+/// which require dynamic intialization to work as expected, e.g. aarch64
+/// outline-atomics.
+mod configure_builtins;
+
 /// The PAL (platform abstraction layer) contains platform-specific abstractions
 /// for implementing the features in the other submodules, e.g. UNIX file
 /// descriptors.