Pass deployment target with -m*-version-min=

Clang's supports many ways of passing the deployment target, and prefers
that you use the `-target` flag for doing so.

This works poorly work with configuration files, which Homebrew's LLVM
uses, so we use the `-mmacosx-version-min=`, `-miphoneos-version-min=`,
`-mtargetos=` etc. flags to pass the deployment target instead.

Author: madsmtm

src/lib.rs

@@ -2182,17 +2182,14 @@ impl Build {
                         }
                     }
 
-                    // Add version information to the target.
-                    let llvm_target = if target.vendor == "apple" {
-                        let deployment_target = self.apple_deployment_target(target);
-                        target.versioned_llvm_target(Some(&deployment_target))
-                    } else {
-                        target.versioned_llvm_target(None)
-                    };
-
-                    // Pass `--target` with the LLVM target to properly
-                    // configure Clang even when cross-compiling.
-                    cmd.push_cc_arg(format!("--target={llvm_target}").into());
+                    // Pass `--target` with the LLVM target to properly configure Clang even when
+                    // cross-compiling.
+                    //
+                    // We intentionally don't put the deployment version in here on Apple targets,
+                    // and instead pass that via `-mmacosx-version-min=` and similar flags, for
+                    // better compatibility with older versions of Clang that has poor support for
+                    // versioned target names (especially when it comes to configuration files).
+                    cmd.push_cc_arg(format!("--target={}", target.unversioned_llvm_target).into());
                 }
             }
             ToolFamily::Msvc { clang_cl } => {
@@ -2208,8 +2205,9 @@ impl Build {
                         cmd.push_cc_arg("-m32".into());
                         cmd.push_cc_arg("-arch:IA32".into());
                     } else {
-                        let llvm_target = target.versioned_llvm_target(None);
-                        cmd.push_cc_arg(format!("--target={llvm_target}").into());
+                        cmd.push_cc_arg(
+                            format!("--target={}", target.unversioned_llvm_target).into(),
+                        );
                     }
                 } else if target.full_arch == "i586" {
                     cmd.push_cc_arg("-arch:IA32".into());
@@ -2635,23 +2633,13 @@ impl Build {
     fn apple_flags(&self, cmd: &mut Tool) -> Result<(), Error> {
         let target = self.get_target()?;
 
-        // If the compiler is Clang, then we've already specifed the target
-        // information (including the deployment target) with the `--target`
-        // option, so we don't need to do anything further here.
+        // Pass the deployment target via `-mmacosx-version-min=`, `-mtargetos=` and similar.
         //
-        // If the compiler is GCC, then we need to specify
-        // `-mmacosx-version-min` to set the deployment target, as well
-        // as to say that the target OS is macOS.
-        //
-        // NOTE: GCC does not support `-miphoneos-version-min=` etc. (because
-        // it does not support iOS in general), but we specify them anyhow in
-        // case we actually have a Clang-like compiler disguised as a GNU-like
-        // compiler, or in case GCC adds support for these in the future.
-        if !cmd.is_like_clang() {
-            let min_version = self.apple_deployment_target(&target);
-            cmd.args
-                .push(target.apple_version_flag(&min_version).into());
-        }
+        // It is also necessary on GCC, as it forces a compilation error if the compiler is not
+        // configured for Darwin: https://gcc.gnu.org/onlinedocs/gcc/Darwin-Options.html
+        let min_version = self.apple_deployment_target(&target);
+        cmd.args
+            .push(target.apple_version_flag(&min_version).into());
 
         // AppleClang sometimes requires sysroot even on macOS
         if cmd.is_xctoolchain_clang() || target.os != "macos" {

src/target.rs

@@ -44,7 +44,10 @@ pub(crate) struct TargetInfo<'a> {
     /// This is the same as the value of `cfg!(target_abi)`.
     pub abi: &'a str,
     /// The unversioned LLVM/Clang target triple.
-    unversioned_llvm_target: &'a str,
+    ///
+    /// NOTE: You should never need to match on this explicitly, use the other
+    /// fields on [`TargetInfo`] instead.
+    pub unversioned_llvm_target: &'a str,
 }
 
 impl FromStr for TargetInfo<'_> {

src/target/apple.rs

@@ -18,6 +18,18 @@ impl TargetInfo<'_> {
     }
 
     pub(crate) fn apple_version_flag(&self, min_version: &str) -> String {
+        // There are many aliases for these, and `-mtargetos=` is preferred on Clang nowadays, but
+        // for compatibility with older Clang, we use the earliest supported name here.
+        //
+        // NOTE: GCC does not support `-miphoneos-version-min=` etc. (because it does not support
+        // iOS in general), but we specify them anyhow in case we actually have a Clang-like
+        // compiler disguised as a GNU-like compiler, or in case GCC adds support for these in the
+        // future.
+        //
+        // See also:
+        // https://clang.llvm.org/docs/ClangCommandLineReference.html#cmdoption-clang-mmacos-version-min
+        // https://clang.llvm.org/docs/AttributeReference.html#availability
+        // https://gcc.gnu.org/onlinedocs/gcc/Darwin-Options.html#index-mmacosx-version-min
         match (self.os, self.abi) {
             ("macos", "") => format!("-mmacosx-version-min={min_version}"),
             ("ios", "") => format!("-miphoneos-version-min={min_version}"),

src/target/llvm.rs

@@ -1,32 +1,3 @@
-use std::borrow::Cow;
-
-use super::TargetInfo;
-
-impl<'a> TargetInfo<'a> {
-    /// The versioned LLVM/Clang target triple.
-    pub(crate) fn versioned_llvm_target(&self, version: Option<&str>) -> Cow<'a, str> {
-        if let Some(version) = version {
-            // Only support versioned Apple targets for now.
-            assert_eq!(self.vendor, "apple");
-
-            let mut components = self.unversioned_llvm_target.split("-");
-            let arch = components.next().expect("llvm_target should have arch");
-            let vendor = components.next().expect("llvm_target should have vendor");
-            let os = components.next().expect("LLVM target should have os");
-            let environment = components.next();
-            assert_eq!(components.next(), None, "too many LLVM target components");
-
-            Cow::Owned(if let Some(env) = environment {
-                format!("{arch}-{vendor}-{os}{version}-{env}")
-            } else {
-                format!("{arch}-{vendor}-{os}{version}")
-            })
-        } else {
-            Cow::Borrowed(self.unversioned_llvm_target)
-        }
-    }
-}
-
 /// Rust and Clang don't really agree on naming, so do a best-effort
 /// conversion to support out-of-tree / custom target-spec targets.
 pub(crate) fn guess_llvm_target_triple(