From 9091de47826b82ce357c77090f35e3faaf22091a Mon Sep 17 00:00:00 2001 From: Daniel Mueller Date: Fri, 1 Nov 2019 07:45:35 -0700 Subject: Update cc crate to 1.0.48 This change updates the cc crate to version 1.0.48. Import subrepo cc/:cc at be9f2c1ae05b336aa3d07a4cbefdc1d88a3d8a91 --- cc/.github/workflows/main.yml | 124 +++++++++++++++++ cc/Cargo.toml | 10 +- cc/README.md | 8 -- cc/azure-pipelines.yml | 105 --------------- cc/cc-test/Cargo.toml | 1 + cc/cc-test/build.rs | 2 - cc/cc-test/tests/all.rs | 2 - cc/ci/azure-install-rust.yml | 38 ------ cc/ci/azure-steps.yml | 28 ---- cc/src/com.rs | 14 +- cc/src/lib.rs | 302 +++++++++++++++++++++++++++++++++++++----- cc/src/setup_config.rs | 24 ++-- cc/src/windows_registry.rs | 125 ++++++++--------- cc/tests/cc_env.rs | 5 +- cc/tests/cflags.rs | 5 +- cc/tests/cxxflags.rs | 5 +- cc/tests/support/mod.rs | 4 +- cc/tests/test.rs | 37 +++++- nitrocli/CHANGELOG.md | 2 +- nitrocli/Cargo.lock | 4 +- 20 files changed, 517 insertions(+), 328 deletions(-) create mode 100644 cc/.github/workflows/main.yml delete mode 100644 cc/azure-pipelines.yml delete mode 100644 cc/ci/azure-install-rust.yml delete mode 100644 cc/ci/azure-steps.yml diff --git a/cc/.github/workflows/main.yml b/cc/.github/workflows/main.yml new file mode 100644 index 0000000..9c35a41 --- /dev/null +++ b/cc/.github/workflows/main.yml @@ -0,0 +1,124 @@ +name: CI +on: [push, pull_request] + +jobs: + test: + name: Test + runs-on: ${{ matrix.os }} + strategy: + matrix: + build: [stable, beta, nightly, linux32, macos, aarch64-ios, win32, win64, mingw32, mingw64, windows-2016] + include: + - build: stable + os: ubuntu-latest + rust: stable + target: x86_64-unknown-linux-gnu + - build: beta + os: ubuntu-latest + rust: beta + target: x86_64-unknown-linux-gnu + - build: nightly + os: ubuntu-latest + rust: nightly + target: x86_64-unknown-linux-gnu + - build: linux32 + os: ubuntu-latest + rust: stable + target: i686-unknown-linux-gnu + - build: macos + os: macos-latest + rust: stable + target: x86_64-apple-darwin + - build: aarch64-ios + os: macos-latest + rust: stable + target: aarch64-apple-ios + no_run: --no-run + - build: win32 + os: windows-2016 + 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 + 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 + rust: stable-x86_64 + target: x86_64-pc-windows-msvc + steps: + - uses: actions/checkout@master + - name: Install Rust (rustup) + run: rustup update ${{ matrix.rust }} --no-self-update && rustup default ${{ matrix.rust }} + if: matrix.os != 'macos-latest' + shell: bash + - name: Install Rust (macos) + run: | + curl https://sh.rustup.rs | sh -s -- -y + echo "##[add-path]$HOME/.cargo/bin" + if: matrix.os == 'macos-latest' + - run: rustup target add ${{ matrix.target }} + - name: Install g++-multilib + run: | + set -e + # Remove the ubuntu-toolchain-r/test PPA, which is added by default. + # Some packages were removed, and this is causing the g++multilib + # install to fail. Similar issue: + # https://github.com/scikit-learn/scikit-learn/issues/13928. + sudo add-apt-repository --remove ppa:ubuntu-toolchain-r/test + sudo apt-get install g++-multilib + if: matrix.build == 'linux32' + - run: cargo build + - run: cargo test ${{ matrix.no_run }} + - run: cargo test ${{ matrix.no_run }} --features parallel + - run: cargo test ${{ matrix.no_run }} --manifest-path cc-test/Cargo.toml --target ${{ matrix.target }} + - run: cargo test ${{ matrix.no_run }} --manifest-path cc-test/Cargo.toml --target ${{ matrix.target }} --features parallel + - run: cargo test ${{ matrix.no_run }} --manifest-path cc-test/Cargo.toml --target ${{ matrix.target }} --release + + msrv: + name: MSRV + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest, windows-latest] + steps: + - uses: actions/checkout@master + - name: Install Rust + run: rustup update 1.31.0 --no-self-update && rustup default 1.31.0 + shell: bash + - run: cargo build + + rustfmt: + name: Rustfmt + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@master + - name: Install Rust + run: rustup update stable && rustup default stable && rustup component add rustfmt + - run: cargo fmt -- --check + + publish_docs: + name: Publish Documentation + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@master + - name: Install Rust + run: rustup update stable && rustup default stable + - name: Build documentation + run: cargo doc --no-deps --all-features + - name: Publish documentation + run: | + cd target/doc + git init + git add . + git -c user.name='ci' -c user.email='ci' commit -m init + git push -f -q https://git:${{ secrets.github_token }}@github.com/${{ github.repository }} HEAD:gh-pages + if: github.event_name == 'push' && github.event.ref == 'refs/heads/master' diff --git a/cc/Cargo.toml b/cc/Cargo.toml index 52e18ce..88f44eb 100644 --- a/cc/Cargo.toml +++ b/cc/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "cc" -version = "1.0.40" +version = "1.0.48" authors = ["Alex Crichton "] license = "MIT/Apache-2.0" repository = "https://github.com/alexcrichton/cc-rs" @@ -15,12 +15,14 @@ keywords = ["build-dependencies"] readme = "README.md" categories = ["development-tools::build-utils"] exclude = ["/.travis.yml", "/appveyor.yml"] +edition = "2018" [dependencies] -rayon = { version = "1.0", optional = true } +num_cpus = { version = "1.10", optional = true } +jobserver = { version = "0.1.16", optional = true } [features] -parallel = ["rayon"] +parallel = ["num_cpus", "jobserver"] [dev-dependencies] -tempdir = "0.3" +tempfile = "3" diff --git a/cc/README.md b/cc/README.md index e3c6ad0..68448ac 100644 --- a/cc/README.md +++ b/cc/README.md @@ -2,8 +2,6 @@ A library to compile C/C++/assembly into a Rust library/application. -[![Build Status](https://dev.azure.com/alexcrichton/cc-rs/_apis/build/status/alexcrichton.cc-rs?branchName=master)](https://dev.azure.com/alexcrichton/cc-rs/_build/latest?definitionId=5&branchName=master) - [Documentation](https://docs.rs/cc) A simple library meant to be used as a build dependency with Cargo packages in @@ -28,8 +26,6 @@ Next up, you'll want to write a build script like so: ```rust,no_run // build.rs -extern crate cc; - fn main() { cc::Build::new() .file("foo.c") @@ -143,8 +139,6 @@ required varies per platform, but there are three broad categories: `Build`: ```rust,no_run -extern crate cc; - fn main() { cc::Build::new() .cpp(true) // Switch to C++ library compilation. @@ -163,8 +157,6 @@ linked to the crate target. on `Build` (currently for GNU/Clang toolchains only): ```rust,no_run -extern crate cc; - fn main() { cc::Build::new() // Switch to CUDA C++ library compilation using NVCC. diff --git a/cc/azure-pipelines.yml b/cc/azure-pipelines.yml deleted file mode 100644 index e925da1..0000000 --- a/cc/azure-pipelines.yml +++ /dev/null @@ -1,105 +0,0 @@ -# Note for forks: Azure Pipelines is triggered only by commits to the branches -# matching the patterns below. -# See https://docs.microsoft.com/en-us/azure/devops/pipelines/build/triggers -trigger: - - master - - ci-* - -jobs: - - job: min_linux - pool: - vmImage: ubuntu-16.04 - displayName: Minimum Rust (Linux) - variables: - TOOLCHAIN: 1.16.0 - steps: - - template: ci/azure-install-rust.yml - - script: cargo build - - - job: min_Windows - pool: - vmImage: vs2017-win2016 - displayName: Minimum Rust (Windows) - variables: - TOOLCHAIN: 1.16.0 - steps: - - template: ci/azure-install-rust.yml - - script: cargo build - - - job: Linux - pool: - vmImage: ubuntu-16.04 - steps: - - template: ci/azure-steps.yml - strategy: - matrix: - x86_64: - TARGET: x86_64-unknown-linux-gnu - i686: - TARGET: i686-unknown-linux-gnu - x86_64-beta: - TARGET: x86_64-unknown-linux-gnu - TOOLCHAIN: beta - x86_64-nightly: - TARGET: x86_64-unknown-linux-gnu - TOOLCHAIN: nightly - - - job: macOS - pool: - vmImage: macos-10.13 - steps: - - template: ci/azure-steps.yml - strategy: - matrix: - x86_64: - TARGET: x86_64-apple-darwin - aarch64-ios: - TARGET: aarch64-apple-ios - NO_RUN: --no-run - - - job: Windows_vs2019 - pool: - vmImage: windows-2019 - steps: - - template: ci/azure-steps.yml - strategy: - matrix: - x86_64-msvc: - TARGET: x86_64-pc-windows-msvc - - - job: Windows_vs2017 - pool: - vmImage: vs2017-win2016 - steps: - - template: ci/azure-steps.yml - strategy: - matrix: - x86_64-msvc: - TARGET: x86_64-pc-windows-msvc - i686-msvc: - TARGET: i686-pc-windows-msvc - x86_64-gnu: - TARGET: x86_64-pc-windows-gnu - i686-gnu: - TARGET: i686-pc-windows-gnu - - - job: Windows_vs2015 - pool: - vmImage: vs2015-win2012r2 - steps: - - template: ci/azure-steps.yml - strategy: - matrix: - x86_64-msvc: - TARGET: x86_64-pc-windows-msvc - i686-msvc: - TARGET: i686-pc-windows-msvc - - - job: docs - steps: - - template: ci/azure-install-rust.yml - - script: cargo doc --no-deps --all-features - - script: curl -LsSf https://git.io/fhJ8n | rustc - && (cd target/doc && ../../rust_out) - condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/master')) - env: - GITHUB_DEPLOY_KEY: $(GITHUB_DEPLOY_KEY) diff --git a/cc/cc-test/Cargo.toml b/cc/cc-test/Cargo.toml index e83416a..c25854c 100644 --- a/cc/cc-test/Cargo.toml +++ b/cc/cc-test/Cargo.toml @@ -2,6 +2,7 @@ name = "cc-test" version = "0.1.0" authors = ["Alex Crichton "] +edition = "2018" [lib] name = "cc_test" diff --git a/cc/cc-test/build.rs b/cc/cc-test/build.rs index 677161e..3065861 100644 --- a/cc/cc-test/build.rs +++ b/cc/cc-test/build.rs @@ -1,5 +1,3 @@ -extern crate cc; - use std::env; use std::fs; use std::path::PathBuf; diff --git a/cc/cc-test/tests/all.rs b/cc/cc-test/tests/all.rs index 59cb8e4..a457c72 100644 --- a/cc/cc-test/tests/all.rs +++ b/cc/cc-test/tests/all.rs @@ -1,5 +1,3 @@ -extern crate cc_test; - use cc_test::*; #[link(name = "OptLinkage", kind = "static")] diff --git a/cc/ci/azure-install-rust.yml b/cc/ci/azure-install-rust.yml deleted file mode 100644 index 9c1bae8..0000000 --- a/cc/ci/azure-install-rust.yml +++ /dev/null @@ -1,38 +0,0 @@ -steps: - - bash: | - set -e - toolchain=$TOOLCHAIN - if [ "$toolchain" = "" ]; then - toolchain=stable - fi - if command -v rustup; then - rustup update $toolchain - rustup default $toolchain - else - curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain $toolchain - echo "##vso[task.prependpath]$HOME/.cargo/bin" - fi - displayName: Install rust (unix) - condition: ne( variables['Agent.OS'], 'Windows_NT' ) - - - bash: | - set -e - toolchain=$TOOLCHAIN - if [ "$toolchain" = "" ]; then - toolchain=stable-$TARGET - fi - if command -v rustup; then - rustup update --no-self-update $toolchain - rustup default $toolchain - else - curl.exe -sSf -o rustup-init.exe https://win.rustup.rs - ./rustup-init.exe -y --default-toolchain $toolchain - echo "##vso[task.prependpath]$USERPROFILE/.cargo/bin" - fi - displayName: Install rust (windows) - condition: eq( variables['Agent.OS'], 'Windows_NT' ) - - - script: | - rustc -Vv - cargo -V - displayName: Query rust and cargo versions diff --git a/cc/ci/azure-steps.yml b/cc/ci/azure-steps.yml deleted file mode 100644 index bbf8ec6..0000000 --- a/cc/ci/azure-steps.yml +++ /dev/null @@ -1,28 +0,0 @@ -steps: - - template: azure-install-rust.yml - - bash: rustup target add $TARGET - displayName: Install Rust target - - # Remove the ubuntu-toolchain-r/test PPA, which is added by default. Some - # packages were removed, and this is causing the g++multilib install to fail. - # Similar issue: https://github.com/scikit-learn/scikit-learn/issues/13928 - - bash: sudo add-apt-repository --remove ppa:ubuntu-toolchain-r/test - condition: eq( variables['Agent.OS'], 'Linux' ) - displayName: Remove ppa:ubuntu-toolchain-r/test - - - bash: sudo apt-get install g++-multilib - condition: eq( variables['Agent.OS'], 'Linux' ) - displayName: Install g++-multilib - - - script: cargo build - displayName: "Normal build" - - bash: cargo test $NO_RUN - displayName: "Crate tests" - - bash: cargo test $NO_RUN --features parallel - displayName: "Crate tests (parallel)" - - bash: cargo test $NO_RUN --manifest-path cc-test/Cargo.toml --target $TARGET - displayName: "cc-test tests" - - bash: cargo test $NO_RUN --manifest-path cc-test/Cargo.toml --target $TARGET --features parallel - displayName: "cc-test tests (parallel)" - - bash: cargo test $NO_RUN --manifest-path cc-test/Cargo.toml --target $TARGET --release - displayName: "cc-test tests (release)" diff --git a/cc/src/com.rs b/cc/src/com.rs index 9b75d47..a5f2afe 100644 --- a/cc/src/com.rs +++ b/cc/src/com.rs @@ -7,19 +7,19 @@ #![allow(unused)] +use crate::winapi::CoInitializeEx; +use crate::winapi::IUnknown; +use crate::winapi::Interface; +use crate::winapi::BSTR; +use crate::winapi::COINIT_MULTITHREADED; +use crate::winapi::{SysFreeString, SysStringLen}; +use crate::winapi::{HRESULT, S_FALSE, S_OK}; use std::ffi::{OsStr, OsString}; use std::mem::forget; use std::ops::Deref; use std::os::windows::ffi::{OsStrExt, OsStringExt}; use std::ptr::null_mut; use std::slice::from_raw_parts; -use winapi::CoInitializeEx; -use winapi::IUnknown; -use winapi::Interface; -use winapi::BSTR; -use winapi::COINIT_MULTITHREADED; -use winapi::{SysFreeString, SysStringLen}; -use winapi::{HRESULT, S_FALSE, S_OK}; pub fn initialize() -> Result<(), HRESULT> { let err = unsafe { CoInitializeEx(null_mut(), COINIT_MULTITHREADED) }; diff --git a/cc/src/lib.rs b/cc/src/lib.rs index 2d918b8..d795e5a 100644 --- a/cc/src/lib.rs +++ b/cc/src/lib.rs @@ -35,15 +35,13 @@ //! Cargo will also set this environment variable when executed with the `-jN` flag. //! //! If `NUM_JOBS` is not set, the `RAYON_NUM_THREADS` environment variable can -//! also specify the build paralellism. +//! also specify the build parallelism. //! //! # Examples //! //! Use the `Build` struct to compile `src/foo.c`: //! //! ```no_run -//! extern crate cc; -//! //! fn main() { //! cc::Build::new() //! .file("src/foo.c") @@ -58,9 +56,6 @@ #![allow(deprecated)] #![deny(missing_docs)] -#[cfg(feature = "parallel")] -extern crate rayon; - use std::collections::HashMap; use std::env; use std::ffi::{OsStr, OsString}; @@ -99,6 +94,8 @@ pub struct Build { flags: Vec, flags_supported: Vec, known_flag_support_status: Arc>>, + ar_flags: Vec, + no_default_flags: bool, files: Vec, cpp: bool, cpp_link_stdlib: Option>, @@ -109,6 +106,7 @@ pub struct Build { out_dir: Option, opt_level: Option, debug: Option, + force_frame_pointer: Option, env: Vec<(OsString, OsString)>, compiler: Option, archiver: Option, @@ -213,8 +211,17 @@ impl ToolFamily { } ToolFamily::Gnu | ToolFamily::Clang => { cmd.push_cc_arg("-g".into()); + } + } + } + + /// What the flag to force frame pointers. + fn add_force_frame_pointer(&self, cmd: &mut Tool) { + match *self { + ToolFamily::Gnu | ToolFamily::Clang => { cmd.push_cc_arg("-fno-omit-frame-pointer".into()); } + _ => (), } } @@ -277,6 +284,8 @@ impl Build { flags: Vec::new(), flags_supported: Vec::new(), known_flag_support_status: Arc::new(Mutex::new(HashMap::new())), + ar_flags: Vec::new(), + no_default_flags: false, files: Vec::new(), shared_flag: None, static_flag: None, @@ -289,6 +298,7 @@ impl Build { out_dir: None, opt_level: None, debug: None, + force_frame_pointer: None, env: Vec::new(), compiler: None, archiver: None, @@ -361,6 +371,23 @@ impl Build { self } + /// Add an arbitrary flag to the invocation of the compiler + /// + /// # Example + /// + /// ```no_run + /// cc::Build::new() + /// .file("src/foo.c") + /// .file("src/bar.c") + /// .ar_flag("/NODEFAULTLIB:libc.dll") + /// .compile("foo"); + /// ``` + + pub fn ar_flag(&mut self, flag: &str) -> &mut Build { + self.ar_flags.push(flag.to_string()); + self + } + fn ensure_check_file(&self) -> Result { let out_dir = self.get_out_dir()?; let src = if self.cuda { @@ -497,6 +524,17 @@ impl Build { self } + /// Disables the generation of default compiler flags. The default compiler + /// flags may cause conflicts in some cross compiling scenarios. + /// + /// Setting the `CRATE_CC_NO_DEFAULTS` environment variable has the same + /// effect as setting this to `true`. The presence of the environment + /// variable and the value of `no_default_flags` will be OR'd together. + pub fn no_default_flags(&mut self, no_default_flags: bool) -> &mut Build { + self.no_default_flags = no_default_flags; + self + } + /// Add a file which will be compiled pub fn file>(&mut self, p: P) -> &mut Build { self.files.push(p.as_ref().to_path_buf()); @@ -750,6 +788,17 @@ impl Build { self } + /// Configures whether the compiler will emit instructions to store + /// frame pointers during codegen. + /// + /// This option is automatically enabled when debug information is emitted. + /// Otherwise the target platform compiler's default will be used. + /// You can use this option to force a specific setting. + pub fn force_frame_pointer(&mut self, force: bool) -> &mut Build { + self.force_frame_pointer = Some(force); + self + } + /// Configures the output directory where all object files and static /// libraries will be located. /// @@ -931,22 +980,150 @@ impl Build { } #[cfg(feature = "parallel")] - fn compile_objects(&self, objs: &[Object]) -> Result<(), Error> { - use self::rayon::prelude::*; + fn compile_objects<'me>(&'me self, objs: &[Object]) -> Result<(), Error> { + use std::sync::atomic::{AtomicBool, Ordering::SeqCst}; + use std::sync::Once; + + // Limit our parallelism globally with a jobserver. Start off by + // releasing our own token for this process so we can have a bit of an + // easier to write loop below. If this fails, though, then we're likely + // on Windows with the main implicit token, so we just have a bit extra + // parallelism for a bit and don't reacquire later. + let server = jobserver(); + let reacquire = server.release_raw().is_ok(); + + // When compiling objects in parallel we do a few dirty tricks to speed + // things up: + // + // * First is that we use the `jobserver` crate to limit the parallelism + // of this build script. The `jobserver` crate will use a jobserver + // configured by Cargo for build scripts to ensure that parallelism is + // coordinated across C compilations and Rust compilations. Before we + // compile anything we make sure to wait until we acquire a token. + // + // Note that this jobserver is cached globally so we only used one per + // process and only worry about creating it once. + // + // * Next we use a raw `thread::spawn` per thread to actually compile + // objects in parallel. We only actually spawn a thread after we've + // acquired a token to perform some work + // + // * Finally though we want to keep the dependencies of this crate + // pretty light, so we avoid using a safe abstraction like `rayon` and + // instead rely on some bits of `unsafe` code. We know that this stack + // frame persists while everything is compiling so we use all the + // stack-allocated objects without cloning/reallocating. We use a + // transmute to `State` with a `'static` lifetime to persist + // everything we need across the boundary, and the join-on-drop + // semantics of `JoinOnDrop` should ensure that our stack frame is + // alive while threads are alive. + // + // With all that in mind we compile all objects in a loop here, after we + // acquire the appropriate tokens, Once all objects have been compiled + // we join on all the threads and propagate the results of compilation. + // + // Note that as a slight optimization we try to break out as soon as + // possible as soon as any compilation fails to ensure that errors get + // out to the user as fast as possible. + let error = AtomicBool::new(false); + let mut threads = Vec::new(); + for obj in objs { + if error.load(SeqCst) { + break; + } + let token = server.acquire()?; + let state = State { + build: self, + obj, + error: &error, + }; + let state = unsafe { std::mem::transmute::>(state) }; + let thread = thread::spawn(|| { + let state: State<'me> = state; // erase the `'static` lifetime + let result = state.build.compile_object(state.obj); + if result.is_err() { + state.error.store(true, SeqCst); + } + drop(token); // make sure our jobserver token is released after the compile + return result; + }); + threads.push(JoinOnDrop(Some(thread))); + } - if let Some(amt) = self.getenv("NUM_JOBS") { - if let Ok(amt) = amt.parse() { - let _ = rayon::ThreadPoolBuilder::new() - .num_threads(amt) - .build_global(); + for mut thread in threads { + if let Some(thread) = thread.0.take() { + thread.join().expect("thread should not panic")?; } } - // Check for any errors and return the first one found. - objs.par_iter() - .with_max_len(1) - .map(|obj| self.compile_object(obj)) - .collect() + // Reacquire our process's token before we proceed, which we released + // before entering the loop above. + if reacquire { + server.acquire_raw()?; + } + + return Ok(()); + + /// Shared state from the parent thread to the child thread. This + /// package of pointers is temporarily transmuted to a `'static` + /// lifetime to cross the thread boundary and then once the thread is + /// running we erase the `'static` to go back to an anonymous lifetime. + struct State<'a> { + build: &'a Build, + obj: &'a Object, + error: &'a AtomicBool, + } + + /// Returns a suitable `jobserver::Client` used to coordinate + /// parallelism between build scripts. + fn jobserver() -> &'static jobserver::Client { + static INIT: Once = Once::new(); + static mut JOBSERVER: Option = None; + + fn _assert_sync() {} + _assert_sync::(); + + unsafe { + INIT.call_once(|| { + let server = default_jobserver(); + JOBSERVER = Some(server); + }); + JOBSERVER.as_ref().unwrap() + } + } + + unsafe fn default_jobserver() -> jobserver::Client { + // Try to use the environmental jobserver which Cargo typically + // initializes for us... + if let Some(client) = jobserver::Client::from_env() { + return client; + } + + // ... but if that fails for whatever reason fall back to the number + // of cpus on the system or the `NUM_JOBS` env var. + let mut parallelism = num_cpus::get(); + if let Ok(amt) = env::var("NUM_JOBS") { + if let Ok(amt) = amt.parse() { + parallelism = amt; + } + } + + // If we create our own jobserver then be sure to reserve one token + // for ourselves. + let client = jobserver::Client::new(parallelism).expect("failed to create jobserver"); + client.acquire_raw().expect("failed to acquire initial"); + return client; + } + + struct JoinOnDrop(Option>>); + + impl Drop for JoinOnDrop { + fn drop(&mut self) { + if let Some(thread) = self.0.take() { + drop(thread.join()); + } + } + } } #[cfg(not(feature = "parallel"))] @@ -1073,11 +1250,10 @@ impl Build { let mut cmd = self.get_base_compiler()?; let envflags = self.envflags(if self.cpp { "CXXFLAGS" } else { "CFLAGS" }); - // Disable default flag generation via environment variable or when - // certain cross compiling arguments are set - let use_defaults = self.getenv("CRATE_CC_NO_DEFAULTS").is_none(); + // Disable default flag generation via `no_default_flags` or environment variable + let no_defaults = self.no_default_flags || self.getenv("CRATE_CC_NO_DEFAULTS").is_some(); - if use_defaults { + if !no_defaults { self.add_default_flags(&mut cmd, &target, &opt_level)?; } else { println!("Info: default compiler flags are disabled"); @@ -1213,12 +1389,22 @@ impl Build { family.add_debug_flags(cmd); } + if self.get_force_frame_pointer() { + let family = cmd.family; + family.add_force_frame_pointer(cmd); + } + // Target flags match cmd.family { ToolFamily::Clang => { cmd.args.push(format!("--target={}", target).into()); } ToolFamily::Msvc { clang_cl } => { + // This is an undocumented flag from MSVC but helps with making + // builds more reproducible by avoiding putting timestamps into + // files. + cmd.args.push("-Brepro".into()); + if clang_cl { if target.contains("x86_64") { cmd.args.push("-m64".into()); @@ -1402,9 +1588,11 @@ impl Build { if let Some(arch) = parts.next() { let arch = &arch[5..]; cmd.args.push(("-march=rv".to_owned() + arch).into()); - // ABI is always soft-float right now, update this when this is no longer the - // case: - if arch.starts_with("64") { + if target.contains("linux") && arch.starts_with("64") { + cmd.args.push("-mabi=lp64d".into()); + } else if target.contains("linux") && arch.starts_with("32") { + cmd.args.push("-mabi=ilp32d".into()); + } else if arch.starts_with("64") { cmd.args.push("-mabi=lp64".into()); } else { cmd.args.push("-mabi=ilp32".into()); @@ -1501,6 +1689,9 @@ impl Build { let mut out = OsString::from("-out:"); out.push(dst); cmd.arg(out).arg("-nologo"); + for flag in self.ar_flags.iter() { + cmd.arg(flag); + } // Similar to https://github.com/rust-lang/rust/pull/47507 // and https://github.com/rust-lang/rust/pull/48548 @@ -1563,6 +1754,33 @@ impl Build { }; } else { let (mut ar, cmd) = self.get_ar()?; + + // Set an environment variable to tell the OSX archiver to ensure + // that all dates listed in the archive are zero, improving + // determinism of builds. AFAIK there's not really official + // documentation of this but there's a lot of references to it if + // you search google. + // + // You can reproduce this locally on a mac with: + // + // $ touch foo.c + // $ cc -c foo.c -o foo.o + // + // # Notice that these two checksums are different + // $ ar crus libfoo1.a foo.o && sleep 2 && ar crus libfoo2.a foo.o + // $ md5sum libfoo*.a + // + // # Notice that these two checksums are the same + // $ export ZERO_AR_DATE=1 + // $ ar crus libfoo1.a foo.o && sleep 2 && touch foo.o && ar crus libfoo2.a foo.o + // $ md5sum libfoo*.a + // + // In any case if this doesn't end up getting read, it shouldn't + // cause that many issues! + ar.env("ZERO_AR_DATE", "1"); + for flag in self.ar_flags.iter() { + ar.arg(flag); + } run( ar.arg("crs").arg(dst).args(&objects).args(&self.objects), &cmd, @@ -1687,13 +1905,19 @@ impl Build { let tool_opt: Option = self .env_tool(env) - .map(|(tool, cc, args)| { + .map(|(tool, wrapper, args)| { + // find the driver mode, if any + const DRIVER_MODE: &str = "--driver-mode="; + let driver_mode = args + .iter() + .find(|a| a.starts_with(DRIVER_MODE)) + .map(|a| &a[DRIVER_MODE.len()..]); // chop off leading/trailing whitespace to work around // semi-buggy build scripts which are shared in // makefiles/configure scripts (where spaces are far more // lenient) - let mut t = Tool::new(PathBuf::from(tool.trim())); - if let Some(cc) = cc { + let mut t = Tool::with_clang_driver(PathBuf::from(tool.trim()), driver_mode); + if let Some(cc) = wrapper { t.cc_wrapper_path = Some(PathBuf::from(cc)); } for arg in args { @@ -1846,7 +2070,7 @@ impl Build { Err(_) => "nvcc".into(), Ok(nvcc) => nvcc, }; - let mut nvcc_tool = Tool::with_features(PathBuf::from(nvcc), self.cuda); + let mut nvcc_tool = Tool::with_features(PathBuf::from(nvcc), None, self.cuda); nvcc_tool .args .push(format!("-ccbin={}", tool.path.display()).into()); @@ -2062,6 +2286,10 @@ impl Build { }) } + fn get_force_frame_pointer(&self) -> bool { + self.force_frame_pointer.unwrap_or_else(|| self.get_debug()) + } + fn get_out_dir(&self) -> Result { match self.out_dir.clone() { Some(p) => Ok(p), @@ -2109,11 +2337,15 @@ impl Default for Build { } impl Tool { - fn new(path: PathBuf) -> Tool { - Tool::with_features(path, false) + fn new(path: PathBuf) -> Self { + Tool::with_features(path, None, false) } - fn with_features(path: PathBuf, cuda: bool) -> Tool { + fn with_clang_driver(path: PathBuf, clang_driver: Option<&str>) -> Self { + Self::with_features(path, clang_driver, false) + } + + fn with_features(path: PathBuf, clang_driver: Option<&str>, cuda: bool) -> Self { // Try to detect family of the tool from its name, falling back to Gnu. let family = if let Some(fname) = path.file_name().and_then(|p| p.to_str()) { if fname.contains("clang-cl") { @@ -2125,13 +2357,17 @@ impl Tool { { ToolFamily::Msvc { clang_cl: false } } else if fname.contains("clang") { - ToolFamily::Clang + match clang_driver { + Some("cl") => ToolFamily::Msvc { clang_cl: true }, + _ => ToolFamily::Clang, + } } else { ToolFamily::Gnu } } else { ToolFamily::Gnu }; + Tool { path: path, cc_wrapper_path: None, diff --git a/cc/src/setup_config.rs b/cc/src/setup_config.rs index 56fe114..bc2b1c2 100644 --- a/cc/src/setup_config.rs +++ b/cc/src/setup_config.rs @@ -8,19 +8,19 @@ #![allow(bad_style)] #![allow(unused)] +use crate::winapi::Interface; +use crate::winapi::BSTR; +use crate::winapi::LPCOLESTR; +use crate::winapi::LPSAFEARRAY; +use crate::winapi::S_FALSE; +use crate::winapi::{CoCreateInstance, CLSCTX_ALL}; +use crate::winapi::{IUnknown, IUnknownVtbl}; +use crate::winapi::{HRESULT, LCID, LPCWSTR, PULONGLONG}; +use crate::winapi::{LPFILETIME, ULONG}; use std::ffi::OsString; use std::ptr::null_mut; -use winapi::Interface; -use winapi::BSTR; -use winapi::LPCOLESTR; -use winapi::LPSAFEARRAY; -use winapi::S_FALSE; -use winapi::{CoCreateInstance, CLSCTX_ALL}; -use winapi::{IUnknown, IUnknownVtbl}; -use winapi::{HRESULT, LCID, LPCWSTR, PULONGLONG}; -use winapi::{LPFILETIME, ULONG}; -use com::{BStr, ComPtr}; +use crate::com::{BStr, ComPtr}; // Bindings to the Setup.Configuration stuff pub type InstanceState = u32; @@ -196,7 +196,7 @@ impl SetupConfiguration { } pub fn enum_all_instances(&self) -> Result { let mut obj = null_mut(); - let this = try!(self.0.cast::()); + let this = self.0.cast::()?; let err = unsafe { this.EnumAllInstances(&mut obj) }; if err < 0 { return Err(err); @@ -249,7 +249,7 @@ impl SetupInstance { } pub fn product_path(&self) -> Result { let mut s = null_mut(); - let this = try!(self.0.cast::()); + let this = self.0.cast::()?; let err = unsafe { this.GetProductPath(&mut s) }; let bstr = unsafe { BStr::from_raw(s) }; if err < 0 { diff --git a/cc/src/windows_registry.rs b/cc/src/windows_registry.rs index ee39339..5af3ff7 100644 --- a/cc/src/windows_registry.rs +++ b/cc/src/windows_registry.rs @@ -13,17 +13,7 @@ use std::process::Command; -use Tool; - -#[cfg(windows)] -macro_rules! otry { - ($expr:expr) => { - match $expr { - Some(val) => val, - None => return None, - } - }; -} +use crate::Tool; /// Attempts to find a tool within an MSVC installation using the Windows /// registry as a point to search from. @@ -173,9 +163,9 @@ pub fn find_vs_version() -> Result { #[cfg(windows)] mod impl_ { - use com; - use registry::{RegistryKey, LOCAL_MACHINE}; - use setup_config::{EnumSetupInstances, SetupConfiguration, SetupInstance}; + use crate::com; + use crate::registry::{RegistryKey, LOCAL_MACHINE}; + use crate::setup_config::{EnumSetupInstances, SetupConfiguration, SetupInstance}; use std::env; use std::ffi::OsString; use std::fs::File; @@ -184,7 +174,7 @@ mod impl_ { use std::mem; use std::path::{Path, PathBuf}; - use Tool; + use crate::Tool; struct MsvcTool { tool: PathBuf, @@ -218,6 +208,7 @@ mod impl_ { } } + #[allow(bare_trait_objects)] fn vs16_instances() -> Box> { let instances = if let Some(instances) = vs15_instances() { instances @@ -225,10 +216,10 @@ mod impl_ { return Box::new(iter::empty()); }; Box::new(instances.filter_map(|instance| { - let instance = otry!(instance.ok()); - let installation_name = otry!(instance.installation_name().ok()); - if otry!(installation_name.to_str()).starts_with("VisualStudio/16.") { - Some(PathBuf::from(otry!(instance.installation_path().ok()))) + let instance = instance.ok()?; + let installation_name = instance.installation_name().ok()?; + if installation_name.to_str()?.starts_with("VisualStudio/16.") { + Some(PathBuf::from(instance.installation_path().ok()?)) } else { None } @@ -263,16 +254,16 @@ mod impl_ { // // [online]: https://blogs.msdn.microsoft.com/vcblog/2017/03/06/finding-the-visual-c-compiler-tools-in-visual-studio-2017/ fn vs15_instances() -> Option { - otry!(com::initialize().ok()); + com::initialize().ok()?; - let config = otry!(SetupConfiguration::new().ok()); + let config = SetupConfiguration::new().ok()?; config.enum_all_instances().ok() } pub fn find_msvc_15(tool: &str, target: &str) -> Option { - let iter = otry!(vs15_instances()); + let iter = vs15_instances()?; for instance in iter { - let instance = otry!(instance.ok()); + let instance = instance.ok()?; let tool = tool_from_vs15_instance(tool, target, &instance); if tool.is_some() { return tool; @@ -322,8 +313,7 @@ mod impl_ { } fn tool_from_vs15_instance(tool: &str, target: &str, instance: &SetupInstance) -> Option { - let (bin_path, host_dylib_path, lib_path, include_path) = - otry!(vs15_vc_paths(target, instance)); + let (bin_path, host_dylib_path, lib_path, include_path) = vs15_vc_paths(target, instance)?; let tool_path = bin_path.join(tool); if !tool_path.exists() { return None; @@ -339,7 +329,7 @@ mod impl_ { tool.include.push(atl_include_path); } - otry!(add_sdks(&mut tool, target)); + add_sdks(&mut tool, target)?; Some(tool.into_tool()) } @@ -348,19 +338,19 @@ mod impl_ { target: &str, instance: &SetupInstance, ) -> Option<(PathBuf, PathBuf, PathBuf, PathBuf)> { - let instance_path: PathBuf = otry!(instance.installation_path().ok()).into(); + let instance_path: PathBuf = instance.installation_path().ok()?.into(); let version_path = instance_path.join(r"VC\Auxiliary\Build\Microsoft.VCToolsVersion.default.txt"); - let mut version_file = otry!(File::open(version_path).ok()); + let mut version_file = File::open(version_path).ok()?; let mut version = String::new(); - otry!(version_file.read_to_string(&mut version).ok()); + version_file.read_to_string(&mut version).ok()?; let version = version.trim(); let host = match host_arch() { X86 => "X86", X86_64 => "X64", _ => return None, }; - let target = otry!(lib_subdir(target)); + let target = lib_subdir(target)?; // The directory layout here is MSVC/bin/Host$host/$target/ let path = instance_path.join(r"VC\Tools\MSVC").join(version); // This is the path to the toolchain for a particular target, running @@ -383,7 +373,7 @@ mod impl_ { fn atl_paths(target: &str, path: &Path) -> Option<(PathBuf, PathBuf)> { let atl_path = path.join("atlfmc"); - let sub = otry!(lib_subdir(target)); + let sub = lib_subdir(target)?; if atl_path.exists() { Some((atl_path.join("lib").join(sub), atl_path.join("include"))) } else { @@ -394,15 +384,15 @@ mod impl_ { // For MSVC 14 we need to find the Universal CRT as well as either // the Windows 10 SDK or Windows 8.1 SDK. pub fn find_msvc_14(tool: &str, target: &str) -> Option { - let vcdir = otry!(get_vc_dir("14.0")); - let mut tool = otry!(get_tool(tool, &vcdir, target)); - otry!(add_sdks(&mut tool, target)); + let vcdir = get_vc_dir("14.0")?; + let mut tool = get_tool(tool, &vcdir, target)?; + add_sdks(&mut tool, target)?; Some(tool.into_tool()) } fn add_sdks(tool: &mut MsvcTool, target: &str) -> Option<()> { - let sub = otry!(lib_subdir(target)); - let (ucrt, ucrt_version) = otry!(get_ucrt_dir()); + let sub = lib_subdir(target)?; + let (ucrt, ucrt_version) = get_ucrt_dir()?; tool.path .push(ucrt.join("bin").join(&ucrt_version).join(sub)); @@ -437,10 +427,10 @@ mod impl_ { // For MSVC 12 we need to find the Windows 8.1 SDK. pub fn find_msvc_12(tool: &str, target: &str) -> Option { - let vcdir = otry!(get_vc_dir("12.0")); - let mut tool = otry!(get_tool(tool, &vcdir, target)); - let sub = otry!(lib_subdir(target)); - let sdk81 = otry!(get_sdk81_dir()); + let vcdir = get_vc_dir("12.0")?; + let mut tool = get_tool(tool, &vcdir, target)?; + let sub = lib_subdir(target)?; + let sdk81 = get_sdk81_dir()?; tool.path.push(sdk81.join("bin").join(sub)); let sdk_lib = sdk81.join("lib").join("winv6.3"); tool.libs.push(sdk_lib.join("um").join(sub)); @@ -453,10 +443,10 @@ mod impl_ { // For MSVC 11 we need to find the Windows 8 SDK. pub fn find_msvc_11(tool: &str, target: &str) -> Option { - let vcdir = otry!(get_vc_dir("11.0")); - let mut tool = otry!(get_tool(tool, &vcdir, target)); - let sub = otry!(lib_subdir(target)); - let sdk8 = otry!(get_sdk8_dir()); + let vcdir = get_vc_dir("11.0")?; + let mut tool = get_tool(tool, &vcdir, target)?; + let sub = lib_subdir(target)?; + let sdk8 = get_sdk8_dir()?; tool.path.push(sdk8.join("bin").join(sub)); let sdk_lib = sdk8.join("lib").join("win8"); tool.libs.push(sdk_lib.join("um").join(sub)); @@ -493,7 +483,7 @@ mod impl_ { tool }) .filter_map(|mut tool| { - let sub = otry!(vc_lib_subdir(target)); + let sub = vc_lib_subdir(target)?; tool.libs.push(path.join("lib").join(sub)); tool.include.push(path.join("include")); let atlmfc_path = path.join("atlmfc"); @@ -510,8 +500,8 @@ mod impl_ { // trying to find. fn get_vc_dir(ver: &str) -> Option { let key = r"SOFTWARE\Microsoft\VisualStudio\SxS\VC7"; - let key = otry!(LOCAL_MACHINE.open(key.as_ref()).ok()); - let path = otry!(key.query_str(ver).ok()); + let key = LOCAL_MACHINE.open(key.as_ref()).ok()?; + let path = key.query_str(ver).ok()?; Some(path.into()) } @@ -523,19 +513,20 @@ mod impl_ { // Returns a pair of (root, version) for the ucrt dir if found fn get_ucrt_dir() -> Option<(PathBuf, String)> { let key = r"SOFTWARE\Microsoft\Windows Kits\Installed Roots"; - let key = otry!(LOCAL_MACHINE.open(key.as_ref()).ok()); - let root = otry!(key.query_str("KitsRoot10").ok()); - let readdir = otry!(Path::new(&root).join("lib").read_dir().ok()); - let max_libdir = otry!(readdir + let key = LOCAL_MACHINE.open(key.as_ref()).ok()?; + let root = key.query_str("KitsRoot10").ok()?; + let readdir = Path::new(&root).join("lib").read_dir().ok()?; + let max_libdir = readdir .filter_map(|dir| dir.ok()) .map(|dir| dir.path()) - .filter(|dir| dir - .components() - .last() - .and_then(|c| c.as_os_str().to_str()) - .map(|c| c.starts_with("10.") && dir.join("ucrt").is_dir()) - .unwrap_or(false)) - .max()); + .filter(|dir| { + dir.components() + .last() + .and_then(|c| c.as_os_str().to_str()) + .map(|c| c.starts_with("10.") && dir.join("ucrt").is_dir()) + .unwrap_or(false) + }) + .max()?; let version = max_libdir.components().last().unwrap(); let version = version.as_os_str().to_str().unwrap().to_string(); Some((root.into(), version)) @@ -551,19 +542,19 @@ mod impl_ { // asciibetically to find the newest one as that is what vcvars does. fn get_sdk10_dir() -> Option<(PathBuf, String)> { let key = r"SOFTWARE\Microsoft\Microsoft SDKs\Windows\v10.0"; - let key = otry!(LOCAL_MACHINE.open(key.as_ref()).ok()); - let root = otry!(key.query_str("InstallationFolder").ok()); - let readdir = otry!(Path::new(&root).join("lib").read_dir().ok()); + let key = LOCAL_MACHINE.open(key.as_ref()).ok()?; + let root = key.query_str("InstallationFolder").ok()?; + let readdir = Path::new(&root).join("lib").read_dir().ok()?; let mut dirs = readdir .filter_map(|dir| dir.ok()) .map(|dir| dir.path()) .collect::>(); dirs.sort(); - let dir = otry!(dirs + let dir = dirs .into_iter() .rev() .filter(|dir| dir.join("um").join("x64").join("kernel32.lib").is_file()) - .next()); + .next()?; let version = dir.components().last().unwrap(); let version = version.as_os_str().to_str().unwrap().to_string(); Some((root.into(), version)) @@ -575,15 +566,15 @@ mod impl_ { // instead of user mode applications, we would care. fn get_sdk81_dir() -> Option { let key = r"SOFTWARE\Microsoft\Microsoft SDKs\Windows\v8.1"; - let key = otry!(LOCAL_MACHINE.open(key.as_ref()).ok()); - let root = otry!(key.query_str("InstallationFolder").ok()); + let key = LOCAL_MACHINE.open(key.as_ref()).ok()?; + let root = key.query_str("InstallationFolder").ok()?; Some(root.into()) } fn get_sdk8_dir() -> Option { let key = r"SOFTWARE\Microsoft\Microsoft SDKs\Windows\v8.0"; - let key = otry!(LOCAL_MACHINE.open(key.as_ref()).ok()); - let root = otry!(key.query_str("InstallationFolder").ok()); + let key = LOCAL_MACHINE.open(key.as_ref()).ok()?; + let root = key.query_str("InstallationFolder").ok()?; Some(root.into()) } diff --git a/cc/tests/cc_env.rs b/cc/tests/cc_env.rs index e862fea..43eb689 100644 --- a/cc/tests/cc_env.rs +++ b/cc/tests/cc_env.rs @@ -1,12 +1,9 @@ -extern crate cc; -extern crate tempdir; - use std::env; use std::ffi::OsString; use std::path::Path; mod support; -use support::Test; +use crate::support::Test; #[test] fn main() { diff --git a/cc/tests/cflags.rs b/cc/tests/cflags.rs index df6b0a7..caec6ea 100644 --- a/cc/tests/cflags.rs +++ b/cc/tests/cflags.rs @@ -1,10 +1,7 @@ -extern crate cc; -extern crate tempdir; - mod support; +use crate::support::Test; use std::env; -use support::Test; /// This test is in its own module because it modifies the environment and would affect other tests /// when run in parallel with them. diff --git a/cc/tests/cxxflags.rs b/cc/tests/cxxflags.rs index 26426af..c524c7d 100644 --- a/cc/tests/cxxflags.rs +++ b/cc/tests/cxxflags.rs @@ -1,10 +1,7 @@ -extern crate cc; -extern crate tempdir; - mod support; +use crate::support::Test; use std::env; -use support::Test; /// This test is in its own module because it modifies the environment and would affect other tests /// when run in parallel with them. diff --git a/cc/tests/support/mod.rs b/cc/tests/support/mod.rs index 7d74719..fe8acde 100644 --- a/cc/tests/support/mod.rs +++ b/cc/tests/support/mod.rs @@ -8,7 +8,7 @@ use std::io::prelude::*; use std::path::{Path, PathBuf}; use cc; -use tempdir::TempDir; +use tempfile::{Builder, TempDir}; pub struct Test { pub td: TempDir, @@ -27,7 +27,7 @@ impl Test { if gcc.ends_with("deps") { gcc.pop(); } - let td = TempDir::new_in(&gcc, "gcc-test").unwrap(); + let td = Builder::new().prefix("gcc-test").tempdir_in(&gcc).unwrap(); gcc.push(format!("gcc-shim{}", env::consts::EXE_SUFFIX)); Test { td: td, diff --git a/cc/tests/test.rs b/cc/tests/test.rs index 74eca1e..def11f0 100644 --- a/cc/tests/test.rs +++ b/cc/tests/test.rs @@ -1,7 +1,4 @@ -extern crate cc; -extern crate tempdir; - -use support::Test; +use crate::support::Test; mod support; @@ -42,10 +39,40 @@ fn gnu_opt_level_s() { } #[test] -fn gnu_debug() { +fn gnu_debug_fp_auto() { let test = Test::gnu(); test.gcc().debug(true).file("foo.c").compile("foo"); test.cmd(0).must_have("-g"); + test.cmd(0).must_have("-fno-omit-frame-pointer"); +} + +#[test] +fn gnu_debug_fp() { + let test = Test::gnu(); + test.gcc().debug(true).file("foo.c").compile("foo"); + test.cmd(0).must_have("-g"); + test.cmd(0).must_have("-fno-omit-frame-pointer"); +} + +#[test] +fn gnu_debug_nofp() { + let test = Test::gnu(); + test.gcc() + .debug(true) + .force_frame_pointer(false) + .file("foo.c") + .compile("foo"); + test.cmd(0).must_have("-g"); + test.cmd(0).must_not_have("-fno-omit-frame-pointer"); + + let test = Test::gnu(); + test.gcc() + .force_frame_pointer(false) + .debug(true) + .file("foo.c") + .compile("foo"); + test.cmd(0).must_have("-g"); + test.cmd(0).must_not_have("-fno-omit-frame-pointer"); } #[test] diff --git a/nitrocli/CHANGELOG.md b/nitrocli/CHANGELOG.md index c74960b..a55237e 100644 --- a/nitrocli/CHANGELOG.md +++ b/nitrocli/CHANGELOG.md @@ -9,7 +9,7 @@ Unreleased - Removed previously deprecated `--ascii` option from `otp set` command - Fixed wrong hexadecimal conversion used in `otp set` command - Bumped `libc` dependency to `0.2.66` -- Bumped `cc` dependency to `1.0.40` +- Bumped `cc` dependency to `1.0.48` 0.2.4 diff --git a/nitrocli/Cargo.lock b/nitrocli/Cargo.lock index 2976d61..18d48b5 100644 --- a/nitrocli/Cargo.lock +++ b/nitrocli/Cargo.lock @@ -23,7 +23,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "cc" -version = "1.0.40" +version = "1.0.48" [[package]] name = "cfg-if" @@ -96,7 +96,7 @@ dependencies = [ name = "nitrokey-sys" version = "3.4.3" dependencies = [ - "cc 1.0.40", + "cc 1.0.48", ] [[package]] -- cgit v1.2.1