Use cfg_os_version_min in std

Author: madsmtm

library/std/src/lib.rs

@@ -281,6 +281,8 @@
 #![feature(cfg_sanitizer_cfi)]
 #![feature(cfg_target_thread_local)]
 #![feature(cfi_encoding)]
+#![feature(cfg_boolean_literals)]
+#![cfg_attr(not(bootstrap), feature(cfg_os_version_min))]
 #![feature(concat_idents)]
 #![feature(decl_macro)]
 #![feature(deprecated_suggestion)]

library/std/src/sys/pal/unix/fd.rs

@@ -252,7 +252,15 @@ impl FileDesc {
 
     #[cfg(all(target_os = "android", target_pointer_width = "32"))]
     pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
-        super::weak::weak!(fn preadv64(libc::c_int, *const libc::iovec, libc::c_int, off64_t) -> isize);
+        super::weak::maybe_weak!(
+            #[cfg_always_available_on(false)]
+            fn preadv64(
+                fd: libc::c_int,
+                iov: *const libc::iovec,
+                iovcnt: libc::c_int,
+                offset: off64_t,
+            ) -> isize;
+        );
 
         match preadv64.get() {
             Some(preadv) => {
@@ -281,7 +289,33 @@ impl FileDesc {
     // use "weak" linking.
     #[cfg(target_vendor = "apple")]
     pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
-        super::weak::weak!(fn preadv(libc::c_int, *const libc::iovec, libc::c_int, off64_t) -> isize);
+        #[cfg(not(bootstrap))]
+        super::weak::maybe_weak!(
+            #[cfg_always_available_on(any(
+                os_version_min("macos", "11.0"),
+                os_version_min("ios", "14.0"),
+                os_version_min("tvos", "14.0"),
+                os_version_min("watchos", "7.0"),
+                os_version_min("visionos", "1.0"),
+            ))]
+            fn preadv(
+                fd: libc::c_int,
+                iov: *const libc::iovec,
+                iovcnt: libc::c_int,
+                offset: off64_t,
+            ) -> isize;
+        );
+
+        #[cfg(bootstrap)]
+        super::weak::maybe_weak!(
+            #[cfg_always_available_on(false)]
+            fn preadv(
+                fd: libc::c_int,
+                iov: *const libc::iovec,
+                iovcnt: libc::c_int,
+                offset: off64_t,
+            ) -> isize;
+        );
 
         match preadv.get() {
             Some(preadv) => {
@@ -445,7 +479,15 @@ impl FileDesc {
 
     #[cfg(all(target_os = "android", target_pointer_width = "32"))]
     pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
-        super::weak::weak!(fn pwritev64(libc::c_int, *const libc::iovec, libc::c_int, off64_t) -> isize);
+        super::weak::maybe_weak!(
+            #[cfg_always_available_on(false)]
+            fn pwritev64(
+                fd: libc::c_int,
+                iov: *const libc::iovec,
+                iovcnt: libc::c_int,
+                offset: off64_t,
+            ) -> isize;
+        );
 
         match pwritev64.get() {
             Some(pwritev) => {
@@ -463,18 +505,35 @@ impl FileDesc {
         }
     }
 
-    // We support old MacOS, iOS, watchOS, tvOS and visionOS. `pwritev` was added in the following
-    // Apple OS versions:
-    // ios 14.0
-    // tvos 14.0
-    // macos 11.0
-    // watchos 7.0
-    //
-    // These versions may be newer than the minimum supported versions of OS's we support so we must
-    // use "weak" linking.
     #[cfg(target_vendor = "apple")]
     pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
-        super::weak::weak!(fn pwritev(libc::c_int, *const libc::iovec, libc::c_int, off64_t) -> isize);
+        #[cfg(not(bootstrap))]
+        super::weak::maybe_weak!(
+            #[cfg_always_available_on(any(
+                os_version_min("macos", "11.0"),
+                os_version_min("ios", "14.0"),
+                os_version_min("tvos", "14.0"),
+                os_version_min("watchos", "7.0"),
+                os_version_min("visionos", "1.0"),
+            ))]
+            fn pwritev(
+                fd: libc::c_int,
+                iov: *const libc::iovec,
+                iovcnt: libc::c_int,
+                offset: off64_t,
+            ) -> isize;
+        );
+
+        #[cfg(bootstrap)]
+        super::weak::maybe_weak!(
+            #[cfg_always_available_on(false)]
+            fn pwritev(
+                fd: libc::c_int,
+                iov: *const libc::iovec,
+                iovcnt: libc::c_int,
+                offset: off64_t,
+            ) -> isize;
+        );
 
         match pwritev.get() {
             Some(pwritev) => {

library/std/src/sys/pal/unix/fs.rs

@@ -80,10 +80,10 @@ use crate::sync::Arc;
 use crate::sys::common::small_c_string::run_path_with_cstr;
 use crate::sys::fd::FileDesc;
 use crate::sys::time::SystemTime;
+#[cfg(target_os = "android")]
+use crate::sys::weak::maybe_weak;
 #[cfg(all(target_os = "linux", target_env = "gnu"))]
 use crate::sys::weak::syscall;
-#[cfg(target_os = "android")]
-use crate::sys::weak::weak;
 use crate::sys::{cvt, cvt_r};
 pub use crate::sys_common::fs::exists;
 use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
@@ -1508,9 +1508,13 @@ impl File {
                 Ok(())
             } else if #[cfg(target_os = "android")] {
                 let times = [to_timespec(times.accessed)?, to_timespec(times.modified)?];
-                // futimens requires Android API level 19
                 cvt(unsafe {
-                    weak!(fn futimens(c_int, *const libc::timespec) -> c_int);
+                    maybe_weak!(
+                        // FIXME: Once `os_version_min` supports Android, mark this as available on
+                        // Android API level 19.
+                        #[cfg_always_available_on(false)]
+                        fn futimens(c_int, *const libc::timespec) -> c_int;
+                    );
                     match futimens.get() {
                         Some(futimens) => futimens(self.as_raw_fd(), times.as_ptr()),
                         None => return Err(io::const_error!(
@@ -1523,10 +1527,14 @@ impl File {
             } else {
                 #[cfg(all(target_os = "linux", target_env = "gnu", target_pointer_width = "32", not(target_arch = "riscv32")))]
                 {
-                    use crate::sys::{time::__timespec64, weak::weak};
-
-                    // Added in glibc 2.34
-                    weak!(fn __futimens64(libc::c_int, *const __timespec64) -> libc::c_int);
+                    use crate::sys::{time::__timespec64, weak::maybe_weak};
+
+                    maybe_weak!(
+                        // FIXME: Once `os_version_min` supports glibc, mark this as availabe on
+                        // glibc 2.34.
+                        #[cfg_always_available_on(false)]
+                        fn __futimens64(libc::c_int, *const __timespec64) -> libc::c_int;
+                    );
 
                     if let Some(futimens64) = __futimens64.get() {
                         let to_timespec = |time: Option<SystemTime>| time.map(|time| time.t.to_timespec64())

library/std/src/sys/pal/unix/process/process_unix.rs

@@ -454,20 +454,24 @@ impl Command {
 
         cfg_if::cfg_if! {
             if #[cfg(target_os = "linux")] {
-                use crate::sys::weak::weak;
+                use crate::sys::weak::maybe_weak;
 
-                weak! {
+                maybe_weak!(
+                    #[cfg_always_available_on(false)]
                     fn pidfd_spawnp(
-                        *mut libc::c_int,
-                        *const libc::c_char,
-                        *const libc::posix_spawn_file_actions_t,
-                        *const libc::posix_spawnattr_t,
-                        *const *mut libc::c_char,
-                        *const *mut libc::c_char
-                    ) -> libc::c_int
-                }
+                        pidfd: *mut libc::c_int,
+                          path: *const libc::c_char,
+                        file_actions: *const libc::posix_spawn_file_actions_t,
+                        attrp: *const libc::posix_spawnattr_t,
+                        argv: *const *mut libc::c_char,
+                        envp: *const *mut libc::c_char,
+                    ) -> libc::c_int;
+                );
 
-                weak! { fn pidfd_getpid(libc::c_int) -> libc::c_int }
+                maybe_weak!(
+                    #[cfg_always_available_on(false)]
+                    fn pidfd_getpid(fd: libc::c_int) -> libc::c_int;
+                );
 
                 static PIDFD_SUPPORTED: AtomicU8 = AtomicU8::new(0);
                 const UNKNOWN: u8 = 0;
@@ -575,38 +579,30 @@ impl Command {
         ) -> libc::c_int;
 
         /// Get the function pointer for adding a chdir action to a
-        /// `posix_spawn_file_actions_t`, if available, assuming a dynamic libc.
+        /// `posix_spawn_file_actions_t`, if available.
         ///
         /// Some platforms can set a new working directory for a spawned process in the
         /// `posix_spawn` path. This function looks up the function pointer for adding
         /// such an action to a `posix_spawn_file_actions_t` struct.
-        #[cfg(not(all(target_os = "linux", target_env = "musl")))]
         fn get_posix_spawn_addchdir() -> Option<PosixSpawnAddChdirFn> {
-            use crate::sys::weak::weak;
-
-            weak! {
+            use crate::sys::weak::maybe_weak;
+
+            maybe_weak!(
+                // Weak symbol lookup doesn't work with statically linked libcs, so in cases
+                // where static linking is possible we need to either check for the presence
+                // of the symbol at compile time or know about it upfront.
+                //
+                // Our minimum required musl supports this function, so we can just use it.
+                #[cfg_always_available_on(all(target_os = "linux", target_env = "musl"))]
                 fn posix_spawn_file_actions_addchdir_np(
-                    *mut libc::posix_spawn_file_actions_t,
-                    *const libc::c_char
-                ) -> libc::c_int
-            }
+                    file_actions: *mut libc::posix_spawn_file_actions_t,
+                    path: *const libc::c_char,
+                ) -> libc::c_int;
+            );
 
             posix_spawn_file_actions_addchdir_np.get()
         }
 
-        /// Get the function pointer for adding a chdir action to a
-        /// `posix_spawn_file_actions_t`, if available, on platforms where the function
-        /// is known to exist.
-        ///
-        /// Weak symbol lookup doesn't work with statically linked libcs, so in cases
-        /// where static linking is possible we need to either check for the presence
-        /// of the symbol at compile time or know about it upfront.
-        #[cfg(all(target_os = "linux", target_env = "musl"))]
-        fn get_posix_spawn_addchdir() -> Option<PosixSpawnAddChdirFn> {
-            // Our minimum required musl supports this function, so we can just use it.
-            Some(libc::posix_spawn_file_actions_addchdir_np)
-        }
-
         let addchdir = match self.get_cwd() {
             Some(cwd) => {
                 if cfg!(target_vendor = "apple") {

library/std/src/sys/pal/unix/thread.rs

@@ -4,7 +4,7 @@ use crate::num::NonZero;
 #[cfg(all(target_os = "linux", target_env = "gnu"))]
 use crate::sys::weak::dlsym;
 #[cfg(any(target_os = "solaris", target_os = "illumos", target_os = "nto",))]
-use crate::sys::weak::weak;
+use crate::sys::weak::maybe_weak;
 use crate::sys::{os, stack_overflow};
 use crate::time::Duration;
 use crate::{cmp, io, ptr};
@@ -186,11 +186,13 @@ impl Thread {
 
     #[cfg(any(target_os = "solaris", target_os = "illumos", target_os = "nto"))]
     pub fn set_name(name: &CStr) {
-        weak! {
+        maybe_weak!(
+            #[cfg_always_available_on(false)]
             fn pthread_setname_np(
-                libc::pthread_t, *const libc::c_char
-            ) -> libc::c_int
-        }
+                thread: libc::pthread_t,
+                name: *const libc::c_char,
+            ) -> libc::c_int;
+        );
 
         if let Some(f) = pthread_setname_np.get() {
             #[cfg(target_os = "nto")]

library/std/src/sys/pal/unix/time.rs

@@ -108,11 +108,18 @@ impl Timespec {
             not(target_arch = "riscv32")
         ))]
         {
-            use crate::sys::weak::weak;
+            use crate::sys::weak::maybe_weak;
 
             // __clock_gettime64 was added to 32-bit arches in glibc 2.34,
             // and it handles both vDSO calls and ENOSYS fallbacks itself.
-            weak!(fn __clock_gettime64(libc::clockid_t, *mut __timespec64) -> libc::c_int);
+            maybe_weak!(
+                // FIXME: Mark with `os_version_min` once that supports glibc.
+                #[cfg_always_available_on(false)]
+                fn __clock_gettime64(
+                    clock_id: libc::clockid_t,
+                    tp: *mut __timespec64,
+                ) -> libc::c_int;
+            );
 
             if let Some(clock_gettime64) = __clock_gettime64.get() {
                 let mut t = MaybeUninit::uninit();

library/std/src/sys/pal/unix/weak.rs

@@ -19,7 +19,7 @@
 // There are a variety of `#[cfg]`s controlling which targets are involved in
 // each instance of `weak!` and `syscall!`. Rather than trying to unify all of
 // that, we'll just allow that some unix targets don't use this module at all.
-#![allow(dead_code, unused_macros)]
+#![allow(dead_code, unused_macros, unused_imports)]
 
 use crate::ffi::CStr;
 use crate::marker::PhantomData;
@@ -28,11 +28,12 @@ use crate::{mem, ptr};
 
 // We can use true weak linkage on ELF targets.
 #[cfg(all(unix, not(target_vendor = "apple")))]
-pub(crate) macro weak {
-    (fn $name:ident($($t:ty),*) -> $ret:ty) => (
+pub(crate) macro weak_impl {
+    (fn $name:ident($($t:ty),*) -> $ret:ty $(, $sym:expr)?) => (
         let ref $name: ExternWeak<unsafe extern "C" fn($($t),*) -> $ret> = {
             unsafe extern "C" {
                 #[linkage = "extern_weak"]
+                $(#[link_name = $sym])?
                 static $name: Option<unsafe extern "C" fn($($t),*) -> $ret>;
             }
             #[allow(unused_unsafe)]
@@ -41,9 +42,44 @@ pub(crate) macro weak {
     )
 }
 
-// On non-ELF targets, use the dlsym approximation of weak linkage.
+// On Apple targets, we use `dlsym` instead of real weak linkage, since that requires an Xcode SDK
+// with the item available in `*.tbd` files for the linker, and we support compiling and linking
+// the standard library with older Xcode versions.
 #[cfg(target_vendor = "apple")]
-pub(crate) use self::dlsym as weak;
+pub(crate) use dlsym as weak_impl;
+
+/// Try to use the symbol directly if always available, and fall back to weak linking if not.
+pub(crate) macro maybe_weak {
+    {
+        #[cfg_always_available_on($($cfg:tt)*)]
+        $(#[link_name = $sym:expr])?
+        fn $name:ident($($param:ident : $t:ty),* $(,)?) -> $ret:ty;
+    } => {
+        // If the symbol is known to be available at compile-time, use it directly.
+        #[cfg($($cfg)*)]
+        let $name = {
+            extern "C" {
+                $(#[link_name = $sym])?
+                fn $name($($param : $t),*) -> $ret;
+            }
+            Known($name)
+        };
+
+        // Otherwise it needs to be weakly linked.
+        #[cfg(not($($cfg)*))]
+        weak_impl!(fn $name($($t),*) -> $ret $(, $sym)?);
+    }
+}
+
+/// The function is statically known here.
+pub(crate) struct Known<F>(F);
+
+impl<F: Copy> Known<F> {
+    #[inline]
+    pub(crate) fn get(&self) -> Option<F> {
+        Some(self.0)
+    }
+}
 
 pub(crate) struct ExternWeak<F: Copy> {
     weak_ptr: Option<F>,
@@ -145,7 +181,7 @@ unsafe fn fetch(name: &str) -> *mut libc::c_void {
 pub(crate) macro syscall {
     (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
         unsafe fn $name($($arg_name: $t),*) -> $ret {
-            weak! { fn $name($($t),*) -> $ret }
+            weak_impl! { fn $name($($t),*) -> $ret }
 
             if let Some(fun) = $name.get() {
                 fun($($arg_name),*)
@@ -161,7 +197,7 @@ pub(crate) macro syscall {
 pub(crate) macro syscall {
     (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
         unsafe fn $name($($arg_name:$t),*) -> $ret {
-            weak! { fn $name($($t),*) -> $ret }
+            weak_impl! { fn $name($($t),*) -> $ret }
 
             // Use a weak symbol from libc when possible, allowing `LD_PRELOAD`
             // interposition, but if it's not found just use a raw syscall.