use MACOSX_DEPLOYMENT_TARGET when set

Author: youknowone

src/lib.rs

@@ -1870,8 +1870,8 @@ impl Build {
             }
         }
 
-        if target.contains("apple-ios") || target.contains("apple-watchos") {
-            self.ios_watchos_flags(cmd)?;
+        if target.contains("-apple-") {
+            self.apple_flags(cmd)?;
         }
 
         if self.static_flag.unwrap_or(false) {
@@ -2064,32 +2064,40 @@ impl Build {
         Ok(())
     }
 
-    fn ios_watchos_flags(&self, cmd: &mut Tool) -> Result<(), Error> {
+    fn apple_flags(&self, cmd: &mut Tool) -> Result<(), Error> {
         enum ArchSpec {
             Device(&'static str),
             Simulator(&'static str),
             Catalyst(&'static str),
         }
 
         enum Os {
+            MacOs,
             Ios,
             WatchOs,
         }
         impl Display for Os {
             fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
                 match self {
+                    Os::MacOs => f.write_str("macOS"),
                     Os::Ios => f.write_str("iOS"),
                     Os::WatchOs => f.write_str("WatchOS"),
                 }
             }
         }
 
         let target = self.get_target()?;
-        let os = if target.contains("-watchos") {
+        let os = if target.contains("-darwin") {
+            Os::MacOs
+        } else if target.contains("-watchos") {
             Os::WatchOs
         } else {
             Os::Ios
         };
+        let is_mac = match os {
+            Os::MacOs => true,
+            _ => false,
+        };
 
         let arch = target.split('-').nth(0).ok_or_else(|| {
             Error::new(
@@ -2108,7 +2116,18 @@ impl Build {
             None => false,
         };
 
-        let arch = if is_catalyst {
+        let arch = if is_mac {
+            match arch {
+                "i686" => ArchSpec::Device("-m32"),
+                "x86_64" | "aarch64" => ArchSpec::Device("-m64"),
+                _ => {
+                    return Err(Error::new(
+                        ErrorKind::ArchitectureInvalid,
+                        "Unknown architecture for macOS target.",
+                    ));
+                }
+            }
+        } else if is_catalyst {
             match arch {
                 "arm64e" => ArchSpec::Catalyst("arm64e"),
                 "arm64" | "aarch64" => ArchSpec::Catalyst("arm64"),
@@ -2151,6 +2170,11 @@ impl Build {
         };
 
         let (sdk_prefix, sim_prefix, min_version) = match os {
+            Os::MacOs => (
+                "macosx",
+                "",
+                std::env::var("MACOSX_DEPLOYMENT_TARGET").unwrap_or_else(|_| "10.0".into()),
+            ),
             Os::Ios => (
                 "iphone",
                 "ios-",
@@ -2164,6 +2188,11 @@ impl Build {
         };
 
         let sdk = match arch {
+            ArchSpec::Device(_) if is_mac => {
+                cmd.args
+                    .push(format!("-mmacosx-version-min={}", min_version).into());
+                "macosx".to_owned()
+            }
             ArchSpec::Device(arch) => {
                 cmd.args.push("-arch".into());
                 cmd.args.push(arch.into());
@@ -2180,11 +2209,13 @@ impl Build {
             ArchSpec::Catalyst(_) => "macosx".to_owned(),
         };
 
-        self.print(&format!("Detecting {} SDK path for {}", os, sdk));
-        let sdk_path = self.apple_sdk_root(sdk.as_str())?;
-        cmd.args.push("-isysroot".into());
-        cmd.args.push(sdk_path);
-        cmd.args.push("-fembed-bitcode".into());
+        if !is_mac {
+            self.print(&format!("Detecting {} SDK path for {}", os, sdk));
+            let sdk_path = self.apple_sdk_root(sdk.as_str())?;
+            cmd.args.push("-isysroot".into());
+            cmd.args.push(sdk_path);
+            cmd.args.push("-fembed-bitcode".into());
+        }
         /*
          * TODO we probably ultimately want the -fembed-bitcode-marker flag
          * but can't have it now because of an issue in LLVM:

tests/test.rs

@@ -427,3 +427,18 @@ fn msvc_no_dash_dash() {
 
     test.cmd(0).must_not_have("--");
 }
+
+#[test]
+fn gnu_apple_darwin() {
+    for arch in &["x86_64", "aarch64"] {
+        let target = format!("{}-apple-darwin", arch);
+        let test = Test::gnu();
+        test.gcc()
+            .target(&target)
+            .host(&target)
+            .file("foo.c")
+            .compile("foo");
+
+        test.cmd(0).must_have("-mmacosx-version-min=10.0");
+    }
+}