Merge branch 'main' into avoid-xrun

Author: dvc94ch

.github/workflows/main.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        build: [stable, beta, nightly, linux32, macos, aarch64-ios, win32, win64, mingw32, mingw64, windows-2016]
+        build: [stable, beta, nightly, linux32, macos, aarch64-ios, win32, win64, mingw32, mingw64, windows-2019]
         include:
           - build: stable
             os: ubuntu-latest
@@ -40,23 +40,27 @@ jobs:
             target: aarch64-pc-windows-msvc
             no_run: --no-run
           - build: win32
-            os: windows-2016
+            os: windows-2019
             rust: stable-i686-msvc
             target: i686-pc-windows-msvc
           - build: win64
             os: windows-latest
             rust: stable
             target: x86_64-pc-windows-msvc
           - build: mingw32
-            os: windows-latest
+            # windows-latest, a.k.a. windows-2022, runner is equipped with
+            # a newer mingw toolchain, which appears to produce unexecutable
+            # mixed-language binaries in debug builds. Fall back to
+            # windows-2019 for now and revisit it later...
+            os: windows-2019
             rust: stable-i686-gnu
             target: i686-pc-windows-gnu
           - build: mingw64
             os: windows-latest
             rust: stable-x86_64-gnu
             target: x86_64-pc-windows-gnu
-          - build: windows-2016
-            os: windows-2016
+          - build: windows-2019
+            os: windows-2019
             rust: stable-x86_64
             target: x86_64-pc-windows-msvc
     steps:
@@ -92,16 +96,16 @@ jobs:
     runs-on: ubuntu-20.04
     steps:
     - uses: actions/checkout@master
-    - name: Install cuda-minimal-build-11-4
+    - name: Install cuda-minimal-build-11-6
       shell: bash
       run: |
         # https://developer.nvidia.com/cuda-downloads?target_os=Linux&target_arch=x86_64&Distribution=Ubuntu&target_version=20.04&target_type=deb_network
         wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-ubuntu2004.pin
         sudo mv cuda-ubuntu2004.pin /etc/apt/preferences.d/cuda-repository-pin-600
-        sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/7fa2af80.pub
+        sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/3bf863cc.pub
         sudo add-apt-repository "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/ /"
         sudo apt-get update
-        sudo apt-get -y install cuda-minimal-build-11-4
+        sudo apt-get -y install cuda-minimal-build-11-6
     - name: Test 'cudart' feature
       shell: bash
       run: env PATH=/usr/local/cuda/bin:$PATH cargo test --manifest-path cc-test/Cargo.toml --features test_cuda

Cargo.toml

@@ -2,7 +2,7 @@
 name = "cc"
 version = "1.0.73"
 authors = ["Alex Crichton <[email protected]>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 repository = "https://github.com/alexcrichton/cc-rs"
 homepage = "https://github.com/alexcrichton/cc-rs"
 documentation = "https://docs.rs/cc"
@@ -14,7 +14,7 @@ code.
 keywords = ["build-dependencies"]
 readme = "README.md"
 categories = ["development-tools::build-utils"]
-exclude = ["/.github", "/.travis.yml", "/appveyor.yml"]
+exclude = ["/.github"]
 edition = "2018"
 
 [dependencies]

src/lib.rs

@@ -59,7 +59,7 @@
 use std::collections::HashMap;
 use std::env;
 use std::ffi::{OsStr, OsString};
-use std::fmt::{self, Display};
+use std::fmt::{self, Display, Formatter};
 use std::fs;
 use std::io::{self, BufRead, BufReader, Read, Write};
 use std::path::{Component, Path, PathBuf};
@@ -168,7 +168,7 @@ impl From<io::Error> for Error {
 }
 
 impl Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{:?}: {}", self.kind, self.message)
     }
 }
@@ -1311,6 +1311,13 @@ impl Build {
         if self.cuda && self.files.len() > 1 {
             cmd.arg("--device-c");
         }
+        if compiler.family == (ToolFamily::Msvc { clang_cl: true }) {
+            // #513: For `clang-cl`, separate flags/options from the input file.
+            // When cross-compiling macOS -> Windows, this avoids interpreting
+            // common `/Users/...` paths as the `/U` flag and triggering
+            // `-Wslash-u-filename` warning.
+            cmd.arg("--");
+        }
         cmd.arg(&obj.src);
         if cfg!(target_os = "macos") {
             self.fix_env_for_apple_os(&mut cmd)?;
@@ -1522,7 +1529,7 @@ impl Build {
                     cmd.push_opt_unless_duplicate("-DANDROID".into());
                 }
 
-                if !target.contains("apple-ios") {
+                if !target.contains("apple-ios") && !target.contains("apple-watchos") {
                     cmd.push_cc_arg("-ffunction-sections".into());
                     cmd.push_cc_arg("-fdata-sections".into());
                 }
@@ -1590,6 +1597,20 @@ impl Build {
                                 .into(),
                             );
                         }
+                    } else if target.contains("watchos-sim") {
+                        if let Some(arch) =
+                            map_darwin_target_from_rust_to_compiler_architecture(target)
+                        {
+                            let deployment_target = env::var("WATCHOS_DEPLOYMENT_TARGET")
+                                .unwrap_or_else(|_| "5.0".into());
+                            cmd.args.push(
+                                format!(
+                                    "--target={}-apple-watchos{}-simulator",
+                                    arch, deployment_target
+                                )
+                                .into(),
+                            );
+                        }
                     } else if target.starts_with("riscv64gc-") {
                         cmd.args.push(
                             format!("--target={}", target.replace("riscv64gc", "riscv64")).into(),
@@ -1849,8 +1870,8 @@ impl Build {
             }
         }
 
-        if target.contains("apple-ios") {
-            self.ios_flags(cmd)?;
+        if target.contains("apple-ios") || target.contains("apple-watchos") {
+            self.ios_watchos_flags(cmd)?;
         }
 
         if self.static_flag.unwrap_or(false) {
@@ -2043,18 +2064,37 @@ impl Build {
         Ok(())
     }
 
-    fn ios_flags(&self, cmd: &mut Tool) -> Result<(), Error> {
+    fn ios_watchos_flags(&self, cmd: &mut Tool) -> Result<(), Error> {
         enum ArchSpec {
             Device(&'static str),
             Simulator(&'static str),
             Catalyst(&'static str),
         }
 
+        enum Os {
+            Ios,
+            WatchOs,
+        }
+        impl Display for Os {
+            fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+                match self {
+                    Os::Ios => f.write_str("iOS"),
+                    Os::WatchOs => f.write_str("WatchOS"),
+                }
+            }
+        }
+
         let target = self.get_target()?;
+        let os = if target.contains("-watchos") {
+            Os::WatchOs
+        } else {
+            Os::Ios
+        };
+
         let arch = target.split('-').nth(0).ok_or_else(|| {
             Error::new(
                 ErrorKind::ArchitectureInvalid,
-                "Unknown architecture for iOS target.",
+                format!("Unknown architecture for {} target.", os).as_str(),
             )
         })?;
 
@@ -2083,6 +2123,7 @@ impl Build {
         } else if is_sim {
             match arch {
                 "arm64" | "aarch64" => ArchSpec::Simulator("-arch arm64"),
+                "x86_64" => ArchSpec::Simulator("-m64"),
                 _ => {
                     return Err(Error::new(
                         ErrorKind::ArchitectureInvalid,
@@ -2093,46 +2134,59 @@ impl Build {
         } else {
             match arch {
                 "arm" | "armv7" | "thumbv7" => ArchSpec::Device("armv7"),
+                "armv7k" => ArchSpec::Device("armv7k"),
                 "armv7s" | "thumbv7s" => ArchSpec::Device("armv7s"),
                 "arm64e" => ArchSpec::Device("arm64e"),
                 "arm64" | "aarch64" => ArchSpec::Device("arm64"),
+                "arm64_32" => ArchSpec::Device("arm64_32"),
                 "i386" | "i686" => ArchSpec::Simulator("-m32"),
                 "x86_64" => ArchSpec::Simulator("-m64"),
                 _ => {
                     return Err(Error::new(
                         ErrorKind::ArchitectureInvalid,
-                        "Unknown architecture for iOS target.",
+                        format!("Unknown architecture for {} target.", os).as_str(),
                     ));
                 }
             }
         };
 
-        let min_version =
-            std::env::var("IPHONEOS_DEPLOYMENT_TARGET").unwrap_or_else(|_| "7.0".into());
+        let (sdk_prefix, sim_prefix, min_version) = match os {
+            Os::Ios => (
+                "iphone",
+                "ios-",
+                std::env::var("IPHONEOS_DEPLOYMENT_TARGET").unwrap_or_else(|_| "7.0".into()),
+            ),
+            Os::WatchOs => (
+                "watch",
+                "watch",
+                std::env::var("WATCHOS_DEPLOYMENT_TARGET").unwrap_or_else(|_| "2.0".into()),
+            ),
+        };
 
         let sdk = match arch {
             ArchSpec::Device(arch) => {
                 cmd.args.push("-arch".into());
                 cmd.args.push(arch.into());
                 cmd.args
-                    .push(format!("-miphoneos-version-min={}", min_version).into());
-                "iphoneos"
+                    .push(format!("-m{}os-version-min={}", sdk_prefix, min_version).into());
+                format!("{}os", sdk_prefix)
             }
             ArchSpec::Simulator(arch) => {
                 cmd.args.push(arch.into());
                 cmd.args
-                    .push(format!("-mios-simulator-version-min={}", min_version).into());
-                "iphonesimulator"
+                    .push(format!("-m{}simulator-version-min={}", sim_prefix, min_version).into());
+                format!("{}simulator", sdk_prefix)
             }
-            ArchSpec::Catalyst(_) => "macosx",
+            ArchSpec::Catalyst(_) => "macosx".to_owned(),
         };
 
-        self.print(&format!("Detecting iOS SDK path for {}", sdk));
+        self.print(&format!("Detecting {} SDK path for {}", os, sdk));
         let sdk_path = if let Some(sdkroot) = env::var_os("SDKROOT") {
             sdkroot
         } else {
-            self.apple_sdk_root(sdk)?
+            self.apple_sdk_root(sdk.as_str())?
         };
+
         cmd.args.push("-isysroot".into());
         cmd.args.push(sdk_path);
         cmd.args.push("-fembed-bitcode".into());
@@ -2234,6 +2288,8 @@ impl Build {
                     }
                 } else if target.contains("apple-ios") {
                     clang.to_string()
+                } else if target.contains("apple-watchos") {
+                    clang.to_string()
                 } else if target.contains("android") {
                     autodetect_android_compiler(&target, &host, gnu, clang)
                 } else if target.contains("cloudabi") {
@@ -2810,7 +2866,7 @@ impl Build {
             Err(_) => {
                 return Err(Error::new(
                     ErrorKind::IOError,
-                    "Unable to determine iOS SDK path.",
+                    "Unable to determine Apple SDK path.",
                 ));
             }
         };

tests/test.rs

@@ -343,6 +343,14 @@ fn gnu_static() {
     test.cmd(0).must_have("-static").must_not_have("-shared");
 }
 
+#[test]
+fn gnu_no_dash_dash() {
+    let test = Test::gnu();
+    test.gcc().file("foo.c").compile("foo");
+
+    test.cmd(0).must_not_have("--");
+}
+
 #[test]
 fn msvc_smoke() {
     reset_env();
@@ -411,3 +419,11 @@ fn msvc_no_static_crt() {
 
     test.cmd(0).must_have("-MD");
 }
+
+#[test]
+fn msvc_no_dash_dash() {
+    let test = Test::msvc();
+    test.gcc().file("foo.c").compile("foo");
+
+    test.cmd(0).must_not_have("--");
+}