Remove vendored dependencies

While it appears that by now we actually can get successful builds
without Cargo insisting on Internet access by virtue of using the
--frozen flag, maintaining vendored dependencies is somewhat of a pain
point. This state will also get worse with upcoming changes that replace
argparse in favor of structopt and pull in a slew of new dependencies by
doing so. Then there is also the repository structure aspect, which is
non-standard due to the way we vendor dependencies and a potential
source of confusion.
In order to fix these problems, this change removes all the vendored
dependencies we have.

Delete subrepo argparse/:argparse
Delete subrepo base32/:base32
Delete subrepo cc/:cc
Delete subrepo cfg-if/:cfg-if
Delete subrepo getrandom/:getrandom
Delete subrepo lazy-static/:lazy-static
Delete subrepo libc/:libc
Delete subrepo nitrokey-sys/:nitrokey-sys
Delete subrepo nitrokey/:nitrokey
Delete subrepo rand/:rand

7 files changed, 0 insertions, 4328 deletions

diff --git a/cc/src/bin/gcc-shim.rs b/cc/src/bin/gcc-shim.rs
deleted file mode 100644
index 1731df8..0000000
--- a/cc/src/bin/gcc-shim.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![cfg_attr(test, allow(dead_code))]
-
-use std::env;
-use std::fs::File;
-use std::io::prelude::*;
-use std::path::PathBuf;
-
-fn main() {
-    let mut args = env::args();
-    let program = args.next().expect("Unexpected empty args");
-
-    let out_dir = PathBuf::from(
-        env::var_os("GCCTEST_OUT_DIR").expect(&format!("{}: GCCTEST_OUT_DIR not found", program)),
-    );
-
-    // Find the first nonexistent candidate file to which the program's args can be written.
-    for i in 0.. {
-        let candidate = &out_dir.join(format!("out{}", i));
-
-        // If the file exists, commands have already run. Try again.
-        if candidate.exists() {
-            continue;
-        }
-
-        // Create a file and record the args passed to the command.
-        let mut f = File::create(candidate).expect(&format!(
-            "{}: can't create candidate: {}",
-            program,
-            candidate.to_string_lossy()
-        ));
-        for arg in args {
-            writeln!(f, "{}", arg).expect(&format!(
-                "{}: can't write to candidate: {}",
-                program,
-                candidate.to_string_lossy()
-            ));
-        }
-        break;
-    }
-
-    // Create a file used by some tests.
-    let path = &out_dir.join("libfoo.a");
-    File::create(path).expect(&format!(
-        "{}: can't create libfoo.a: {}",
-        program,
-        path.to_string_lossy()
-    ));
-}
diff --git a/cc/src/com.rs b/cc/src/com.rs
deleted file mode 100644
index a5f2afe..0000000
--- a/cc/src/com.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright © 2017 winapi-rs developers
-// Licensed under the Apache License, Version 2.0
-// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// All files in the project carrying such notice may not be copied, modified, or distributed
-// except according to those terms.
-
-#![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;
-
-pub fn initialize() -> Result<(), HRESULT> {
-    let err = unsafe { CoInitializeEx(null_mut(), COINIT_MULTITHREADED) };
-    if err != S_OK && err != S_FALSE {
-        // S_FALSE just means COM is already initialized
-        return Err(err);
-    }
-    Ok(())
-}
-
-pub struct ComPtr<T>(*mut T)
-where
-    T: Interface;
-impl<T> ComPtr<T>
-where
-    T: Interface,
-{
-    /// Creates a `ComPtr` to wrap a raw pointer.
-    /// It takes ownership over the pointer which means it does __not__ call `AddRef`.
-    /// `T` __must__ be a COM interface that inherits from `IUnknown`.
-    pub unsafe fn from_raw(ptr: *mut T) -> ComPtr<T> {
-        assert!(!ptr.is_null());
-        ComPtr(ptr)
-    }
-    /// Casts up the inheritance chain
-    pub fn up<U>(self) -> ComPtr<U>
-    where
-        T: Deref<Target = U>,
-        U: Interface,
-    {
-        ComPtr(self.into_raw() as *mut U)
-    }
-    /// Extracts the raw pointer.
-    /// You are now responsible for releasing it yourself.
-    pub fn into_raw(self) -> *mut T {
-        let p = self.0;
-        forget(self);
-        p
-    }
-    /// For internal use only.
-    fn as_unknown(&self) -> &IUnknown {
-        unsafe { &*(self.0 as *mut IUnknown) }
-    }
-    /// Performs QueryInterface fun.
-    pub fn cast<U>(&self) -> Result<ComPtr<U>, i32>
-    where
-        U: Interface,
-    {
-        let mut obj = null_mut();
-        let err = unsafe { self.as_unknown().QueryInterface(&U::uuidof(), &mut obj) };
-        if err < 0 {
-            return Err(err);
-        }
-        Ok(unsafe { ComPtr::from_raw(obj as *mut U) })
-    }
-}
-impl<T> Deref for ComPtr<T>
-where
-    T: Interface,
-{
-    type Target = T;
-    fn deref(&self) -> &T {
-        unsafe { &*self.0 }
-    }
-}
-impl<T> Clone for ComPtr<T>
-where
-    T: Interface,
-{
-    fn clone(&self) -> Self {
-        unsafe {
-            self.as_unknown().AddRef();
-            ComPtr::from_raw(self.0)
-        }
-    }
-}
-impl<T> Drop for ComPtr<T>
-where
-    T: Interface,
-{
-    fn drop(&mut self) {
-        unsafe {
-            self.as_unknown().Release();
-        }
-    }
-}
-pub struct BStr(BSTR);
-impl BStr {
-    pub unsafe fn from_raw(s: BSTR) -> BStr {
-        BStr(s)
-    }
-    pub fn to_osstring(&self) -> OsString {
-        let len = unsafe { SysStringLen(self.0) };
-        let slice = unsafe { from_raw_parts(self.0, len as usize) };
-        OsStringExt::from_wide(slice)
-    }
-}
-impl Drop for BStr {
-    fn drop(&mut self) {
-        unsafe { SysFreeString(self.0) };
-    }
-}
-
-pub trait ToWide {
-    fn to_wide(&self) -> Vec<u16>;
-    fn to_wide_null(&self) -> Vec<u16>;
-}
-impl<T> ToWide for T
-where
-    T: AsRef<OsStr>,
-{
-    fn to_wide(&self) -> Vec<u16> {
-        self.as_ref().encode_wide().collect()
-    }
-    fn to_wide_null(&self) -> Vec<u16> {
-        self.as_ref().encode_wide().chain(Some(0)).collect()
-    }
-}
-pub trait FromWide
-where
-    Self: Sized,
-{
-    fn from_wide(wide: &[u16]) -> Self;
-    fn from_wide_null(wide: &[u16]) -> Self {
-        let len = wide.iter().take_while(|&&c| c != 0).count();
-        Self::from_wide(&wide[..len])
-    }
-}
-impl FromWide for OsString {
-    fn from_wide(wide: &[u16]) -> OsString {
-        OsStringExt::from_wide(wide)
-    }
-}
diff --git a/cc/src/lib.rs b/cc/src/lib.rs
deleted file mode 100644
index d795e5a..0000000
--- a/cc/src/lib.rs
+++ /dev/null
@@ -1,2666 +0,0 @@
-//! A library for build scripts to compile custom C code
-//!
-//! This library is intended to be used as a `build-dependencies` entry in
-//! `Cargo.toml`:
-//!
-//! ```toml
-//! [build-dependencies]
-//! cc = "1.0"
-//! ```
-//!
-//! The purpose of this crate is to provide the utility functions necessary to
-//! compile C code into a static archive which is then linked into a Rust crate.
-//! Configuration is available through the `Build` struct.
-//!
-//! This crate will automatically detect situations such as cross compilation or
-//! other environment variables set by Cargo and will build code appropriately.
-//!
-//! The crate is not limited to C code, it can accept any source code that can
-//! be passed to a C or C++ compiler. As such, assembly files with extensions
-//! `.s` (gcc/clang) and `.asm` (MSVC) can also be compiled.
-//!
-//! [`Build`]: struct.Build.html
-//!
-//! # Parallelism
-//!
-//! To parallelize computation, enable the `parallel` feature for the crate.
-//!
-//! ```toml
-//! [build-dependencies]
-//! cc = { version = "1.0", features = ["parallel"] }
-//! ```
-//! To specify the max number of concurrent compilation jobs, set the `NUM_JOBS`
-//! environment variable to the desired amount.
-//!
-//! 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 parallelism.
-//!
-//! # Examples
-//!
-//! Use the `Build` struct to compile `src/foo.c`:
-//!
-//! ```no_run
-//! fn main() {
-//!     cc::Build::new()
-//!         .file("src/foo.c")
-//!         .define("FOO", Some("bar"))
-//!         .include("src")
-//!         .compile("foo");
-//! }
-//! ```
-
-#![doc(html_root_url = "https://docs.rs/cc/1.0")]
-#![cfg_attr(test, deny(warnings))]
-#![allow(deprecated)]
-#![deny(missing_docs)]
-
-use std::collections::HashMap;
-use std::env;
-use std::ffi::{OsStr, OsString};
-use std::fmt::{self, Display};
-use std::fs;
-use std::io::{self, BufRead, BufReader, Read, Write};
-use std::path::{Path, PathBuf};
-use std::process::{Child, Command, Stdio};
-use std::sync::{Arc, Mutex};
-use std::thread::{self, JoinHandle};
-
-// These modules are all glue to support reading the MSVC version from
-// the registry and from COM interfaces
-#[cfg(windows)]
-mod registry;
-#[cfg(windows)]
-#[macro_use]
-mod winapi;
-#[cfg(windows)]
-mod com;
-#[cfg(windows)]
-mod setup_config;
-
-pub mod windows_registry;
-
-/// A builder for compilation of a native static library.
-///
-/// A `Build` is the main type of the `cc` crate and is used to control all the
-/// various configuration options and such of a compile. You'll find more
-/// documentation on each method itself.
-#[derive(Clone, Debug)]
-pub struct Build {
-    include_directories: Vec<PathBuf>,
-    definitions: Vec<(String, Option<String>)>,
-    objects: Vec<PathBuf>,
-    flags: Vec<String>,
-    flags_supported: Vec<String>,
-    known_flag_support_status: Arc<Mutex<HashMap<String, bool>>>,
-    ar_flags: Vec<String>,
-    no_default_flags: bool,
-    files: Vec<PathBuf>,
-    cpp: bool,
-    cpp_link_stdlib: Option<Option<String>>,
-    cpp_set_stdlib: Option<String>,
-    cuda: bool,
-    target: Option<String>,
-    host: Option<String>,
-    out_dir: Option<PathBuf>,
-    opt_level: Option<String>,
-    debug: Option<bool>,
-    force_frame_pointer: Option<bool>,
-    env: Vec<(OsString, OsString)>,
-    compiler: Option<PathBuf>,
-    archiver: Option<PathBuf>,
-    cargo_metadata: bool,
-    pic: Option<bool>,
-    use_plt: Option<bool>,
-    static_crt: Option<bool>,
-    shared_flag: Option<bool>,
-    static_flag: Option<bool>,
-    warnings_into_errors: bool,
-    warnings: Option<bool>,
-    extra_warnings: Option<bool>,
-    env_cache: Arc<Mutex<HashMap<String, Option<String>>>>,
-}
-
-/// Represents the types of errors that may occur while using cc-rs.
-#[derive(Clone, Debug)]
-enum ErrorKind {
-    /// Error occurred while performing I/O.
-    IOError,
-    /// Invalid architecture supplied.
-    ArchitectureInvalid,
-    /// Environment variable not found, with the var in question as extra info.
-    EnvVarNotFound,
-    /// Error occurred while using external tools (ie: invocation of compiler).
-    ToolExecError,
-    /// Error occurred due to missing external tools.
-    ToolNotFound,
-}
-
-/// Represents an internal error that occurred, with an explanation.
-#[derive(Clone, Debug)]
-pub struct Error {
-    /// Describes the kind of error that occurred.
-    kind: ErrorKind,
-    /// More explanation of error that occurred.
-    message: String,
-}
-
-impl Error {
-    fn new(kind: ErrorKind, message: &str) -> Error {
-        Error {
-            kind: kind,
-            message: message.to_owned(),
-        }
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(e: io::Error) -> Error {
-        Error::new(ErrorKind::IOError, &format!("{}", e))
-    }
-}
-
-impl Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}: {}", self.kind, self.message)
-    }
-}
-
-/// Configuration used to represent an invocation of a C compiler.
-///
-/// This can be used to figure out what compiler is in use, what the arguments
-/// to it are, and what the environment variables look like for the compiler.
-/// This can be used to further configure other build systems (e.g. forward
-/// along CC and/or CFLAGS) or the `to_command` method can be used to run the
-/// compiler itself.
-#[derive(Clone, Debug)]
-pub struct Tool {
-    path: PathBuf,
-    cc_wrapper_path: Option<PathBuf>,
-    cc_wrapper_args: Vec<OsString>,
-    args: Vec<OsString>,
-    env: Vec<(OsString, OsString)>,
-    family: ToolFamily,
-    cuda: bool,
-    removed_args: Vec<OsString>,
-}
-
-/// Represents the family of tools this tool belongs to.
-///
-/// Each family of tools differs in how and what arguments they accept.
-///
-/// Detection of a family is done on best-effort basis and may not accurately reflect the tool.
-#[derive(Copy, Clone, Debug, PartialEq)]
-enum ToolFamily {
-    /// Tool is GNU Compiler Collection-like.
-    Gnu,
-    /// Tool is Clang-like. It differs from the GCC in a sense that it accepts superset of flags
-    /// and its cross-compilation approach is different.
-    Clang,
-    /// Tool is the MSVC cl.exe.
-    Msvc { clang_cl: bool },
-}
-
-impl ToolFamily {
-    /// What the flag to request debug info for this family of tools look like
-    fn add_debug_flags(&self, cmd: &mut Tool) {
-        match *self {
-            ToolFamily::Msvc { .. } => {
-                cmd.push_cc_arg("-Z7".into());
-            }
-            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());
-            }
-            _ => (),
-        }
-    }
-
-    /// What the flags to enable all warnings
-    fn warnings_flags(&self) -> &'static str {
-        match *self {
-            ToolFamily::Msvc { .. } => "-W4",
-            ToolFamily::Gnu | ToolFamily::Clang => "-Wall",
-        }
-    }
-
-    /// What the flags to enable extra warnings
-    fn extra_warnings_flags(&self) -> Option<&'static str> {
-        match *self {
-            ToolFamily::Msvc { .. } => None,
-            ToolFamily::Gnu | ToolFamily::Clang => Some("-Wextra"),
-        }
-    }
-
-    /// What the flag to turn warning into errors
-    fn warnings_to_errors_flag(&self) -> &'static str {
-        match *self {
-            ToolFamily::Msvc { .. } => "-WX",
-            ToolFamily::Gnu | ToolFamily::Clang => "-Werror",
-        }
-    }
-
-    fn verbose_stderr(&self) -> bool {
-        *self == ToolFamily::Clang
-    }
-}
-
-/// Represents an object.
-///
-/// This is a source file -> object file pair.
-#[derive(Clone, Debug)]
-struct Object {
-    src: PathBuf,
-    dst: PathBuf,
-}
-
-impl Object {
-    /// Create a new source file -> object file pair.
-    fn new(src: PathBuf, dst: PathBuf) -> Object {
-        Object { src: src, dst: dst }
-    }
-}
-
-impl Build {
-    /// Construct a new instance of a blank set of configuration.
-    ///
-    /// This builder is finished with the [`compile`] function.
-    ///
-    /// [`compile`]: struct.Build.html#method.compile
-    pub fn new() -> Build {
-        Build {
-            include_directories: Vec::new(),
-            definitions: Vec::new(),
-            objects: Vec::new(),
-            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,
-            cpp: false,
-            cpp_link_stdlib: None,
-            cpp_set_stdlib: None,
-            cuda: false,
-            target: None,
-            host: None,
-            out_dir: None,
-            opt_level: None,
-            debug: None,
-            force_frame_pointer: None,
-            env: Vec::new(),
-            compiler: None,
-            archiver: None,
-            cargo_metadata: true,
-            pic: None,
-            use_plt: None,
-            static_crt: None,
-            warnings: None,
-            extra_warnings: None,
-            warnings_into_errors: false,
-            env_cache: Arc::new(Mutex::new(HashMap::new())),
-        }
-    }
-
-    /// Add a directory to the `-I` or include path for headers
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use std::path::Path;
-    ///
-    /// let library_path = Path::new("/path/to/library");
-    ///
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .include(library_path)
-    ///     .include("src")
-    ///     .compile("foo");
-    /// ```
-    pub fn include<P: AsRef<Path>>(&mut self, dir: P) -> &mut Build {
-        self.include_directories.push(dir.as_ref().to_path_buf());
-        self
-    }
-
-    /// Specify a `-D` variable with an optional value.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .define("FOO", "BAR")
-    ///     .define("BAZ", None)
-    ///     .compile("foo");
-    /// ```
-    pub fn define<'a, V: Into<Option<&'a str>>>(&mut self, var: &str, val: V) -> &mut Build {
-        self.definitions
-            .push((var.to_string(), val.into().map(|s| s.to_string())));
-        self
-    }
-
-    /// Add an arbitrary object file to link in
-    pub fn object<P: AsRef<Path>>(&mut self, obj: P) -> &mut Build {
-        self.objects.push(obj.as_ref().to_path_buf());
-        self
-    }
-
-    /// Add an arbitrary flag to the invocation of the compiler
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .flag("-ffunction-sections")
-    ///     .compile("foo");
-    /// ```
-    pub fn flag(&mut self, flag: &str) -> &mut Build {
-        self.flags.push(flag.to_string());
-        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<PathBuf, Error> {
-        let out_dir = self.get_out_dir()?;
-        let src = if self.cuda {
-            assert!(self.cpp);
-            out_dir.join("flag_check.cu")
-        } else if self.cpp {
-            out_dir.join("flag_check.cpp")
-        } else {
-            out_dir.join("flag_check.c")
-        };
-
-        if !src.exists() {
-            let mut f = fs::File::create(&src)?;
-            write!(f, "int main(void) {{ return 0; }}")?;
-        }
-
-        Ok(src)
-    }
-
-    /// Run the compiler to test if it accepts the given flag.
-    ///
-    /// For a convenience method for setting flags conditionally,
-    /// see `flag_if_supported()`.
-    ///
-    /// It may return error if it's unable to run the compilier with a test file
-    /// (e.g. the compiler is missing or a write to the `out_dir` failed).
-    ///
-    /// Note: Once computed, the result of this call is stored in the
-    /// `known_flag_support` field. If `is_flag_supported(flag)`
-    /// is called again, the result will be read from the hash table.
-    pub fn is_flag_supported(&self, flag: &str) -> Result<bool, Error> {
-        let mut known_status = self.known_flag_support_status.lock().unwrap();
-        if let Some(is_supported) = known_status.get(flag).cloned() {
-            return Ok(is_supported);
-        }
-
-        let out_dir = self.get_out_dir()?;
-        let src = self.ensure_check_file()?;
-        let obj = out_dir.join("flag_check");
-        let target = self.get_target()?;
-        let host = self.get_host()?;
-        let mut cfg = Build::new();
-        cfg.flag(flag)
-            .target(&target)
-            .opt_level(0)
-            .host(&host)
-            .debug(false)
-            .cpp(self.cpp)
-            .cuda(self.cuda);
-        let mut compiler = cfg.try_get_compiler()?;
-
-        // Clang uses stderr for verbose output, which yields a false positive
-        // result if the CFLAGS/CXXFLAGS include -v to aid in debugging.
-        if compiler.family.verbose_stderr() {
-            compiler.remove_arg("-v".into());
-        }
-
-        let mut cmd = compiler.to_command();
-        let is_arm = target.contains("aarch64") || target.contains("arm");
-        command_add_output_file(
-            &mut cmd,
-            &obj,
-            self.cuda,
-            target.contains("msvc"),
-            false,
-            is_arm,
-        );
-
-        // We need to explicitly tell msvc not to link and create an exe
-        // in the root directory of the crate
-        if target.contains("msvc") && !self.cuda {
-            cmd.arg("-c");
-        }
-
-        cmd.arg(&src);
-
-        let output = cmd.output()?;
-        let is_supported = output.stderr.is_empty();
-
-        known_status.insert(flag.to_owned(), is_supported);
-        Ok(is_supported)
-    }
-
-    /// Add an arbitrary flag to the invocation of the compiler if it supports it
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .flag_if_supported("-Wlogical-op") // only supported by GCC
-    ///     .flag_if_supported("-Wunreachable-code") // only supported by clang
-    ///     .compile("foo");
-    /// ```
-    pub fn flag_if_supported(&mut self, flag: &str) -> &mut Build {
-        self.flags_supported.push(flag.to_string());
-        self
-    }
-
-    /// Set the `-shared` flag.
-    ///
-    /// When enabled, the compiler will produce a shared object which can
-    /// then be linked with other objects to form an executable.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .shared_flag(true)
-    ///     .compile("libfoo.so");
-    /// ```
-    pub fn shared_flag(&mut self, shared_flag: bool) -> &mut Build {
-        self.shared_flag = Some(shared_flag);
-        self
-    }
-
-    /// Set the `-static` flag.
-    ///
-    /// When enabled on systems that support dynamic linking, this prevents
-    /// linking with the shared libraries.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .shared_flag(true)
-    ///     .static_flag(true)
-    ///     .compile("foo");
-    /// ```
-    pub fn static_flag(&mut self, static_flag: bool) -> &mut Build {
-        self.static_flag = Some(static_flag);
-        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<P: AsRef<Path>>(&mut self, p: P) -> &mut Build {
-        self.files.push(p.as_ref().to_path_buf());
-        self
-    }
-
-    /// Add files which will be compiled
-    pub fn files<P>(&mut self, p: P) -> &mut Build
-    where
-        P: IntoIterator,
-        P::Item: AsRef<Path>,
-    {
-        for file in p.into_iter() {
-            self.file(file);
-        }
-        self
-    }
-
-    /// Set C++ support.
-    ///
-    /// The other `cpp_*` options will only become active if this is set to
-    /// `true`.
-    pub fn cpp(&mut self, cpp: bool) -> &mut Build {
-        self.cpp = cpp;
-        self
-    }
-
-    /// Set CUDA C++ support.
-    ///
-    /// Enabling CUDA will pass the detected C/C++ toolchain as an argument to
-    /// the CUDA compiler, NVCC. NVCC itself accepts some limited GNU-like args;
-    /// any other arguments for the C/C++ toolchain will be redirected using
-    /// "-Xcompiler" flags.
-    ///
-    /// If enabled, this also implicitly enables C++ support.
-    pub fn cuda(&mut self, cuda: bool) -> &mut Build {
-        self.cuda = cuda;
-        if cuda {
-            self.cpp = true;
-        }
-        self
-    }
-
-    /// Set warnings into errors flag.
-    ///
-    /// Disabled by default.
-    ///
-    /// Warning: turning warnings into errors only make sense
-    /// if you are a developer of the crate using cc-rs.
-    /// Some warnings only appear on some architecture or
-    /// specific version of the compiler. Any user of this crate,
-    /// or any other crate depending on it, could fail during
-    /// compile time.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .warnings_into_errors(true)
-    ///     .compile("libfoo.a");
-    /// ```
-    pub fn warnings_into_errors(&mut self, warnings_into_errors: bool) -> &mut Build {
-        self.warnings_into_errors = warnings_into_errors;
-        self
-    }
-
-    /// Set warnings flags.
-    ///
-    /// Adds some flags:
-    /// - "-Wall" for MSVC.
-    /// - "-Wall", "-Wextra" for GNU and Clang.
-    ///
-    /// Enabled by default.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .warnings(false)
-    ///     .compile("libfoo.a");
-    /// ```
-    pub fn warnings(&mut self, warnings: bool) -> &mut Build {
-        self.warnings = Some(warnings);
-        self.extra_warnings = Some(warnings);
-        self
-    }
-
-    /// Set extra warnings flags.
-    ///
-    /// Adds some flags:
-    /// - nothing for MSVC.
-    /// - "-Wextra" for GNU and Clang.
-    ///
-    /// Enabled by default.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// // Disables -Wextra, -Wall remains enabled:
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .extra_warnings(false)
-    ///     .compile("libfoo.a");
-    /// ```
-    pub fn extra_warnings(&mut self, warnings: bool) -> &mut Build {
-        self.extra_warnings = Some(warnings);
-        self
-    }
-
-    /// Set the standard library to link against when compiling with C++
-    /// support.
-    ///
-    /// The default value of this property depends on the current target: On
-    /// OS X `Some("c++")` is used, when compiling for a Visual Studio based
-    /// target `None` is used and for other targets `Some("stdc++")` is used.
-    /// If the `CXXSTDLIB` environment variable is set, its value will
-    /// override the default value.
-    ///
-    /// A value of `None` indicates that no automatic linking should happen,
-    /// otherwise cargo will link against the specified library.
-    ///
-    /// The given library name must not contain the `lib` prefix.
-    ///
-    /// Common values:
-    /// - `stdc++` for GNU
-    /// - `c++` for Clang
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .shared_flag(true)
-    ///     .cpp_link_stdlib("stdc++")
-    ///     .compile("libfoo.so");
-    /// ```
-    pub fn cpp_link_stdlib<'a, V: Into<Option<&'a str>>>(
-        &mut self,
-        cpp_link_stdlib: V,
-    ) -> &mut Build {
-        self.cpp_link_stdlib = Some(cpp_link_stdlib.into().map(|s| s.into()));
-        self
-    }
-
-    /// Force the C++ compiler to use the specified standard library.
-    ///
-    /// Setting this option will automatically set `cpp_link_stdlib` to the same
-    /// value.
-    ///
-    /// The default value of this option is always `None`.
-    ///
-    /// This option has no effect when compiling for a Visual Studio based
-    /// target.
-    ///
-    /// This option sets the `-stdlib` flag, which is only supported by some
-    /// compilers (clang, icc) but not by others (gcc). The library will not
-    /// detect which compiler is used, as such it is the responsibility of the
-    /// caller to ensure that this option is only used in conjuction with a
-    /// compiler which supports the `-stdlib` flag.
-    ///
-    /// A value of `None` indicates that no specific C++ standard library should
-    /// be used, otherwise `-stdlib` is added to the compile invocation.
-    ///
-    /// The given library name must not contain the `lib` prefix.
-    ///
-    /// Common values:
-    /// - `stdc++` for GNU
-    /// - `c++` for Clang
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .cpp_set_stdlib("c++")
-    ///     .compile("libfoo.a");
-    /// ```
-    pub fn cpp_set_stdlib<'a, V: Into<Option<&'a str>>>(
-        &mut self,
-        cpp_set_stdlib: V,
-    ) -> &mut Build {
-        let cpp_set_stdlib = cpp_set_stdlib.into();
-        self.cpp_set_stdlib = cpp_set_stdlib.map(|s| s.into());
-        self.cpp_link_stdlib(cpp_set_stdlib);
-        self
-    }
-
-    /// Configures the target this configuration will be compiling for.
-    ///
-    /// This option is automatically scraped from the `TARGET` environment
-    /// variable by build scripts, so it's not required to call this function.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .target("aarch64-linux-android")
-    ///     .compile("foo");
-    /// ```
-    pub fn target(&mut self, target: &str) -> &mut Build {
-        self.target = Some(target.to_string());
-        self
-    }
-
-    /// Configures the host assumed by this configuration.
-    ///
-    /// This option is automatically scraped from the `HOST` environment
-    /// variable by build scripts, so it's not required to call this function.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// cc::Build::new()
-    ///     .file("src/foo.c")
-    ///     .host("arm-linux-gnueabihf")
-    ///     .compile("foo");
-    /// ```
-    pub fn host(&mut self, host: &str) -> &mut Build {
-        self.host = Some(host.to_string());
-        self
-    }
-
-    /// Configures the optimization level of the generated object files.
-    ///
-    /// This option is automatically scraped from the `OPT_LEVEL` environment
-    /// variable by build scripts, so it's not required to call this function.
-    pub fn opt_level(&mut self, opt_level: u32) -> &mut Build {
-        self.opt_level = Some(opt_level.to_string());
-        self
-    }
-
-    /// Configures the optimization level of the generated object files.
-    ///
-    /// This option is automatically scraped from the `OPT_LEVEL` environment
-    /// variable by build scripts, so it's not required to call this function.
-    pub fn opt_level_str(&mut self, opt_level: &str) -> &mut Build {
-        self.opt_level = Some(opt_level.to_string());
-        self
-    }
-
-    /// Configures whether the compiler will emit debug information when
-    /// generating object files.
-    ///
-    /// This option is automatically scraped from the `DEBUG` environment
-    /// variable by build scripts, so it's not required to call this function.
-    pub fn debug(&mut self, debug: bool) -> &mut Build {
-        self.debug = Some(debug);
-        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.
-    ///
-    /// This option is automatically scraped from the `OUT_DIR` environment
-    /// variable by build scripts, so it's not required to call this function.
-    pub fn out_dir<P: AsRef<Path>>(&mut self, out_dir: P) -> &mut Build {
-        self.out_dir = Some(out_dir.as_ref().to_owned());
-        self
-    }
-
-    /// Configures the compiler to be used to produce output.
-    ///
-    /// This option is automatically determined from the target platform or a
-    /// number of environment variables, so it's not required to call this
-    /// function.
-    pub fn compiler<P: AsRef<Path>>(&mut self, compiler: P) -> &mut Build {
-        self.compiler = Some(compiler.as_ref().to_owned());
-        self
-    }
-
-    /// Configures the tool used to assemble archives.
-    ///
-    /// This option is automatically determined from the target platform or a
-    /// number of environment variables, so it's not required to call this
-    /// function.
-    pub fn archiver<P: AsRef<Path>>(&mut self, archiver: P) -> &mut Build {
-        self.archiver = Some(archiver.as_ref().to_owned());
-        self
-    }
-    /// Define whether metadata should be emitted for cargo allowing it to
-    /// automatically link the binary. Defaults to `true`.
-    ///
-    /// The emitted metadata is:
-    ///
-    ///  - `rustc-link-lib=static=`*compiled lib*
-    ///  - `rustc-link-search=native=`*target folder*
-    ///  - When target is MSVC, the ATL-MFC libs are added via `rustc-link-search=native=`
-    ///  - When C++ is enabled, the C++ stdlib is added via `rustc-link-lib`
-    ///
-    pub fn cargo_metadata(&mut self, cargo_metadata: bool) -> &mut Build {
-        self.cargo_metadata = cargo_metadata;
-        self
-    }
-
-    /// Configures whether the compiler will emit position independent code.
-    ///
-    /// This option defaults to `false` for `windows-gnu` and `riscv` targets and
-    /// to `true` for all other targets.
-    pub fn pic(&mut self, pic: bool) -> &mut Build {
-        self.pic = Some(pic);
-        self
-    }
-
-    /// Configures whether the Procedure Linkage Table is used for indirect
-    /// calls into shared libraries.
-    ///
-    /// The PLT is used to provide features like lazy binding, but introduces
-    /// a small performance loss due to extra pointer indirection. Setting
-    /// `use_plt` to `false` can provide a small performance increase.
-    ///
-    /// Note that skipping the PLT requires a recent version of GCC/Clang.
-    ///
-    /// This only applies to ELF targets. It has no effect on other platforms.
-    pub fn use_plt(&mut self, use_plt: bool) -> &mut Build {
-        self.use_plt = Some(use_plt);
-        self
-    }
-
-    /// Configures whether the /MT flag or the /MD flag will be passed to msvc build tools.
-    ///
-    /// This option defaults to `false`, and affect only msvc targets.
-    pub fn static_crt(&mut self, static_crt: bool) -> &mut Build {
-        self.static_crt = Some(static_crt);
-        self
-    }
-
-    #[doc(hidden)]
-    pub fn __set_env<A, B>(&mut self, a: A, b: B) -> &mut Build
-    where
-        A: AsRef<OsStr>,
-        B: AsRef<OsStr>,
-    {
-        self.env
-            .push((a.as_ref().to_owned(), b.as_ref().to_owned()));
-        self
-    }
-
-    /// Run the compiler, generating the file `output`
-    ///
-    /// This will return a result instead of panicing; see compile() for the complete description.
-    pub fn try_compile(&self, output: &str) -> Result<(), Error> {
-        let (lib_name, gnu_lib_name) = if output.starts_with("lib") && output.ends_with(".a") {
-            (&output[3..output.len() - 2], output.to_owned())
-        } else {
-            let mut gnu = String::with_capacity(5 + output.len());
-            gnu.push_str("lib");
-            gnu.push_str(&output);
-            gnu.push_str(".a");
-            (output, gnu)
-        };
-        let dst = self.get_out_dir()?;
-
-        let mut objects = Vec::new();
-        for file in self.files.iter() {
-            let obj = dst.join(file).with_extension("o");
-            let obj = if !obj.starts_with(&dst) {
-                dst.join(obj.file_name().ok_or_else(|| {
-                    Error::new(ErrorKind::IOError, "Getting object file details failed.")
-                })?)
-            } else {
-                obj
-            };
-
-            match obj.parent() {
-                Some(s) => fs::create_dir_all(s)?,
-                None => {
-                    return Err(Error::new(
-                        ErrorKind::IOError,
-                        "Getting object file details failed.",
-                    ));
-                }
-            };
-
-            objects.push(Object::new(file.to_path_buf(), obj));
-        }
-        self.compile_objects(&objects)?;
-        self.assemble(lib_name, &dst.join(gnu_lib_name), &objects)?;
-
-        if self.get_target()?.contains("msvc") {
-            let compiler = self.get_base_compiler()?;
-            let atlmfc_lib = compiler
-                .env()
-                .iter()
-                .find(|&&(ref var, _)| var.as_os_str() == OsStr::new("LIB"))
-                .and_then(|&(_, ref lib_paths)| {
-                    env::split_paths(lib_paths).find(|path| {
-                        let sub = Path::new("atlmfc/lib");
-                        path.ends_with(sub) || path.parent().map_or(false, |p| p.ends_with(sub))
-                    })
-                });
-
-            if let Some(atlmfc_lib) = atlmfc_lib {
-                self.print(&format!(
-                    "cargo:rustc-link-search=native={}",
-                    atlmfc_lib.display()
-                ));
-            }
-        }
-
-        self.print(&format!("cargo:rustc-link-lib=static={}", lib_name));
-        self.print(&format!("cargo:rustc-link-search=native={}", dst.display()));
-
-        // Add specific C++ libraries, if enabled.
-        if self.cpp {
-            if let Some(stdlib) = self.get_cpp_link_stdlib()? {
-                self.print(&format!("cargo:rustc-link-lib={}", stdlib));
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Run the compiler, generating the file `output`
-    ///
-    /// The name `output` should be the name of the library.  For backwards compatibility,
-    /// the `output` may start with `lib` and end with `.a`.  The Rust compilier will create
-    /// the assembly with the lib prefix and .a extension.  MSVC will create a file without prefix,
-    /// ending with `.lib`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `output` is not formatted correctly or if one of the underlying
-    /// compiler commands fails. It can also panic if it fails reading file names
-    /// or creating directories.
-    pub fn compile(&self, output: &str) {
-        if let Err(e) = self.try_compile(output) {
-            fail(&e.message);
-        }
-    }
-
-    #[cfg(feature = "parallel")]
-    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, State<'static>>(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)));
-        }
-
-        for mut thread in threads {
-            if let Some(thread) = thread.0.take() {
-                thread.join().expect("thread should not panic")?;
-            }
-        }
-
-        // 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<jobserver::Client> = None;
-
-            fn _assert_sync<T: Sync>() {}
-            _assert_sync::<jobserver::Client>();
-
-            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<thread::JoinHandle<Result<(), Error>>>);
-
-        impl Drop for JoinOnDrop {
-            fn drop(&mut self) {
-                if let Some(thread) = self.0.take() {
-                    drop(thread.join());
-                }
-            }
-        }
-    }
-
-    #[cfg(not(feature = "parallel"))]
-    fn compile_objects(&self, objs: &[Object]) -> Result<(), Error> {
-        for obj in objs {
-            self.compile_object(obj)?;
-        }
-        Ok(())
-    }
-
-    fn compile_object(&self, obj: &Object) -> Result<(), Error> {
-        let is_asm = obj.src.extension().and_then(|s| s.to_str()) == Some("asm");
-        let target = self.get_target()?;
-        let msvc = target.contains("msvc");
-        let (mut cmd, name) = if msvc && is_asm {
-            self.msvc_macro_assembler()?
-        } else {
-            let compiler = self.try_get_compiler()?;
-            let mut cmd = compiler.to_command();
-            for &(ref a, ref b) in self.env.iter() {
-                cmd.env(a, b);
-            }
-            (
-                cmd,
-                compiler
-                    .path
-                    .file_name()
-                    .ok_or_else(|| Error::new(ErrorKind::IOError, "Failed to get compiler path."))?
-                    .to_string_lossy()
-                    .into_owned(),
-            )
-        };
-        let is_arm = target.contains("aarch64") || target.contains("arm");
-        command_add_output_file(&mut cmd, &obj.dst, self.cuda, msvc, is_asm, is_arm);
-        // armasm and armasm64 don't requrie -c option
-        if !msvc || !is_asm || !is_arm {
-            cmd.arg("-c");
-        }
-        cmd.arg(&obj.src);
-
-        run(&mut cmd, &name)?;
-        Ok(())
-    }
-
-    /// This will return a result instead of panicing; see expand() for the complete description.
-    pub fn try_expand(&self) -> Result<Vec<u8>, Error> {
-        let compiler = self.try_get_compiler()?;
-        let mut cmd = compiler.to_command();
-        for &(ref a, ref b) in self.env.iter() {
-            cmd.env(a, b);
-        }
-        cmd.arg("-E");
-
-        assert!(
-            self.files.len() <= 1,
-            "Expand may only be called for a single file"
-        );
-
-        for file in self.files.iter() {
-            cmd.arg(file);
-        }
-
-        let name = compiler
-            .path
-            .file_name()
-            .ok_or_else(|| Error::new(ErrorKind::IOError, "Failed to get compiler path."))?
-            .to_string_lossy()
-            .into_owned();
-
-        Ok(run_output(&mut cmd, &name)?)
-    }
-
-    /// Run the compiler, returning the macro-expanded version of the input files.
-    ///
-    /// This is only relevant for C and C++ files.
-    ///
-    /// # Panics
-    /// Panics if more than one file is present in the config, or if compiler
-    /// path has an invalid file name.
-    ///
-    /// # Example
-    /// ```no_run
-    /// let out = cc::Build::new().file("src/foo.c").expand();
-    /// ```
-    pub fn expand(&self) -> Vec<u8> {
-        match self.try_expand() {
-            Err(e) => fail(&e.message),
-            Ok(v) => v,
-        }
-    }
-
-    /// Get the compiler that's in use for this configuration.
-    ///
-    /// This function will return a `Tool` which represents the culmination
-    /// of this configuration at a snapshot in time. The returned compiler can
-    /// be inspected (e.g. the path, arguments, environment) to forward along to
-    /// other tools, or the `to_command` method can be used to invoke the
-    /// compiler itself.
-    ///
-    /// This method will take into account all configuration such as debug
-    /// information, optimization level, include directories, defines, etc.
-    /// Additionally, the compiler binary in use follows the standard
-    /// conventions for this path, e.g. looking at the explicitly set compiler,
-    /// environment variables (a number of which are inspected here), and then
-    /// falling back to the default configuration.
-    ///
-    /// # Panics
-    ///
-    /// Panics if an error occurred while determining the architecture.
-    pub fn get_compiler(&self) -> Tool {
-        match self.try_get_compiler() {
-            Ok(tool) => tool,
-            Err(e) => fail(&e.message),
-        }
-    }
-
-    /// Get the compiler that's in use for this configuration.
-    ///
-    /// This will return a result instead of panicing; see get_compiler() for the complete description.
-    pub fn try_get_compiler(&self) -> Result<Tool, Error> {
-        let opt_level = self.get_opt_level()?;
-        let target = self.get_target()?;
-
-        let mut cmd = self.get_base_compiler()?;
-        let envflags = self.envflags(if self.cpp { "CXXFLAGS" } else { "CFLAGS" });
-
-        // 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 !no_defaults {
-            self.add_default_flags(&mut cmd, &target, &opt_level)?;
-        } else {
-            println!("Info: default compiler flags are disabled");
-        }
-
-        for arg in envflags {
-            cmd.push_cc_arg(arg.into());
-        }
-
-        for directory in self.include_directories.iter() {
-            cmd.args.push("-I".into());
-            cmd.args.push(directory.into());
-        }
-
-        // If warnings and/or extra_warnings haven't been explicitly set,
-        // then we set them only if the environment doesn't already have
-        // CFLAGS/CXXFLAGS, since those variables presumably already contain
-        // the desired set of warnings flags.
-
-        if self
-            .warnings
-            .unwrap_or(if self.has_flags() { false } else { true })
-        {
-            let wflags = cmd.family.warnings_flags().into();
-            cmd.push_cc_arg(wflags);
-        }
-
-        if self
-            .extra_warnings
-            .unwrap_or(if self.has_flags() { false } else { true })
-        {
-            if let Some(wflags) = cmd.family.extra_warnings_flags() {
-                cmd.push_cc_arg(wflags.into());
-            }
-        }
-
-        for flag in self.flags.iter() {
-            cmd.args.push(flag.into());
-        }
-
-        for flag in self.flags_supported.iter() {
-            if self.is_flag_supported(flag).unwrap_or(false) {
-                cmd.push_cc_arg(flag.into());
-            }
-        }
-
-        for &(ref key, ref value) in self.definitions.iter() {
-            if let Some(ref value) = *value {
-                cmd.args.push(format!("-D{}={}", key, value).into());
-            } else {
-                cmd.args.push(format!("-D{}", key).into());
-            }
-        }
-
-        if self.warnings_into_errors {
-            let warnings_to_errors_flag = cmd.family.warnings_to_errors_flag().into();
-            cmd.push_cc_arg(warnings_to_errors_flag);
-        }
-
-        Ok(cmd)
-    }
-
-    fn add_default_flags(
-        &self,
-        cmd: &mut Tool,
-        target: &str,
-        opt_level: &str,
-    ) -> Result<(), Error> {
-        // Non-target flags
-        // If the flag is not conditioned on target variable, it belongs here :)
-        match cmd.family {
-            ToolFamily::Msvc { .. } => {
-                cmd.push_cc_arg("-nologo".into());
-
-                let crt_flag = match self.static_crt {
-                    Some(true) => "-MT",
-                    Some(false) => "-MD",
-                    None => {
-                        let features = self
-                            .getenv("CARGO_CFG_TARGET_FEATURE")
-                            .unwrap_or(String::new());
-                        if features.contains("crt-static") {
-                            "-MT"
-                        } else {
-                            "-MD"
-                        }
-                    }
-                };
-                cmd.push_cc_arg(crt_flag.into());
-
-                match &opt_level[..] {
-                    // Msvc uses /O1 to enable all optimizations that minimize code size.
-                    "z" | "s" | "1" => cmd.push_opt_unless_duplicate("-O1".into()),
-                    // -O3 is a valid value for gcc and clang compilers, but not msvc. Cap to /O2.
-                    "2" | "3" => cmd.push_opt_unless_duplicate("-O2".into()),
-                    _ => {}
-                }
-            }
-            ToolFamily::Gnu | ToolFamily::Clang => {
-                // arm-linux-androideabi-gcc 4.8 shipped with Android NDK does
-                // not support '-Oz'
-                if opt_level == "z" && cmd.family != ToolFamily::Clang {
-                    cmd.push_opt_unless_duplicate("-Os".into());
-                } else {
-                    cmd.push_opt_unless_duplicate(format!("-O{}", opt_level).into());
-                }
-
-                if !target.contains("-ios") {
-                    cmd.push_cc_arg("-ffunction-sections".into());
-                    cmd.push_cc_arg("-fdata-sections".into());
-                }
-                // Disable generation of PIC on RISC-V for now: rust-lld doesn't support this yet
-                if self
-                    .pic
-                    .unwrap_or(!target.contains("windows-gnu") && !target.contains("riscv"))
-                {
-                    cmd.push_cc_arg("-fPIC".into());
-                    // PLT only applies if code is compiled with PIC support,
-                    // and only for ELF targets.
-                    if target.contains("linux") && !self.use_plt.unwrap_or(true) {
-                        cmd.push_cc_arg("-fno-plt".into());
-                    }
-                }
-            }
-        }
-
-        if self.get_debug() {
-            if self.cuda {
-                // NVCC debug flag
-                cmd.args.push("-G".into());
-            }
-            let family = cmd.family;
-            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());
-                    } else if target.contains("86") {
-                        cmd.args.push("-m32".into());
-                        cmd.push_cc_arg("-arch:IA32".into());
-                    } else {
-                        cmd.push_cc_arg(format!("--target={}", target).into());
-                    }
-                } else {
-                    if target.contains("i586") {
-                        cmd.push_cc_arg("-arch:IA32".into());
-                    }
-                }
-
-                // There is a check in corecrt.h that will generate a
-                // compilation error if
-                // _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE is
-                // not defined to 1. The check was added in Windows
-                // 8 days because only store apps were allowed on ARM.
-                // This changed with the release of Windows 10 IoT Core.
-                // The check will be going away in future versions of
-                // the SDK, but for all released versions of the
-                // Windows SDK it is required.
-                if target.contains("arm") || target.contains("thumb") {
-                    cmd.args
-                        .push("-D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1".into());
-                }
-            }
-            ToolFamily::Gnu => {
-                if target.contains("i686") || target.contains("i586") {
-                    cmd.args.push("-m32".into());
-                } else if target == "x86_64-unknown-linux-gnux32" {
-                    cmd.args.push("-mx32".into());
-                } else if target.contains("x86_64") || target.contains("powerpc64") {
-                    cmd.args.push("-m64".into());
-                }
-
-                if self.static_flag.is_none() {
-                    let features = self
-                        .getenv("CARGO_CFG_TARGET_FEATURE")
-                        .unwrap_or(String::new());
-                    if features.contains("crt-static") {
-                        cmd.args.push("-static".into());
-                    }
-                }
-
-                // armv7 targets get to use armv7 instructions
-                if (target.starts_with("armv7") || target.starts_with("thumbv7"))
-                    && target.contains("-linux-")
-                {
-                    cmd.args.push("-march=armv7-a".into());
-                }
-
-                // (x86 Android doesn't say "eabi")
-                if target.contains("-androideabi") && target.contains("v7") {
-                    // -march=armv7-a handled above
-                    cmd.args.push("-mthumb".into());
-                    if !target.contains("neon") {
-                        // On android we can guarantee some extra float instructions
-                        // (specified in the android spec online)
-                        // NEON guarantees even more; see below.
-                        cmd.args.push("-mfpu=vfpv3-d16".into());
-                    }
-                    cmd.args.push("-mfloat-abi=softfp".into());
-                }
-
-                if target.contains("neon") {
-                    cmd.args.push("-mfpu=neon-vfpv4".into());
-                }
-
-                if target.starts_with("armv4t-unknown-linux-") {
-                    cmd.args.push("-march=armv4t".into());
-                    cmd.args.push("-marm".into());
-                    cmd.args.push("-mfloat-abi=soft".into());
-                }
-
-                if target.starts_with("armv5te-unknown-linux-") {
-                    cmd.args.push("-march=armv5te".into());
-                    cmd.args.push("-marm".into());
-                    cmd.args.push("-mfloat-abi=soft".into());
-                }
-
-                // For us arm == armv6 by default
-                if target.starts_with("arm-unknown-linux-") {
-                    cmd.args.push("-march=armv6".into());
-                    cmd.args.push("-marm".into());
-                    if target.ends_with("hf") {
-                        cmd.args.push("-mfpu=vfp".into());
-                    } else {
-                        cmd.args.push("-mfloat-abi=soft".into());
-                    }
-                }
-
-                // We can guarantee some settings for FRC
-                if target.starts_with("arm-frc-") {
-                    cmd.args.push("-march=armv7-a".into());
-                    cmd.args.push("-mcpu=cortex-a9".into());
-                    cmd.args.push("-mfpu=vfpv3".into());
-                    cmd.args.push("-mfloat-abi=softfp".into());
-                    cmd.args.push("-marm".into());
-                }
-
-                // Turn codegen down on i586 to avoid some instructions.
-                if target.starts_with("i586-unknown-linux-") {
-                    cmd.args.push("-march=pentium".into());
-                }
-
-                // Set codegen level for i686 correctly
-                if target.starts_with("i686-unknown-linux-") {
-                    cmd.args.push("-march=i686".into());
-                }
-
-                // Looks like `musl-gcc` makes is hard for `-m32` to make its way
-                // all the way to the linker, so we need to actually instruct the
-                // linker that we're generating 32-bit executables as well. This'll
-                // typically only be used for build scripts which transitively use
-                // these flags that try to compile executables.
-                if target == "i686-unknown-linux-musl" || target == "i586-unknown-linux-musl" {
-                    cmd.args.push("-Wl,-melf_i386".into());
-                }
-
-                if target.starts_with("thumb") {
-                    cmd.args.push("-mthumb".into());
-
-                    if target.ends_with("eabihf") {
-                        cmd.args.push("-mfloat-abi=hard".into())
-                    }
-                }
-                if target.starts_with("thumbv6m") {
-                    cmd.args.push("-march=armv6s-m".into());
-                }
-                if target.starts_with("thumbv7em") {
-                    cmd.args.push("-march=armv7e-m".into());
-
-                    if target.ends_with("eabihf") {
-                        cmd.args.push("-mfpu=fpv4-sp-d16".into())
-                    }
-                }
-                if target.starts_with("thumbv7m") {
-                    cmd.args.push("-march=armv7-m".into());
-                }
-                if target.starts_with("thumbv8m.base") {
-                    cmd.args.push("-march=armv8-m.base".into());
-                }
-                if target.starts_with("thumbv8m.main") {
-                    cmd.args.push("-march=armv8-m.main".into());
-
-                    if target.ends_with("eabihf") {
-                        cmd.args.push("-mfpu=fpv5-sp-d16".into())
-                    }
-                }
-                if target.starts_with("armebv7r") | target.starts_with("armv7r") {
-                    if target.starts_with("armeb") {
-                        cmd.args.push("-mbig-endian".into());
-                    } else {
-                        cmd.args.push("-mlittle-endian".into());
-                    }
-
-                    // ARM mode
-                    cmd.args.push("-marm".into());
-
-                    // R Profile
-                    cmd.args.push("-march=armv7-r".into());
-
-                    if target.ends_with("eabihf") {
-                        // Calling convention
-                        cmd.args.push("-mfloat-abi=hard".into());
-
-                        // lowest common denominator FPU
-                        // (see Cortex-R4 technical reference manual)
-                        cmd.args.push("-mfpu=vfpv3-d16".into())
-                    } else {
-                        // Calling convention
-                        cmd.args.push("-mfloat-abi=soft".into());
-                    }
-                }
-                if target.starts_with("riscv32") || target.starts_with("riscv64") {
-                    // get the 32i/32imac/32imc/64gc/64imac/... part
-                    let mut parts = target.split('-');
-                    if let Some(arch) = parts.next() {
-                        let arch = &arch[5..];
-                        cmd.args.push(("-march=rv".to_owned() + arch).into());
-                        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());
-                        }
-                    }
-                }
-            }
-        }
-
-        if target.contains("-ios") {
-            // FIXME: potential bug. iOS is always compiled with Clang, but Gcc compiler may be
-            // detected instead.
-            self.ios_flags(cmd)?;
-        }
-
-        if self.static_flag.unwrap_or(false) {
-            cmd.args.push("-static".into());
-        }
-        if self.shared_flag.unwrap_or(false) {
-            cmd.args.push("-shared".into());
-        }
-
-        if self.cpp {
-            match (self.cpp_set_stdlib.as_ref(), cmd.family) {
-                (None, _) => {}
-                (Some(stdlib), ToolFamily::Gnu) | (Some(stdlib), ToolFamily::Clang) => {
-                    cmd.push_cc_arg(format!("-stdlib=lib{}", stdlib).into());
-                }
-                _ => {
-                    println!(
-                        "cargo:warning=cpp_set_stdlib is specified, but the {:?} compiler \
-                         does not support this option, ignored",
-                        cmd.family
-                    );
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    fn has_flags(&self) -> bool {
-        let flags_env_var_name = if self.cpp { "CXXFLAGS" } else { "CFLAGS" };
-        let flags_env_var_value = self.get_var(flags_env_var_name);
-        if let Ok(_) = flags_env_var_value {
-            true
-        } else {
-            false
-        }
-    }
-
-    fn msvc_macro_assembler(&self) -> Result<(Command, String), Error> {
-        let target = self.get_target()?;
-        let tool = if target.contains("x86_64") {
-            "ml64.exe"
-        } else if target.contains("arm") {
-            "armasm.exe"
-        } else if target.contains("aarch64") {
-            "armasm64.exe"
-        } else {
-            "ml.exe"
-        };
-        let mut cmd = windows_registry::find(&target, tool).unwrap_or_else(|| self.cmd(tool));
-        for directory in self.include_directories.iter() {
-            cmd.arg("-I").arg(directory);
-        }
-        for &(ref key, ref value) in self.definitions.iter() {
-            if let Some(ref value) = *value {
-                cmd.arg(&format!("-D{}={}", key, value));
-            } else {
-                cmd.arg(&format!("-D{}", key));
-            }
-        }
-
-        if target.contains("i686") || target.contains("i586") {
-            cmd.arg("-safeseh");
-        }
-        for flag in self.flags.iter() {
-            cmd.arg(flag);
-        }
-
-        Ok((cmd, tool.to_string()))
-    }
-
-    fn assemble(&self, lib_name: &str, dst: &Path, objs: &[Object]) -> Result<(), Error> {
-        // Delete the destination if it exists as the `ar` tool at least on Unix
-        // appends to it, which we don't want.
-        let _ = fs::remove_file(&dst);
-
-        let objects: Vec<_> = objs.iter().map(|obj| obj.dst.clone()).collect();
-        let target = self.get_target()?;
-        if target.contains("msvc") {
-            let (mut cmd, program) = self.get_ar()?;
-            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
-            let estimated_command_line_len = objects
-                .iter()
-                .chain(&self.objects)
-                .map(|a| a.as_os_str().len())
-                .sum::<usize>();
-            if estimated_command_line_len > 1024 * 6 {
-                let mut args = String::from("\u{FEFF}"); // BOM
-                for arg in objects.iter().chain(&self.objects) {
-                    args.push('"');
-                    for c in arg.to_str().unwrap().chars() {
-                        if c == '"' {
-                            args.push('\\')
-                        }
-                        args.push(c)
-                    }
-                    args.push('"');
-                    args.push('\n');
-                }
-
-                let mut utf16le = Vec::new();
-                for code_unit in args.encode_utf16() {
-                    utf16le.push(code_unit as u8);
-                    utf16le.push((code_unit >> 8) as u8);
-                }
-
-                let mut args_file = OsString::from(dst);
-                args_file.push(".args");
-                fs::File::create(&args_file)
-                    .unwrap()
-                    .write_all(&utf16le)
-                    .unwrap();
-
-                let mut args_file_arg = OsString::from("@");
-                args_file_arg.push(args_file);
-                cmd.arg(args_file_arg);
-            } else {
-                cmd.args(&objects).args(&self.objects);
-            }
-            run(&mut cmd, &program)?;
-
-            // The Rust compiler will look for libfoo.a and foo.lib, but the
-            // MSVC linker will also be passed foo.lib, so be sure that both
-            // exist for now.
-            let lib_dst = dst.with_file_name(format!("{}.lib", lib_name));
-            let _ = fs::remove_file(&lib_dst);
-            match fs::hard_link(&dst, &lib_dst).or_else(|_| {
-                // if hard-link fails, just copy (ignoring the number of bytes written)
-                fs::copy(&dst, &lib_dst).map(|_| ())
-            }) {
-                Ok(_) => (),
-                Err(_) => {
-                    return Err(Error::new(
-                        ErrorKind::IOError,
-                        "Could not copy or create a hard-link to the generated lib file.",
-                    ));
-                }
-            };
-        } 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,
-            )?;
-        }
-
-        Ok(())
-    }
-
-    fn ios_flags(&self, cmd: &mut Tool) -> Result<(), Error> {
-        enum ArchSpec {
-            Device(&'static str),
-            Simulator(&'static str),
-        }
-
-        let target = self.get_target()?;
-        let arch = target.split('-').nth(0).ok_or_else(|| {
-            Error::new(
-                ErrorKind::ArchitectureInvalid,
-                "Unknown architecture for iOS target.",
-            )
-        })?;
-        let arch = match arch {
-            "arm" | "armv7" | "thumbv7" => ArchSpec::Device("armv7"),
-            "armv7s" | "thumbv7s" => ArchSpec::Device("armv7s"),
-            "arm64" | "aarch64" => ArchSpec::Device("arm64"),
-            "i386" | "i686" => ArchSpec::Simulator("-m32"),
-            "x86_64" => ArchSpec::Simulator("-m64"),
-            _ => {
-                return Err(Error::new(
-                    ErrorKind::ArchitectureInvalid,
-                    "Unknown architecture for iOS target.",
-                ));
-            }
-        };
-
-        let min_version =
-            std::env::var("IPHONEOS_DEPLOYMENT_TARGET").unwrap_or_else(|_| "7.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"
-            }
-            ArchSpec::Simulator(arch) => {
-                cmd.args.push(arch.into());
-                cmd.args
-                    .push(format!("-mios-simulator-version-min={}", min_version).into());
-                "iphonesimulator"
-            }
-        };
-
-        self.print(&format!("Detecting iOS SDK path for {}", sdk));
-        let sdk_path = self
-            .cmd("xcrun")
-            .arg("--show-sdk-path")
-            .arg("--sdk")
-            .arg(sdk)
-            .stderr(Stdio::inherit())
-            .output()?
-            .stdout;
-
-        let sdk_path = match String::from_utf8(sdk_path) {
-            Ok(p) => p,
-            Err(_) => {
-                return Err(Error::new(
-                    ErrorKind::IOError,
-                    "Unable to determine iOS SDK path.",
-                ));
-            }
-        };
-
-        cmd.args.push("-isysroot".into());
-        cmd.args.push(sdk_path.trim().into());
-        cmd.args.push("-fembed-bitcode".into());
-        /*
-         * TODO we probably ultimatedly want the -fembed-bitcode-marker flag
-         * but can't have it now because of an issue in LLVM:
-         * https://github.com/alexcrichton/cc-rs/issues/301
-         * https://github.com/rust-lang/rust/pull/48896#comment-372192660
-         */
-        /*
-        if self.get_opt_level()? == "0" {
-            cmd.args.push("-fembed-bitcode-marker".into());
-        }
-        */
-
-        Ok(())
-    }
-
-    fn cmd<P: AsRef<OsStr>>(&self, prog: P) -> Command {
-        let mut cmd = Command::new(prog);
-        for &(ref a, ref b) in self.env.iter() {
-            cmd.env(a, b);
-        }
-        cmd
-    }
-
-    fn get_base_compiler(&self) -> Result<Tool, Error> {
-        if let Some(ref c) = self.compiler {
-            return Ok(Tool::new(c.clone()));
-        }
-        let host = self.get_host()?;
-        let target = self.get_target()?;
-        let (env, msvc, gnu, traditional, clang) = if self.cpp {
-            ("CXX", "cl.exe", "g++", "c++", "clang++")
-        } else {
-            ("CC", "cl.exe", "gcc", "cc", "clang")
-        };
-
-        // On Solaris, c++/cc unlikely to exist or be correct.
-        let default = if host.contains("solaris") {
-            gnu
-        } else {
-            traditional
-        };
-
-        let cl_exe = windows_registry::find_tool(&target, "cl.exe");
-
-        let tool_opt: Option<Tool> = self
-            .env_tool(env)
-            .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::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 {
-                    t.cc_wrapper_args.push(arg.into());
-                }
-                t
-            })
-            .or_else(|| {
-                if target.contains("emscripten") {
-                    let tool = if self.cpp { "em++" } else { "emcc" };
-                    // Windows uses bat file so we have to be a bit more specific
-                    if cfg!(windows) {
-                        let mut t = Tool::new(PathBuf::from("cmd"));
-                        t.args.push("/c".into());
-                        t.args.push(format!("{}.bat", tool).into());
-                        Some(t)
-                    } else {
-                        Some(Tool::new(PathBuf::from(tool)))
-                    }
-                } else {
-                    None
-                }
-            })
-            .or_else(|| cl_exe.clone());
-
-        let tool = match tool_opt {
-            Some(t) => t,
-            None => {
-                let compiler = if host.contains("windows") && target.contains("windows") {
-                    if target.contains("msvc") {
-                        msvc.to_string()
-                    } else {
-                        format!("{}.exe", gnu)
-                    }
-                } else if target.contains("android") {
-                    let target = target
-                        .replace("armv7neon", "arm")
-                        .replace("armv7", "arm")
-                        .replace("thumbv7neon", "arm")
-                        .replace("thumbv7", "arm");
-                    let gnu_compiler = format!("{}-{}", target, gnu);
-                    let clang_compiler = format!("{}-{}", target, clang);
-                    // Check if gnu compiler is present
-                    // if not, use clang
-                    if Command::new(&gnu_compiler).spawn().is_ok() {
-                        gnu_compiler
-                    } else {
-                        clang_compiler
-                    }
-                } else if target.contains("cloudabi") {
-                    format!("{}-{}", target, traditional)
-                } else if target == "wasm32-wasi"
-                    || target == "wasm32-unknown-wasi"
-                    || target == "wasm32-unknown-unknown"
-                {
-                    "clang".to_string()
-                } else if target.contains("vxworks") {
-                    "wr-c++".to_string()
-                } else if self.get_host()? != target {
-                    // CROSS_COMPILE is of the form: "arm-linux-gnueabi-"
-                    let cc_env = self.getenv("CROSS_COMPILE");
-                    let cross_compile = cc_env.as_ref().map(|s| s.trim_right_matches('-'));
-                    let prefix = cross_compile.or(match &target[..] {
-                        "aarch64-unknown-linux-gnu" => Some("aarch64-linux-gnu"),
-                        "aarch64-unknown-linux-musl" => Some("aarch64-linux-musl"),
-                        "aarch64-unknown-netbsd" => Some("aarch64--netbsd"),
-                        "arm-unknown-linux-gnueabi" => Some("arm-linux-gnueabi"),
-                        "armv4t-unknown-linux-gnueabi" => Some("arm-linux-gnueabi"),
-                        "armv5te-unknown-linux-gnueabi" => Some("arm-linux-gnueabi"),
-                        "arm-frc-linux-gnueabi" => Some("arm-frc-linux-gnueabi"),
-                        "arm-unknown-linux-gnueabihf" => Some("arm-linux-gnueabihf"),
-                        "arm-unknown-linux-musleabi" => Some("arm-linux-musleabi"),
-                        "arm-unknown-linux-musleabihf" => Some("arm-linux-musleabihf"),
-                        "arm-unknown-netbsd-eabi" => Some("arm--netbsdelf-eabi"),
-                        "armv6-unknown-netbsd-eabihf" => Some("armv6--netbsdelf-eabihf"),
-                        "armv7-unknown-linux-gnueabihf" => Some("arm-linux-gnueabihf"),
-                        "armv7-unknown-linux-musleabihf" => Some("arm-linux-musleabihf"),
-                        "armv7neon-unknown-linux-gnueabihf" => Some("arm-linux-gnueabihf"),
-                        "armv7neon-unknown-linux-musleabihf" => Some("arm-linux-musleabihf"),
-                        "thumbv7-unknown-linux-gnueabihf" => Some("arm-linux-gnueabihf"),
-                        "thumbv7-unknown-linux-musleabihf" => Some("arm-linux-musleabihf"),
-                        "thumbv7neon-unknown-linux-gnueabihf" => Some("arm-linux-gnueabihf"),
-                        "thumbv7neon-unknown-linux-musleabihf" => Some("arm-linux-musleabihf"),
-                        "armv7-unknown-netbsd-eabihf" => Some("armv7--netbsdelf-eabihf"),
-                        "i586-unknown-linux-musl" => Some("musl"),
-                        "i686-pc-windows-gnu" => Some("i686-w64-mingw32"),
-                        "i686-uwp-windows-gnu" => Some("i686-w64-mingw32"),
-                        "i686-unknown-linux-musl" => Some("musl"),
-                        "i686-unknown-netbsd" => Some("i486--netbsdelf"),
-                        "mips-unknown-linux-gnu" => Some("mips-linux-gnu"),
-                        "mipsel-unknown-linux-gnu" => Some("mipsel-linux-gnu"),
-                        "mips64-unknown-linux-gnuabi64" => Some("mips64-linux-gnuabi64"),
-                        "mips64el-unknown-linux-gnuabi64" => Some("mips64el-linux-gnuabi64"),
-                        "mipsisa32r6-unknown-linux-gnu" => Some("mipsisa32r6-linux-gnu"),
-                        "mipsisa32r6el-unknown-linux-gnu" => Some("mipsisa32r6el-linux-gnu"),
-                        "mipsisa64r6-unknown-linux-gnuabi64" => Some("mipsisa64r6-linux-gnuabi64"),
-                        "mipsisa64r6el-unknown-linux-gnuabi64" => {
-                            Some("mipsisa64r6el-linux-gnuabi64")
-                        }
-                        "powerpc-unknown-linux-gnu" => Some("powerpc-linux-gnu"),
-                        "powerpc-unknown-linux-gnuspe" => Some("powerpc-linux-gnuspe"),
-                        "powerpc-unknown-netbsd" => Some("powerpc--netbsd"),
-                        "powerpc64-unknown-linux-gnu" => Some("powerpc-linux-gnu"),
-                        "powerpc64le-unknown-linux-gnu" => Some("powerpc64le-linux-gnu"),
-                        "riscv32i-unknown-none-elf" => Some("riscv32-unknown-elf"),
-                        "riscv32imac-unknown-none-elf" => Some("riscv32-unknown-elf"),
-                        "riscv32imc-unknown-none-elf" => Some("riscv32-unknown-elf"),
-                        "riscv64gc-unknown-none-elf" => Some("riscv64-unknown-elf"),
-                        "riscv64imac-unknown-none-elf" => Some("riscv64-unknown-elf"),
-                        "s390x-unknown-linux-gnu" => Some("s390x-linux-gnu"),
-                        "sparc-unknown-linux-gnu" => Some("sparc-linux-gnu"),
-                        "sparc64-unknown-linux-gnu" => Some("sparc64-linux-gnu"),
-                        "sparc64-unknown-netbsd" => Some("sparc64--netbsd"),
-                        "sparcv9-sun-solaris" => Some("sparcv9-sun-solaris"),
-                        "armebv7r-none-eabi" => Some("arm-none-eabi"),
-                        "armebv7r-none-eabihf" => Some("arm-none-eabi"),
-                        "armv7r-none-eabi" => Some("arm-none-eabi"),
-                        "armv7r-none-eabihf" => Some("arm-none-eabi"),
-                        "thumbv6m-none-eabi" => Some("arm-none-eabi"),
-                        "thumbv7em-none-eabi" => Some("arm-none-eabi"),
-                        "thumbv7em-none-eabihf" => Some("arm-none-eabi"),
-                        "thumbv7m-none-eabi" => Some("arm-none-eabi"),
-                        "thumbv8m.base-none-eabi" => Some("arm-none-eabi"),
-                        "thumbv8m.main-none-eabi" => Some("arm-none-eabi"),
-                        "thumbv8m.main-none-eabihf" => Some("arm-none-eabi"),
-                        "x86_64-pc-windows-gnu" => Some("x86_64-w64-mingw32"),
-                        "x86_64-uwp-windows-gnu" => Some("x86_64-w64-mingw32"),
-                        "x86_64-rumprun-netbsd" => Some("x86_64-rumprun-netbsd"),
-                        "x86_64-unknown-linux-musl" => Some("musl"),
-                        "x86_64-unknown-netbsd" => Some("x86_64--netbsd"),
-                        _ => None,
-                    });
-                    match prefix {
-                        Some(prefix) => format!("{}-{}", prefix, gnu),
-                        None => default.to_string(),
-                    }
-                } else {
-                    default.to_string()
-                };
-                Tool::new(PathBuf::from(compiler))
-            }
-        };
-
-        let mut tool = if self.cuda {
-            assert!(
-                tool.args.is_empty(),
-                "CUDA compilation currently assumes empty pre-existing args"
-            );
-            let nvcc = match self.get_var("NVCC") {
-                Err(_) => "nvcc".into(),
-                Ok(nvcc) => nvcc,
-            };
-            let mut nvcc_tool = Tool::with_features(PathBuf::from(nvcc), None, self.cuda);
-            nvcc_tool
-                .args
-                .push(format!("-ccbin={}", tool.path.display()).into());
-            nvcc_tool.family = tool.family;
-            nvcc_tool
-        } else {
-            tool
-        };
-
-        // If we found `cl.exe` in our environment, the tool we're returning is
-        // an MSVC-like tool, *and* no env vars were set then set env vars for
-        // the tool that we're returning.
-        //
-        // Env vars are needed for things like `link.exe` being put into PATH as
-        // well as header include paths sometimes. These paths are automatically
-        // included by default but if the `CC` or `CXX` env vars are set these
-        // won't be used. This'll ensure that when the env vars are used to
-        // configure for invocations like `clang-cl` we still get a "works out
-        // of the box" experience.
-        if let Some(cl_exe) = cl_exe {
-            if tool.family == (ToolFamily::Msvc { clang_cl: true })
-                && tool.env.len() == 0
-                && target.contains("msvc")
-            {
-                for &(ref k, ref v) in cl_exe.env.iter() {
-                    tool.env.push((k.to_owned(), v.to_owned()));
-                }
-            }
-        }
-
-        Ok(tool)
-    }
-
-    fn get_var(&self, var_base: &str) -> Result<String, Error> {
-        let target = self.get_target()?;
-        let host = self.get_host()?;
-        let kind = if host == target { "HOST" } else { "TARGET" };
-        let target_u = target.replace("-", "_");
-        let res = self
-            .getenv(&format!("{}_{}", var_base, target))
-            .or_else(|| self.getenv(&format!("{}_{}", var_base, target_u)))
-            .or_else(|| self.getenv(&format!("{}_{}", kind, var_base)))
-            .or_else(|| self.getenv(var_base));
-
-        match res {
-            Some(res) => Ok(res),
-            None => Err(Error::new(
-                ErrorKind::EnvVarNotFound,
-                &format!("Could not find environment variable {}.", var_base),
-            )),
-        }
-    }
-
-    fn envflags(&self, name: &str) -> Vec<String> {
-        self.get_var(name)
-            .unwrap_or(String::new())
-            .split(|c: char| c.is_whitespace())
-            .filter(|s| !s.is_empty())
-            .map(|s| s.to_string())
-            .collect()
-    }
-
-    /// Returns compiler path, optional modifier name from whitelist, and arguments vec
-    fn env_tool(&self, name: &str) -> Option<(String, Option<String>, Vec<String>)> {
-        let tool = match self.get_var(name) {
-            Ok(tool) => tool,
-            Err(_) => return None,
-        };
-
-        // If this is an exact path on the filesystem we don't want to do any
-        // interpretation at all, just pass it on through. This'll hopefully get
-        // us to support spaces-in-paths.
-        if Path::new(&tool).exists() {
-            return Some((tool, None, Vec::new()));
-        }
-
-        // Ok now we want to handle a couple of scenarios. We'll assume from
-        // here on out that spaces are splitting separate arguments. Two major
-        // features we want to support are:
-        //
-        //      CC='sccache cc'
-        //
-        // aka using `sccache` or any other wrapper/caching-like-thing for
-        // compilations. We want to know what the actual compiler is still,
-        // though, because our `Tool` API support introspection of it to see
-        // what compiler is in use.
-        //
-        // additionally we want to support
-        //
-        //      CC='cc -flag'
-        //
-        // where the CC env var is used to also pass default flags to the C
-        // compiler.
-        //
-        // It's true that everything here is a bit of a pain, but apparently if
-        // you're not literally make or bash then you get a lot of bug reports.
-        let known_wrappers = ["ccache", "distcc", "sccache", "icecc"];
-
-        let mut parts = tool.split_whitespace();
-        let maybe_wrapper = match parts.next() {
-            Some(s) => s,
-            None => return None,
-        };
-
-        let file_stem = Path::new(maybe_wrapper)
-            .file_stem()
-            .unwrap()
-            .to_str()
-            .unwrap();
-        if known_wrappers.contains(&file_stem) {
-            if let Some(compiler) = parts.next() {
-                return Some((
-                    compiler.to_string(),
-                    Some(maybe_wrapper.to_string()),
-                    parts.map(|s| s.to_string()).collect(),
-                ));
-            }
-        }
-
-        Some((
-            maybe_wrapper.to_string(),
-            None,
-            parts.map(|s| s.to_string()).collect(),
-        ))
-    }
-
-    /// Returns the default C++ standard library for the current target: `libc++`
-    /// for OS X and `libstdc++` for anything else.
-    fn get_cpp_link_stdlib(&self) -> Result<Option<String>, Error> {
-        match self.cpp_link_stdlib.clone() {
-            Some(s) => Ok(s),
-            None => {
-                if let Ok(stdlib) = self.get_var("CXXSTDLIB") {
-                    if stdlib.is_empty() {
-                        Ok(None)
-                    } else {
-                        Ok(Some(stdlib))
-                    }
-                } else {
-                    let target = self.get_target()?;
-                    if target.contains("msvc") {
-                        Ok(None)
-                    } else if target.contains("apple") {
-                        Ok(Some("c++".to_string()))
-                    } else if target.contains("freebsd") {
-                        Ok(Some("c++".to_string()))
-                    } else if target.contains("openbsd") {
-                        Ok(Some("c++".to_string()))
-                    } else {
-                        Ok(Some("stdc++".to_string()))
-                    }
-                }
-            }
-        }
-    }
-
-    fn get_ar(&self) -> Result<(Command, String), Error> {
-        if let Some(ref p) = self.archiver {
-            let name = p.file_name().and_then(|s| s.to_str()).unwrap_or("ar");
-            return Ok((self.cmd(p), name.to_string()));
-        }
-        if let Ok(p) = self.get_var("AR") {
-            return Ok((self.cmd(&p), p));
-        }
-        let target = self.get_target()?;
-        let program = if target.contains("android") {
-            format!("{}-ar", target.replace("armv7", "arm"))
-        } else if target.contains("emscripten") {
-            // Windows use bat files so we have to be a bit more specific
-            if cfg!(windows) {
-                let mut cmd = self.cmd("cmd");
-                cmd.arg("/c").arg("emar.bat");
-                return Ok((cmd, "emar.bat".to_string()));
-            }
-
-            "emar".to_string()
-        } else if target.contains("msvc") {
-            match windows_registry::find(&target, "lib.exe") {
-                Some(t) => return Ok((t, "lib.exe".to_string())),
-                None => "lib.exe".to_string(),
-            }
-        } else {
-            "ar".to_string()
-        };
-        Ok((self.cmd(&program), program))
-    }
-
-    fn get_target(&self) -> Result<String, Error> {
-        match self.target.clone() {
-            Some(t) => Ok(t),
-            None => Ok(self.getenv_unwrap("TARGET")?),
-        }
-    }
-
-    fn get_host(&self) -> Result<String, Error> {
-        match self.host.clone() {
-            Some(h) => Ok(h),
-            None => Ok(self.getenv_unwrap("HOST")?),
-        }
-    }
-
-    fn get_opt_level(&self) -> Result<String, Error> {
-        match self.opt_level.as_ref().cloned() {
-            Some(ol) => Ok(ol),
-            None => Ok(self.getenv_unwrap("OPT_LEVEL")?),
-        }
-    }
-
-    fn get_debug(&self) -> bool {
-        self.debug.unwrap_or_else(|| match self.getenv("DEBUG") {
-            Some(s) => s != "false",
-            None => false,
-        })
-    }
-
-    fn get_force_frame_pointer(&self) -> bool {
-        self.force_frame_pointer.unwrap_or_else(|| self.get_debug())
-    }
-
-    fn get_out_dir(&self) -> Result<PathBuf, Error> {
-        match self.out_dir.clone() {
-            Some(p) => Ok(p),
-            None => Ok(env::var_os("OUT_DIR").map(PathBuf::from).ok_or_else(|| {
-                Error::new(
-                    ErrorKind::EnvVarNotFound,
-                    "Environment variable OUT_DIR not defined.",
-                )
-            })?),
-        }
-    }
-
-    fn getenv(&self, v: &str) -> Option<String> {
-        let mut cache = self.env_cache.lock().unwrap();
-        if let Some(val) = cache.get(v) {
-            return val.clone();
-        }
-        let r = env::var(v).ok();
-        self.print(&format!("{} = {:?}", v, r));
-        cache.insert(v.to_string(), r.clone());
-        r
-    }
-
-    fn getenv_unwrap(&self, v: &str) -> Result<String, Error> {
-        match self.getenv(v) {
-            Some(s) => Ok(s),
-            None => Err(Error::new(
-                ErrorKind::EnvVarNotFound,
-                &format!("Environment variable {} not defined.", v.to_string()),
-            )),
-        }
-    }
-
-    fn print(&self, s: &str) {
-        if self.cargo_metadata {
-            println!("{}", s);
-        }
-    }
-}
-
-impl Default for Build {
-    fn default() -> Build {
-        Build::new()
-    }
-}
-
-impl Tool {
-    fn new(path: PathBuf) -> Self {
-        Tool::with_features(path, None, false)
-    }
-
-    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") {
-                ToolFamily::Msvc { clang_cl: true }
-            } else if fname.contains("cl")
-                && !fname.contains("cloudabi")
-                && !fname.contains("uclibc")
-                && !fname.contains("clang")
-            {
-                ToolFamily::Msvc { clang_cl: false }
-            } else if fname.contains("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,
-            cc_wrapper_args: Vec::new(),
-            args: Vec::new(),
-            env: Vec::new(),
-            family: family,
-            cuda: cuda,
-            removed_args: Vec::new(),
-        }
-    }
-
-    /// Add an argument to be stripped from the final command arguments.
-    fn remove_arg(&mut self, flag: OsString) {
-        self.removed_args.push(flag);
-    }
-
-    /// Add a flag, and optionally prepend the NVCC wrapper flag "-Xcompiler".
-    ///
-    /// Currently this is only used for compiling CUDA sources, since NVCC only
-    /// accepts a limited set of GNU-like flags, and the rest must be prefixed
-    /// with a "-Xcompiler" flag to get passed to the underlying C++ compiler.
-    fn push_cc_arg(&mut self, flag: OsString) {
-        if self.cuda {
-            self.args.push("-Xcompiler".into());
-        }
-        self.args.push(flag);
-    }
-
-    fn is_duplicate_opt_arg(&self, flag: &OsString) -> bool {
-        let flag = flag.to_str().unwrap();
-        let mut chars = flag.chars();
-
-        // Only duplicate check compiler flags
-        if self.is_like_msvc() {
-            if chars.next() != Some('/') {
-                return false;
-            }
-        } else if self.is_like_gnu() || self.is_like_clang() {
-            if chars.next() != Some('-') {
-                return false;
-            }
-        }
-
-        // Check for existing optimization flags (-O, /O)
-        if chars.next() == Some('O') {
-            return self
-                .args()
-                .iter()
-                .any(|ref a| a.to_str().unwrap_or("").chars().nth(1) == Some('O'));
-        }
-
-        // TODO Check for existing -m..., -m...=..., /arch:... flags
-        return false;
-    }
-
-    /// Don't push optimization arg if it conflicts with existing args
-    fn push_opt_unless_duplicate(&mut self, flag: OsString) {
-        if self.is_duplicate_opt_arg(&flag) {
-            println!("Info: Ignoring duplicate arg {:?}", &flag);
-        } else {
-            self.push_cc_arg(flag);
-        }
-    }
-
-    /// Converts this compiler into a `Command` that's ready to be run.
-    ///
-    /// This is useful for when the compiler needs to be executed and the
-    /// command returned will already have the initial arguments and environment
-    /// variables configured.
-    pub fn to_command(&self) -> Command {
-        let mut cmd = match self.cc_wrapper_path {
-            Some(ref cc_wrapper_path) => {
-                let mut cmd = Command::new(&cc_wrapper_path);
-                cmd.arg(&self.path);
-                cmd
-            }
-            None => Command::new(&self.path),
-        };
-        cmd.args(&self.cc_wrapper_args);
-
-        let value = self
-            .args
-            .iter()
-            .filter(|a| !self.removed_args.contains(a))
-            .collect::<Vec<_>>();
-        cmd.args(&value);
-
-        for &(ref k, ref v) in self.env.iter() {
-            cmd.env(k, v);
-        }
-        cmd
-    }
-
-    /// Returns the path for this compiler.
-    ///
-    /// Note that this may not be a path to a file on the filesystem, e.g. "cc",
-    /// but rather something which will be resolved when a process is spawned.
-    pub fn path(&self) -> &Path {
-        &self.path
-    }
-
-    /// Returns the default set of arguments to the compiler needed to produce
-    /// executables for the target this compiler generates.
-    pub fn args(&self) -> &[OsString] {
-        &self.args
-    }
-
-    /// Returns the set of environment variables needed for this compiler to
-    /// operate.
-    ///
-    /// This is typically only used for MSVC compilers currently.
-    pub fn env(&self) -> &[(OsString, OsString)] {
-        &self.env
-    }
-
-    /// Returns the compiler command in format of CC environment variable.
-    /// Or empty string if CC env was not present
-    ///
-    /// This is typically used by configure script
-    pub fn cc_env(&self) -> OsString {
-        match self.cc_wrapper_path {
-            Some(ref cc_wrapper_path) => {
-                let mut cc_env = cc_wrapper_path.as_os_str().to_owned();
-                cc_env.push(" ");
-                cc_env.push(self.path.to_path_buf().into_os_string());
-                for arg in self.cc_wrapper_args.iter() {
-                    cc_env.push(" ");
-                    cc_env.push(arg);
-                }
-                cc_env
-            }
-            None => OsString::from(""),
-        }
-    }
-
-    /// Returns the compiler flags in format of CFLAGS environment variable.
-    /// Important here - this will not be CFLAGS from env, its internal gcc's flags to use as CFLAGS
-    /// This is typically used by configure script
-    pub fn cflags_env(&self) -> OsString {
-        let mut flags = OsString::new();
-        for (i, arg) in self.args.iter().enumerate() {
-            if i > 0 {
-                flags.push(" ");
-            }
-            flags.push(arg);
-        }
-        flags
-    }
-
-    /// Whether the tool is GNU Compiler Collection-like.
-    pub fn is_like_gnu(&self) -> bool {
-        self.family == ToolFamily::Gnu
-    }
-
-    /// Whether the tool is Clang-like.
-    pub fn is_like_clang(&self) -> bool {
-        self.family == ToolFamily::Clang
-    }
-
-    /// Whether the tool is MSVC-like.
-    pub fn is_like_msvc(&self) -> bool {
-        match self.family {
-            ToolFamily::Msvc { .. } => true,
-            _ => false,
-        }
-    }
-}
-
-fn run(cmd: &mut Command, program: &str) -> Result<(), Error> {
-    let (mut child, print) = spawn(cmd, program)?;
-    let status = match child.wait() {
-        Ok(s) => s,
-        Err(_) => {
-            return Err(Error::new(
-                ErrorKind::ToolExecError,
-                &format!(
-                    "Failed to wait on spawned child process, command {:?} with args {:?}.",
-                    cmd, program
-                ),
-            ));
-        }
-    };
-    print.join().unwrap();
-    println!("{}", status);
-
-    if status.success() {
-        Ok(())
-    } else {
-        Err(Error::new(
-            ErrorKind::ToolExecError,
-            &format!(
-                "Command {:?} with args {:?} did not execute successfully (status code {}).",
-                cmd, program, status
-            ),
-        ))
-    }
-}
-
-fn run_output(cmd: &mut Command, program: &str) -> Result<Vec<u8>, Error> {
-    cmd.stdout(Stdio::piped());
-    let (mut child, print) = spawn(cmd, program)?;
-    let mut stdout = vec![];
-    child
-        .stdout
-        .take()
-        .unwrap()
-        .read_to_end(&mut stdout)
-        .unwrap();
-    let status = match child.wait() {
-        Ok(s) => s,
-        Err(_) => {
-            return Err(Error::new(
-                ErrorKind::ToolExecError,
-                &format!(
-                    "Failed to wait on spawned child process, command {:?} with args {:?}.",
-                    cmd, program
-                ),
-            ));
-        }
-    };
-    print.join().unwrap();
-    println!("{}", status);
-
-    if status.success() {
-        Ok(stdout)
-    } else {
-        Err(Error::new(
-            ErrorKind::ToolExecError,
-            &format!(
-                "Command {:?} with args {:?} did not execute successfully (status code {}).",
-                cmd, program, status
-            ),
-        ))
-    }
-}
-
-fn spawn(cmd: &mut Command, program: &str) -> Result<(Child, JoinHandle<()>), Error> {
-    println!("running: {:?}", cmd);
-
-    // Capture the standard error coming from these programs, and write it out
-    // with cargo:warning= prefixes. Note that this is a bit wonky to avoid
-    // requiring the output to be UTF-8, we instead just ship bytes from one
-    // location to another.
-    match cmd.stderr(Stdio::piped()).spawn() {
-        Ok(mut child) => {
-            let stderr = BufReader::new(child.stderr.take().unwrap());
-            let print = thread::spawn(move || {
-                for line in stderr.split(b'\n').filter_map(|l| l.ok()) {
-                    print!("cargo:warning=");
-                    std::io::stdout().write_all(&line).unwrap();
-                    println!("");
-                }
-            });
-            Ok((child, print))
-        }
-        Err(ref e) if e.kind() == io::ErrorKind::NotFound => {
-            let extra = if cfg!(windows) {
-                " (see https://github.com/alexcrichton/cc-rs#compile-time-requirements \
-                 for help)"
-            } else {
-                ""
-            };
-            Err(Error::new(
-                ErrorKind::ToolNotFound,
-                &format!("Failed to find tool. Is `{}` installed?{}", program, extra),
-            ))
-        }
-        Err(_) => Err(Error::new(
-            ErrorKind::ToolExecError,
-            &format!("Command {:?} with args {:?} failed to start.", cmd, program),
-        )),
-    }
-}
-
-fn fail(s: &str) -> ! {
-    let _ = writeln!(io::stderr(), "\n\nerror occurred: {}\n\n", s);
-    std::process::exit(1);
-}
-
-fn command_add_output_file(
-    cmd: &mut Command,
-    dst: &Path,
-    cuda: bool,
-    msvc: bool,
-    is_asm: bool,
-    is_arm: bool,
-) {
-    if msvc && !cuda && !(is_asm && is_arm) {
-        let mut s = OsString::from("-Fo");
-        s.push(&dst);
-        cmd.arg(s);
-    } else {
-        cmd.arg("-o").arg(&dst);
-    }
-}
diff --git a/cc/src/registry.rs b/cc/src/registry.rs
deleted file mode 100644
index 2ac2fa6..0000000
--- a/cc/src/registry.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::ffi::{OsStr, OsString};
-use std::io;
-use std::ops::RangeFrom;
-use std::os::raw;
-use std::os::windows::prelude::*;
-
-pub struct RegistryKey(Repr);
-
-type HKEY = *mut u8;
-type DWORD = u32;
-type LPDWORD = *mut DWORD;
-type LPCWSTR = *const u16;
-type LPWSTR = *mut u16;
-type LONG = raw::c_long;
-type PHKEY = *mut HKEY;
-type PFILETIME = *mut u8;
-type LPBYTE = *mut u8;
-type REGSAM = u32;
-
-const ERROR_SUCCESS: DWORD = 0;
-const ERROR_NO_MORE_ITEMS: DWORD = 259;
-const HKEY_LOCAL_MACHINE: HKEY = 0x80000002 as HKEY;
-const REG_SZ: DWORD = 1;
-const KEY_READ: DWORD = 0x20019;
-const KEY_WOW64_32KEY: DWORD = 0x200;
-
-#[link(name = "advapi32")]
-extern "system" {
-    fn RegOpenKeyExW(
-        key: HKEY,
-        lpSubKey: LPCWSTR,
-        ulOptions: DWORD,
-        samDesired: REGSAM,
-        phkResult: PHKEY,
-    ) -> LONG;
-    fn RegEnumKeyExW(
-        key: HKEY,
-        dwIndex: DWORD,
-        lpName: LPWSTR,
-        lpcName: LPDWORD,
-        lpReserved: LPDWORD,
-        lpClass: LPWSTR,
-        lpcClass: LPDWORD,
-        lpftLastWriteTime: PFILETIME,
-    ) -> LONG;
-    fn RegQueryValueExW(
-        hKey: HKEY,
-        lpValueName: LPCWSTR,
-        lpReserved: LPDWORD,
-        lpType: LPDWORD,
-        lpData: LPBYTE,
-        lpcbData: LPDWORD,
-    ) -> LONG;
-    fn RegCloseKey(hKey: HKEY) -> LONG;
-}
-
-struct OwnedKey(HKEY);
-
-enum Repr {
-    Const(HKEY),
-    Owned(OwnedKey),
-}
-
-pub struct Iter<'a> {
-    idx: RangeFrom<DWORD>,
-    key: &'a RegistryKey,
-}
-
-unsafe impl Sync for Repr {}
-unsafe impl Send for Repr {}
-
-pub static LOCAL_MACHINE: RegistryKey = RegistryKey(Repr::Const(HKEY_LOCAL_MACHINE));
-
-impl RegistryKey {
-    fn raw(&self) -> HKEY {
-        match self.0 {
-            Repr::Const(val) => val,
-            Repr::Owned(ref val) => val.0,
-        }
-    }
-
-    pub fn open(&self, key: &OsStr) -> io::Result<RegistryKey> {
-        let key = key.encode_wide().chain(Some(0)).collect::<Vec<_>>();
-        let mut ret = 0 as *mut _;
-        let err = unsafe {
-            RegOpenKeyExW(
-                self.raw(),
-                key.as_ptr(),
-                0,
-                KEY_READ | KEY_WOW64_32KEY,
-                &mut ret,
-            )
-        };
-        if err == ERROR_SUCCESS as LONG {
-            Ok(RegistryKey(Repr::Owned(OwnedKey(ret))))
-        } else {
-            Err(io::Error::from_raw_os_error(err as i32))
-        }
-    }
-
-    pub fn iter(&self) -> Iter {
-        Iter {
-            idx: 0..,
-            key: self,
-        }
-    }
-
-    pub fn query_str(&self, name: &str) -> io::Result<OsString> {
-        let name: &OsStr = name.as_ref();
-        let name = name.encode_wide().chain(Some(0)).collect::<Vec<_>>();
-        let mut len = 0;
-        let mut kind = 0;
-        unsafe {
-            let err = RegQueryValueExW(
-                self.raw(),
-                name.as_ptr(),
-                0 as *mut _,
-                &mut kind,
-                0 as *mut _,
-                &mut len,
-            );
-            if err != ERROR_SUCCESS as LONG {
-                return Err(io::Error::from_raw_os_error(err as i32));
-            }
-            if kind != REG_SZ {
-                return Err(io::Error::new(
-                    io::ErrorKind::Other,
-                    "registry key wasn't a string",
-                ));
-            }
-
-            // The length here is the length in bytes, but we're using wide
-            // characters so we need to be sure to halve it for the capacity
-            // passed in.
-            let mut v = Vec::with_capacity(len as usize / 2);
-            let err = RegQueryValueExW(
-                self.raw(),
-                name.as_ptr(),
-                0 as *mut _,
-                0 as *mut _,
-                v.as_mut_ptr() as *mut _,
-                &mut len,
-            );
-            if err != ERROR_SUCCESS as LONG {
-                return Err(io::Error::from_raw_os_error(err as i32));
-            }
-            v.set_len(len as usize / 2);
-
-            // Some registry keys may have a terminating nul character, but
-            // we're not interested in that, so chop it off if it's there.
-            if v[v.len() - 1] == 0 {
-                v.pop();
-            }
-            Ok(OsString::from_wide(&v))
-        }
-    }
-}
-
-impl Drop for OwnedKey {
-    fn drop(&mut self) {
-        unsafe {
-            RegCloseKey(self.0);
-        }
-    }
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = io::Result<OsString>;
-
-    fn next(&mut self) -> Option<io::Result<OsString>> {
-        self.idx.next().and_then(|i| unsafe {
-            let mut v = Vec::with_capacity(256);
-            let mut len = v.capacity() as DWORD;
-            let ret = RegEnumKeyExW(
-                self.key.raw(),
-                i,
-                v.as_mut_ptr(),
-                &mut len,
-                0 as *mut _,
-                0 as *mut _,
-                0 as *mut _,
-                0 as *mut _,
-            );
-            if ret == ERROR_NO_MORE_ITEMS as LONG {
-                None
-            } else if ret != ERROR_SUCCESS as LONG {
-                Some(Err(io::Error::from_raw_os_error(ret as i32)))
-            } else {
-                v.set_len(len as usize);
-                Some(Ok(OsString::from_wide(&v)))
-            }
-        })
-    }
-}
diff --git a/cc/src/setup_config.rs b/cc/src/setup_config.rs
deleted file mode 100644
index bc2b1c2..0000000
--- a/cc/src/setup_config.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright © 2017 winapi-rs developers
-// Licensed under the Apache License, Version 2.0
-// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// All files in the project carrying such notice may not be copied, modified, or distributed
-// except according to those terms.
-
-#![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 crate::com::{BStr, ComPtr};
-
-// Bindings to the Setup.Configuration stuff
-pub type InstanceState = u32;
-
-pub const eNone: InstanceState = 0;
-pub const eLocal: InstanceState = 1;
-pub const eRegistered: InstanceState = 2;
-pub const eNoRebootRequired: InstanceState = 4;
-pub const eComplete: InstanceState = -1i32 as u32;
-
-RIDL! {#[uuid(0xb41463c3, 0x8866, 0x43b5, 0xbc, 0x33, 0x2b, 0x06, 0x76, 0xf7, 0xf4, 0x2e)]
-interface ISetupInstance(ISetupInstanceVtbl): IUnknown(IUnknownVtbl) {
-    fn GetInstanceId(
-        pbstrInstanceId: *mut BSTR,
-    ) -> HRESULT,
-    fn GetInstallDate(
-        pInstallDate: LPFILETIME,
-    ) -> HRESULT,
-    fn GetInstallationName(
-        pbstrInstallationName: *mut BSTR,
-    ) -> HRESULT,
-    fn GetInstallationPath(
-        pbstrInstallationPath: *mut BSTR,
-    ) -> HRESULT,
-    fn GetInstallationVersion(
-        pbstrInstallationVersion: *mut BSTR,
-    ) -> HRESULT,
-    fn GetDisplayName(
-        lcid: LCID,
-        pbstrDisplayName: *mut BSTR,
-    ) -> HRESULT,
-    fn GetDescription(
-        lcid: LCID,
-        pbstrDescription: *mut BSTR,
-    ) -> HRESULT,
-    fn ResolvePath(
-        pwszRelativePath: LPCOLESTR,
-        pbstrAbsolutePath: *mut BSTR,
-    ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0x89143c9a, 0x05af, 0x49b0, 0xb7, 0x17, 0x72, 0xe2, 0x18, 0xa2, 0x18, 0x5c)]
-interface ISetupInstance2(ISetupInstance2Vtbl): ISetupInstance(ISetupInstanceVtbl) {
-    fn GetState(
-        pState: *mut InstanceState,
-    ) -> HRESULT,
-    fn GetPackages(
-        ppsaPackages: *mut LPSAFEARRAY,
-    ) -> HRESULT,
-    fn GetProduct(
-        ppPackage: *mut *mut ISetupPackageReference,
-    ) -> HRESULT,
-    fn GetProductPath(
-        pbstrProductPath: *mut BSTR,
-    ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0x6380bcff, 0x41d3, 0x4b2e, 0x8b, 0x2e, 0xbf, 0x8a, 0x68, 0x10, 0xc8, 0x48)]
-interface IEnumSetupInstances(IEnumSetupInstancesVtbl): IUnknown(IUnknownVtbl) {
-    fn Next(
-        celt: ULONG,
-        rgelt: *mut *mut ISetupInstance,
-        pceltFetched: *mut ULONG,
-    ) -> HRESULT,
-    fn Skip(
-        celt: ULONG,
-    ) -> HRESULT,
-    fn Reset() -> HRESULT,
-    fn Clone(
-        ppenum: *mut *mut IEnumSetupInstances,
-    ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0x42843719, 0xdb4c, 0x46c2, 0x8e, 0x7c, 0x64, 0xf1, 0x81, 0x6e, 0xfd, 0x5b)]
-interface ISetupConfiguration(ISetupConfigurationVtbl): IUnknown(IUnknownVtbl) {
-    fn EnumInstances(
-        ppEnumInstances: *mut *mut IEnumSetupInstances,
-    ) -> HRESULT,
-    fn GetInstanceForCurrentProcess(
-        ppInstance: *mut *mut ISetupInstance,
-    ) -> HRESULT,
-    fn GetInstanceForPath(
-        wzPath: LPCWSTR,
-        ppInstance: *mut *mut ISetupInstance,
-    ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0x26aab78c, 0x4a60, 0x49d6, 0xaf, 0x3b, 0x3c, 0x35, 0xbc, 0x93, 0x36, 0x5d)]
-interface ISetupConfiguration2(ISetupConfiguration2Vtbl):
-    ISetupConfiguration(ISetupConfigurationVtbl) {
-    fn EnumAllInstances(
-        ppEnumInstances: *mut *mut IEnumSetupInstances,
-    ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0xda8d8a16, 0xb2b6, 0x4487, 0xa2, 0xf1, 0x59, 0x4c, 0xcc, 0xcd, 0x6b, 0xf5)]
-interface ISetupPackageReference(ISetupPackageReferenceVtbl): IUnknown(IUnknownVtbl) {
-    fn GetId(
-        pbstrId: *mut BSTR,
-    ) -> HRESULT,
-    fn GetVersion(
-        pbstrVersion: *mut BSTR,
-    ) -> HRESULT,
-    fn GetChip(
-        pbstrChip: *mut BSTR,
-    ) -> HRESULT,
-    fn GetLanguage(
-        pbstrLanguage: *mut BSTR,
-    ) -> HRESULT,
-    fn GetBranch(
-        pbstrBranch: *mut BSTR,
-    ) -> HRESULT,
-    fn GetType(
-        pbstrType: *mut BSTR,
-    ) -> HRESULT,
-    fn GetUniqueId(
-        pbstrUniqueId: *mut BSTR,
-    ) -> HRESULT,
-}}
-
-RIDL! {#[uuid(0x42b21b78, 0x6192, 0x463e, 0x87, 0xbf, 0xd5, 0x77, 0x83, 0x8f, 0x1d, 0x5c)]
-interface ISetupHelper(ISetupHelperVtbl): IUnknown(IUnknownVtbl) {
-    fn ParseVersion(
-        pwszVersion: LPCOLESTR,
-        pullVersion: PULONGLONG,
-    ) -> HRESULT,
-    fn ParseVersionRange(
-        pwszVersionRange: LPCOLESTR,
-        pullMinVersion: PULONGLONG,
-        pullMaxVersion: PULONGLONG,
-    ) -> HRESULT,
-}}
-
-DEFINE_GUID! {CLSID_SetupConfiguration,
-0x177f0c4a, 0x1cd3, 0x4de7, 0xa3, 0x2c, 0x71, 0xdb, 0xbb, 0x9f, 0xa3, 0x6d}
-
-// Safe wrapper around the COM interfaces
-pub struct SetupConfiguration(ComPtr<ISetupConfiguration>);
-
-impl SetupConfiguration {
-    pub fn new() -> Result<SetupConfiguration, i32> {
-        let mut obj = null_mut();
-        let err = unsafe {
-            CoCreateInstance(
-                &CLSID_SetupConfiguration,
-                null_mut(),
-                CLSCTX_ALL,
-                &ISetupConfiguration::uuidof(),
-                &mut obj,
-            )
-        };
-        if err < 0 {
-            return Err(err);
-        }
-        let obj = unsafe { ComPtr::from_raw(obj as *mut ISetupConfiguration) };
-        Ok(SetupConfiguration(obj))
-    }
-    pub fn get_instance_for_current_process(&self) -> Result<SetupInstance, i32> {
-        let mut obj = null_mut();
-        let err = unsafe { self.0.GetInstanceForCurrentProcess(&mut obj) };
-        if err < 0 {
-            return Err(err);
-        }
-        Ok(unsafe { SetupInstance::from_raw(obj) })
-    }
-    pub fn enum_instances(&self) -> Result<EnumSetupInstances, i32> {
-        let mut obj = null_mut();
-        let err = unsafe { self.0.EnumInstances(&mut obj) };
-        if err < 0 {
-            return Err(err);
-        }
-        Ok(unsafe { EnumSetupInstances::from_raw(obj) })
-    }
-    pub fn enum_all_instances(&self) -> Result<EnumSetupInstances, i32> {
-        let mut obj = null_mut();
-        let this = self.0.cast::<ISetupConfiguration2>()?;
-        let err = unsafe { this.EnumAllInstances(&mut obj) };
-        if err < 0 {
-            return Err(err);
-        }
-        Ok(unsafe { EnumSetupInstances::from_raw(obj) })
-    }
-}
-
-pub struct SetupInstance(ComPtr<ISetupInstance>);
-
-impl SetupInstance {
-    pub unsafe fn from_raw(obj: *mut ISetupInstance) -> SetupInstance {
-        SetupInstance(ComPtr::from_raw(obj))
-    }
-    pub fn instance_id(&self) -> Result<OsString, i32> {
-        let mut s = null_mut();
-        let err = unsafe { self.0.GetInstanceId(&mut s) };
-        let bstr = unsafe { BStr::from_raw(s) };
-        if err < 0 {
-            return Err(err);
-        }
-        Ok(bstr.to_osstring())
-    }
-    pub fn installation_name(&self) -> Result<OsString, i32> {
-        let mut s = null_mut();
-        let err = unsafe { self.0.GetInstallationName(&mut s) };
-        let bstr = unsafe { BStr::from_raw(s) };
-        if err < 0 {
-            return Err(err);
-        }
-        Ok(bstr.to_osstring())
-    }
-    pub fn installation_path(&self) -> Result<OsString, i32> {
-        let mut s = null_mut();
-        let err = unsafe { self.0.GetInstallationPath(&mut s) };
-        let bstr = unsafe { BStr::from_raw(s) };
-        if err < 0 {
-            return Err(err);
-        }
-        Ok(bstr.to_osstring())
-    }
-    pub fn installation_version(&self) -> Result<OsString, i32> {
-        let mut s = null_mut();
-        let err = unsafe { self.0.GetInstallationVersion(&mut s) };
-        let bstr = unsafe { BStr::from_raw(s) };
-        if err < 0 {
-            return Err(err);
-        }
-        Ok(bstr.to_osstring())
-    }
-    pub fn product_path(&self) -> Result<OsString, i32> {
-        let mut s = null_mut();
-        let this = self.0.cast::<ISetupInstance2>()?;
-        let err = unsafe { this.GetProductPath(&mut s) };
-        let bstr = unsafe { BStr::from_raw(s) };
-        if err < 0 {
-            return Err(err);
-        }
-        Ok(bstr.to_osstring())
-    }
-}
-
-pub struct EnumSetupInstances(ComPtr<IEnumSetupInstances>);
-
-impl EnumSetupInstances {
-    pub unsafe fn from_raw(obj: *mut IEnumSetupInstances) -> EnumSetupInstances {
-        EnumSetupInstances(ComPtr::from_raw(obj))
-    }
-}
-
-impl Iterator for EnumSetupInstances {
-    type Item = Result<SetupInstance, i32>;
-    fn next(&mut self) -> Option<Result<SetupInstance, i32>> {
-        let mut obj = null_mut();
-        let err = unsafe { self.0.Next(1, &mut obj, null_mut()) };
-        if err < 0 {
-            return Some(Err(err));
-        }
-        if err == S_FALSE {
-            return None;
-        }
-        Some(Ok(unsafe { SetupInstance::from_raw(obj) }))
-    }
-}
diff --git a/cc/src/winapi.rs b/cc/src/winapi.rs
deleted file mode 100644
index c416325..0000000
--- a/cc/src/winapi.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-// Copyright © 2015-2017 winapi-rs developers
-// Licensed under the Apache License, Version 2.0
-// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
-// All files in the project carrying such notice may not be copied, modified, or distributed
-// except according to those terms.
-
-#![allow(bad_style)]
-
-use std::os::raw;
-
-pub type wchar_t = u16;
-
-pub type UINT = raw::c_uint;
-pub type LPUNKNOWN = *mut IUnknown;
-pub type REFIID = *const IID;
-pub type IID = GUID;
-pub type REFCLSID = *const IID;
-pub type PVOID = *mut raw::c_void;
-pub type USHORT = raw::c_ushort;
-pub type ULONG = raw::c_ulong;
-pub type LONG = raw::c_long;
-pub type DWORD = u32;
-pub type LPVOID = *mut raw::c_void;
-pub type HRESULT = raw::c_long;
-pub type LPFILETIME = *mut FILETIME;
-pub type BSTR = *mut OLECHAR;
-pub type OLECHAR = WCHAR;
-pub type WCHAR = wchar_t;
-pub type LPCOLESTR = *const OLECHAR;
-pub type LCID = DWORD;
-pub type LPCWSTR = *const WCHAR;
-pub type PULONGLONG = *mut ULONGLONG;
-pub type ULONGLONG = u64;
-
-pub const S_OK: HRESULT = 0;
-pub const S_FALSE: HRESULT = 1;
-pub const COINIT_MULTITHREADED: u32 = 0x0;
-
-pub type CLSCTX = u32;
-
-pub const CLSCTX_INPROC_SERVER: CLSCTX = 0x1;
-pub const CLSCTX_INPROC_HANDLER: CLSCTX = 0x2;
-pub const CLSCTX_LOCAL_SERVER: CLSCTX = 0x4;
-pub const CLSCTX_REMOTE_SERVER: CLSCTX = 0x10;
-
-pub const CLSCTX_ALL: CLSCTX =
-    CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER;
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct GUID {
-    pub Data1: raw::c_ulong,
-    pub Data2: raw::c_ushort,
-    pub Data3: raw::c_ushort,
-    pub Data4: [raw::c_uchar; 8],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct FILETIME {
-    pub dwLowDateTime: DWORD,
-    pub dwHighDateTime: DWORD,
-}
-
-pub trait Interface {
-    fn uuidof() -> GUID;
-}
-
-#[link(name = "ole32")]
-#[link(name = "oleaut32")]
-extern "C" {}
-
-extern "system" {
-    pub fn CoInitializeEx(pvReserved: LPVOID, dwCoInit: DWORD) -> HRESULT;
-    pub fn CoCreateInstance(
-        rclsid: REFCLSID,
-        pUnkOuter: LPUNKNOWN,
-        dwClsContext: DWORD,
-        riid: REFIID,
-        ppv: *mut LPVOID,
-    ) -> HRESULT;
-    pub fn SysFreeString(bstrString: BSTR);
-    pub fn SysStringLen(pbstr: BSTR) -> UINT;
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SAFEARRAYBOUND {
-    pub cElements: ULONG,
-    pub lLbound: LONG,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SAFEARRAY {
-    pub cDims: USHORT,
-    pub fFeatures: USHORT,
-    pub cbElements: ULONG,
-    pub cLocks: ULONG,
-    pub pvData: PVOID,
-    pub rgsabound: [SAFEARRAYBOUND; 1],
-}
-
-pub type LPSAFEARRAY = *mut SAFEARRAY;
-
-macro_rules! DEFINE_GUID {
-    (
-        $name:ident, $l:expr, $w1:expr, $w2:expr,
-        $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr, $b7:expr, $b8:expr
-    ) => {
-        pub const $name: $crate::winapi::GUID = $crate::winapi::GUID {
-            Data1: $l,
-            Data2: $w1,
-            Data3: $w2,
-            Data4: [$b1, $b2, $b3, $b4, $b5, $b6, $b7, $b8],
-        };
-    };
-}
-
-macro_rules! RIDL {
-    (#[uuid($($uuid:expr),+)]
-    interface $interface:ident ($vtbl:ident) {$(
-        fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty,
-    )+}) => (
-        #[repr(C)]
-        pub struct $vtbl {
-            $(pub $method: unsafe extern "system" fn(
-                This: *mut $interface,
-                $($p: $t),*
-            ) -> $rtr,)+
-        }
-        #[repr(C)]
-        pub struct $interface {
-            pub lpVtbl: *const $vtbl,
-        }
-        RIDL!{@impl $interface {$(fn $method($($p: $t,)*) -> $rtr,)+}}
-        RIDL!{@uuid $interface $($uuid),+}
-    );
-    (#[uuid($($uuid:expr),+)]
-    interface $interface:ident ($vtbl:ident) : $pinterface:ident ($pvtbl:ident) {
-    }) => (
-        #[repr(C)]
-        pub struct $vtbl {
-            pub parent: $pvtbl,
-        }
-        #[repr(C)]
-        pub struct $interface {
-            pub lpVtbl: *const $vtbl,
-        }
-        RIDL!{@deref $interface $pinterface}
-        RIDL!{@uuid $interface $($uuid),+}
-    );
-    (#[uuid($($uuid:expr),+)]
-    interface $interface:ident ($vtbl:ident) : $pinterface:ident ($pvtbl:ident) {$(
-        fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty,
-    )+}) => (
-        #[repr(C)]
-        pub struct $vtbl {
-            pub parent: $pvtbl,
-            $(pub $method: unsafe extern "system" fn(
-                This: *mut $interface,
-                $($p: $t,)*
-            ) -> $rtr,)+
-        }
-        #[repr(C)]
-        pub struct $interface {
-            pub lpVtbl: *const $vtbl,
-        }
-        RIDL!{@impl $interface {$(fn $method($($p: $t,)*) -> $rtr,)+}}
-        RIDL!{@deref $interface $pinterface}
-        RIDL!{@uuid $interface $($uuid),+}
-    );
-    (@deref $interface:ident $pinterface:ident) => (
-        impl ::std::ops::Deref for $interface {
-            type Target = $pinterface;
-            #[inline]
-            fn deref(&self) -> &$pinterface {
-                unsafe { &*(self as *const $interface as *const $pinterface) }
-            }
-        }
-    );
-    (@impl $interface:ident {$(
-        fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty,
-    )+}) => (
-        impl $interface {
-            $(#[inline] pub unsafe fn $method(&self, $($p: $t,)*) -> $rtr {
-                ((*self.lpVtbl).$method)(self as *const _ as *mut _, $($p,)*)
-            })+
-        }
-    );
-    (@uuid $interface:ident
-        $l:expr, $w1:expr, $w2:expr,
-        $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr, $b7:expr, $b8:expr
-    ) => (
-        impl $crate::winapi::Interface for $interface {
-            #[inline]
-            fn uuidof() -> $crate::winapi::GUID {
-                $crate::winapi::GUID {
-                    Data1: $l,
-                    Data2: $w1,
-                    Data3: $w2,
-                    Data4: [$b1, $b2, $b3, $b4, $b5, $b6, $b7, $b8],
-                }
-            }
-        }
-    );
-}
-
-RIDL! {#[uuid(0x00000000, 0x0000, 0x0000, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46)]
-interface IUnknown(IUnknownVtbl) {
-    fn QueryInterface(
-        riid: REFIID,
-        ppvObject: *mut *mut raw::c_void,
-    ) -> HRESULT,
-    fn AddRef() -> ULONG,
-    fn Release() -> ULONG,
-}}
diff --git a/cc/src/windows_registry.rs b/cc/src/windows_registry.rs
deleted file mode 100644
index 5af3ff7..0000000
--- a/cc/src/windows_registry.rs
+++ /dev/null
@@ -1,754 +0,0 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A helper module to probe the Windows Registry when looking for
-//! windows-specific tools.
-
-use std::process::Command;
-
-use crate::Tool;
-
-/// Attempts to find a tool within an MSVC installation using the Windows
-/// registry as a point to search from.
-///
-/// The `target` argument is the target that the tool should work for (e.g.
-/// compile or link for) and the `tool` argument is the tool to find (e.g.
-/// `cl.exe` or `link.exe`).
-///
-/// This function will return `None` if the tool could not be found, or it will
-/// return `Some(cmd)` which represents a command that's ready to execute the
-/// tool with the appropriate environment variables set.
-///
-/// Note that this function always returns `None` for non-MSVC targets.
-pub fn find(target: &str, tool: &str) -> Option<Command> {
-    find_tool(target, tool).map(|c| c.to_command())
-}
-
-/// Similar to the `find` function above, this function will attempt the same
-/// operation (finding a MSVC tool in a local install) but instead returns a
-/// `Tool` which may be introspected.
-#[cfg(not(windows))]
-pub fn find_tool(_target: &str, _tool: &str) -> Option<Tool> {
-    None
-}
-
-/// Documented above.
-#[cfg(windows)]
-pub fn find_tool(target: &str, tool: &str) -> Option<Tool> {
-    use std::env;
-
-    // This logic is all tailored for MSVC, if we're not that then bail out
-    // early.
-    if !target.contains("msvc") {
-        return None;
-    }
-
-    // Looks like msbuild isn't located in the same location as other tools like
-    // cl.exe and lib.exe. To handle this we probe for it manually with
-    // dedicated registry keys.
-    if tool.contains("msbuild") {
-        return impl_::find_msbuild(target);
-    }
-
-    if tool.contains("devenv") {
-        return impl_::find_devenv(target);
-    }
-
-    // If VCINSTALLDIR is set, then someone's probably already run vcvars and we
-    // should just find whatever that indicates.
-    if env::var_os("VCINSTALLDIR").is_some() {
-        return env::var_os("PATH")
-            .and_then(|path| {
-                env::split_paths(&path)
-                    .map(|p| p.join(tool))
-                    .find(|p| p.exists())
-            })
-            .map(|path| Tool::new(path.into()));
-    }
-
-    // Ok, if we're here, now comes the fun part of the probing. Default shells
-    // or shells like MSYS aren't really configured to execute `cl.exe` and the
-    // various compiler tools shipped as part of Visual Studio. Here we try to
-    // first find the relevant tool, then we also have to be sure to fill in
-    // environment variables like `LIB`, `INCLUDE`, and `PATH` to ensure that
-    // the tool is actually usable.
-
-    return impl_::find_msvc_15(tool, target)
-        .or_else(|| impl_::find_msvc_14(tool, target))
-        .or_else(|| impl_::find_msvc_12(tool, target))
-        .or_else(|| impl_::find_msvc_11(tool, target));
-}
-
-/// A version of Visual Studio
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub enum VsVers {
-    /// Visual Studio 12 (2013)
-    Vs12,
-    /// Visual Studio 14 (2015)
-    Vs14,
-    /// Visual Studio 15 (2017)
-    Vs15,
-    /// Visual Studio 16 (2019)
-    Vs16,
-
-    /// Hidden variant that should not be matched on. Callers that want to
-    /// handle an enumeration of `VsVers` instances should always have a default
-    /// case meaning that it's a VS version they don't understand.
-    #[doc(hidden)]
-    #[allow(bad_style)]
-    __Nonexhaustive_do_not_match_this_or_your_code_will_break,
-}
-
-/// Find the most recent installed version of Visual Studio
-///
-/// This is used by the cmake crate to figure out the correct
-/// generator.
-#[cfg(not(windows))]
-pub fn find_vs_version() -> Result<VsVers, String> {
-    Err(format!("not windows"))
-}
-
-/// Documented above
-#[cfg(windows)]
-pub fn find_vs_version() -> Result<VsVers, String> {
-    use std::env;
-
-    match env::var("VisualStudioVersion") {
-        Ok(version) => match &version[..] {
-            "16.0" => Ok(VsVers::Vs16),
-            "15.0" => Ok(VsVers::Vs15),
-            "14.0" => Ok(VsVers::Vs14),
-            "12.0" => Ok(VsVers::Vs12),
-            vers => Err(format!(
-                "\n\n\
-                 unsupported or unknown VisualStudio version: {}\n\
-                 if another version is installed consider running \
-                 the appropriate vcvars script before building this \
-                 crate\n\
-                 ",
-                vers
-            )),
-        },
-        _ => {
-            // Check for the presense of a specific registry key
-            // that indicates visual studio is installed.
-            if impl_::has_msbuild_version("16.0") {
-                Ok(VsVers::Vs16)
-            } else if impl_::has_msbuild_version("15.0") {
-                Ok(VsVers::Vs15)
-            } else if impl_::has_msbuild_version("14.0") {
-                Ok(VsVers::Vs14)
-            } else if impl_::has_msbuild_version("12.0") {
-                Ok(VsVers::Vs12)
-            } else {
-                Err(format!(
-                    "\n\n\
-                     couldn't determine visual studio generator\n\
-                     if VisualStudio is installed, however, consider \
-                     running the appropriate vcvars script before building \
-                     this crate\n\
-                     "
-                ))
-            }
-        }
-    }
-}
-
-#[cfg(windows)]
-mod impl_ {
-    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;
-    use std::io::Read;
-    use std::iter;
-    use std::mem;
-    use std::path::{Path, PathBuf};
-
-    use crate::Tool;
-
-    struct MsvcTool {
-        tool: PathBuf,
-        libs: Vec<PathBuf>,
-        path: Vec<PathBuf>,
-        include: Vec<PathBuf>,
-    }
-
-    impl MsvcTool {
-        fn new(tool: PathBuf) -> MsvcTool {
-            MsvcTool {
-                tool: tool,
-                libs: Vec::new(),
-                path: Vec::new(),
-                include: Vec::new(),
-            }
-        }
-
-        fn into_tool(self) -> Tool {
-            let MsvcTool {
-                tool,
-                libs,
-                path,
-                include,
-            } = self;
-            let mut tool = Tool::new(tool.into());
-            add_env(&mut tool, "LIB", libs);
-            add_env(&mut tool, "PATH", path);
-            add_env(&mut tool, "INCLUDE", include);
-            tool
-        }
-    }
-
-    #[allow(bare_trait_objects)]
-    fn vs16_instances() -> Box<Iterator<Item = PathBuf>> {
-        let instances = if let Some(instances) = vs15_instances() {
-            instances
-        } else {
-            return Box::new(iter::empty());
-        };
-        Box::new(instances.filter_map(|instance| {
-            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
-            }
-        }))
-    }
-
-    fn find_tool_in_vs16_path(tool: &str, target: &str) -> Option<Tool> {
-        vs16_instances()
-            .filter_map(|path| {
-                let path = path.join(tool);
-                if !path.is_file() {
-                    return None;
-                }
-                let mut tool = Tool::new(path);
-                if target.contains("x86_64") {
-                    tool.env.push(("Platform".into(), "X64".into()));
-                }
-                Some(tool)
-            })
-            .next()
-    }
-
-    fn find_msbuild_vs16(target: &str) -> Option<Tool> {
-        find_tool_in_vs16_path(r"MSBuild\Current\Bin\MSBuild.exe", target)
-    }
-
-    // In MSVC 15 (2017) MS once again changed the scheme for locating
-    // the tooling.  Now we must go through some COM interfaces, which
-    // is super fun for Rust.
-    //
-    // Note that much of this logic can be found [online] wrt paths, COM, etc.
-    //
-    // [online]: https://blogs.msdn.microsoft.com/vcblog/2017/03/06/finding-the-visual-c-compiler-tools-in-visual-studio-2017/
-    fn vs15_instances() -> Option<EnumSetupInstances> {
-        com::initialize().ok()?;
-
-        let config = SetupConfiguration::new().ok()?;
-        config.enum_all_instances().ok()
-    }
-
-    pub fn find_msvc_15(tool: &str, target: &str) -> Option<Tool> {
-        let iter = vs15_instances()?;
-        for instance in iter {
-            let instance = instance.ok()?;
-            let tool = tool_from_vs15_instance(tool, target, &instance);
-            if tool.is_some() {
-                return tool;
-            }
-        }
-
-        None
-    }
-
-    // While the paths to Visual Studio 2017's devenv and MSBuild could
-    // potentially be retrieved from the registry, finding them via
-    // SetupConfiguration has shown to be [more reliable], and is preferred
-    // according to Microsoft. To help head off potential regressions though,
-    // we keep the registry method as a fallback option.
-    //
-    // [more reliable]: https://github.com/alexcrichton/cc-rs/pull/331
-    fn find_tool_in_vs15_path(tool: &str, target: &str) -> Option<Tool> {
-        let mut path = match vs15_instances() {
-            Some(instances) => instances
-                .filter_map(|instance| {
-                    instance
-                        .ok()
-                        .and_then(|instance| instance.installation_path().ok())
-                })
-                .map(|path| PathBuf::from(path).join(tool))
-                .find(|ref path| path.is_file()),
-            None => None,
-        };
-
-        if path.is_none() {
-            let key = r"SOFTWARE\WOW6432Node\Microsoft\VisualStudio\SxS\VS7";
-            path = LOCAL_MACHINE
-                .open(key.as_ref())
-                .ok()
-                .and_then(|key| key.query_str("15.0").ok())
-                .map(|path| PathBuf::from(path).join(tool))
-                .and_then(|path| if path.is_file() { Some(path) } else { None });
-        }
-
-        path.map(|path| {
-            let mut tool = Tool::new(path);
-            if target.contains("x86_64") {
-                tool.env.push(("Platform".into(), "X64".into()));
-            }
-            tool
-        })
-    }
-
-    fn tool_from_vs15_instance(tool: &str, target: &str, instance: &SetupInstance) -> Option<Tool> {
-        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;
-        };
-
-        let mut tool = MsvcTool::new(tool_path);
-        tool.path.push(host_dylib_path);
-        tool.libs.push(lib_path);
-        tool.include.push(include_path);
-
-        if let Some((atl_lib_path, atl_include_path)) = atl_paths(target, &bin_path) {
-            tool.libs.push(atl_lib_path);
-            tool.include.push(atl_include_path);
-        }
-
-        add_sdks(&mut tool, target)?;
-
-        Some(tool.into_tool())
-    }
-
-    fn vs15_vc_paths(
-        target: &str,
-        instance: &SetupInstance,
-    ) -> Option<(PathBuf, PathBuf, PathBuf, PathBuf)> {
-        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 = File::open(version_path).ok()?;
-        let mut version = String::new();
-        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 = 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
-        // on a given host
-        let bin_path = path
-            .join("bin")
-            .join(&format!("Host{}", host))
-            .join(&target);
-        // But! we also need PATH to contain the target directory for the host
-        // architecture, because it contains dlls like mspdb140.dll compiled for
-        // the host architecture.
-        let host_dylib_path = path
-            .join("bin")
-            .join(&format!("Host{}", host))
-            .join(&host.to_lowercase());
-        let lib_path = path.join("lib").join(&target);
-        let include_path = path.join("include");
-        Some((bin_path, host_dylib_path, lib_path, include_path))
-    }
-
-    fn atl_paths(target: &str, path: &Path) -> Option<(PathBuf, PathBuf)> {
-        let atl_path = path.join("atlfmc");
-        let sub = lib_subdir(target)?;
-        if atl_path.exists() {
-            Some((atl_path.join("lib").join(sub), atl_path.join("include")))
-        } else {
-            None
-        }
-    }
-
-    // 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<Tool> {
-        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 = lib_subdir(target)?;
-        let (ucrt, ucrt_version) = get_ucrt_dir()?;
-
-        tool.path
-            .push(ucrt.join("bin").join(&ucrt_version).join(sub));
-
-        let ucrt_include = ucrt.join("include").join(&ucrt_version);
-        tool.include.push(ucrt_include.join("ucrt"));
-
-        let ucrt_lib = ucrt.join("lib").join(&ucrt_version);
-        tool.libs.push(ucrt_lib.join("ucrt").join(sub));
-
-        if let Some((sdk, version)) = get_sdk10_dir() {
-            tool.path.push(sdk.join("bin").join(sub));
-            let sdk_lib = sdk.join("lib").join(&version);
-            tool.libs.push(sdk_lib.join("um").join(sub));
-            let sdk_include = sdk.join("include").join(&version);
-            tool.include.push(sdk_include.join("um"));
-            tool.include.push(sdk_include.join("cppwinrt"));
-            tool.include.push(sdk_include.join("winrt"));
-            tool.include.push(sdk_include.join("shared"));
-        } else if let Some(sdk) = get_sdk81_dir() {
-            tool.path.push(sdk.join("bin").join(sub));
-            let sdk_lib = sdk.join("lib").join("winv6.3");
-            tool.libs.push(sdk_lib.join("um").join(sub));
-            let sdk_include = sdk.join("include");
-            tool.include.push(sdk_include.join("um"));
-            tool.include.push(sdk_include.join("winrt"));
-            tool.include.push(sdk_include.join("shared"));
-        }
-
-        Some(())
-    }
-
-    // For MSVC 12 we need to find the Windows 8.1 SDK.
-    pub fn find_msvc_12(tool: &str, target: &str) -> Option<Tool> {
-        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));
-        let sdk_include = sdk81.join("include");
-        tool.include.push(sdk_include.join("shared"));
-        tool.include.push(sdk_include.join("um"));
-        tool.include.push(sdk_include.join("winrt"));
-        Some(tool.into_tool())
-    }
-
-    // For MSVC 11 we need to find the Windows 8 SDK.
-    pub fn find_msvc_11(tool: &str, target: &str) -> Option<Tool> {
-        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));
-        let sdk_include = sdk8.join("include");
-        tool.include.push(sdk_include.join("shared"));
-        tool.include.push(sdk_include.join("um"));
-        tool.include.push(sdk_include.join("winrt"));
-        Some(tool.into_tool())
-    }
-
-    fn add_env(tool: &mut Tool, env: &str, paths: Vec<PathBuf>) {
-        let prev = env::var_os(env).unwrap_or(OsString::new());
-        let prev = env::split_paths(&prev);
-        let new = paths.into_iter().chain(prev);
-        tool.env
-            .push((env.to_string().into(), env::join_paths(new).unwrap()));
-    }
-
-    // Given a possible MSVC installation directory, we look for the linker and
-    // then add the MSVC library path.
-    fn get_tool(tool: &str, path: &Path, target: &str) -> Option<MsvcTool> {
-        bin_subdir(target)
-            .into_iter()
-            .map(|(sub, host)| {
-                (
-                    path.join("bin").join(sub).join(tool),
-                    path.join("bin").join(host),
-                )
-            })
-            .filter(|&(ref path, _)| path.is_file())
-            .map(|(path, host)| {
-                let mut tool = MsvcTool::new(path);
-                tool.path.push(host);
-                tool
-            })
-            .filter_map(|mut tool| {
-                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");
-                if atlmfc_path.exists() {
-                    tool.libs.push(atlmfc_path.join("lib").join(sub));
-                    tool.include.push(atlmfc_path.join("include"));
-                }
-                Some(tool)
-            })
-            .next()
-    }
-
-    // To find MSVC we look in a specific registry key for the version we are
-    // trying to find.
-    fn get_vc_dir(ver: &str) -> Option<PathBuf> {
-        let key = r"SOFTWARE\Microsoft\VisualStudio\SxS\VC7";
-        let key = LOCAL_MACHINE.open(key.as_ref()).ok()?;
-        let path = key.query_str(ver).ok()?;
-        Some(path.into())
-    }
-
-    // To find the Universal CRT we look in a specific registry key for where
-    // all the Universal CRTs are located and then sort them asciibetically to
-    // find the newest version. While this sort of sorting isn't ideal,  it is
-    // what vcvars does so that's good enough for us.
-    //
-    // 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 = 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()?;
-        let version = max_libdir.components().last().unwrap();
-        let version = version.as_os_str().to_str().unwrap().to_string();
-        Some((root.into(), version))
-    }
-
-    // Vcvars finds the correct version of the Windows 10 SDK by looking
-    // for the include `um\Windows.h` because sometimes a given version will
-    // only have UCRT bits without the rest of the SDK. Since we only care about
-    // libraries and not includes, we instead look for `um\x64\kernel32.lib`.
-    // Since the 32-bit and 64-bit libraries are always installed together we
-    // only need to bother checking x64, making this code a tiny bit simpler.
-    // Like we do for the Universal CRT, we sort the possibilities
-    // 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 = 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::<Vec<_>>();
-        dirs.sort();
-        let dir = dirs
-            .into_iter()
-            .rev()
-            .filter(|dir| dir.join("um").join("x64").join("kernel32.lib").is_file())
-            .next()?;
-        let version = dir.components().last().unwrap();
-        let version = version.as_os_str().to_str().unwrap().to_string();
-        Some((root.into(), version))
-    }
-
-    // Interestingly there are several subdirectories, `win7` `win8` and
-    // `winv6.3`. Vcvars seems to only care about `winv6.3` though, so the same
-    // applies to us. Note that if we were targetting kernel mode drivers
-    // instead of user mode applications, we would care.
-    fn get_sdk81_dir() -> Option<PathBuf> {
-        let key = r"SOFTWARE\Microsoft\Microsoft SDKs\Windows\v8.1";
-        let key = LOCAL_MACHINE.open(key.as_ref()).ok()?;
-        let root = key.query_str("InstallationFolder").ok()?;
-        Some(root.into())
-    }
-
-    fn get_sdk8_dir() -> Option<PathBuf> {
-        let key = r"SOFTWARE\Microsoft\Microsoft SDKs\Windows\v8.0";
-        let key = LOCAL_MACHINE.open(key.as_ref()).ok()?;
-        let root = key.query_str("InstallationFolder").ok()?;
-        Some(root.into())
-    }
-
-    const PROCESSOR_ARCHITECTURE_INTEL: u16 = 0;
-    const PROCESSOR_ARCHITECTURE_AMD64: u16 = 9;
-    const X86: u16 = PROCESSOR_ARCHITECTURE_INTEL;
-    const X86_64: u16 = PROCESSOR_ARCHITECTURE_AMD64;
-
-    // When choosing the tool to use, we have to choose the one which matches
-    // the target architecture. Otherwise we end up in situations where someone
-    // on 32-bit Windows is trying to cross compile to 64-bit and it tries to
-    // invoke the native 64-bit compiler which won't work.
-    //
-    // For the return value of this function, the first member of the tuple is
-    // the folder of the tool we will be invoking, while the second member is
-    // the folder of the host toolchain for that tool which is essential when
-    // using a cross linker. We return a Vec since on x64 there are often two
-    // linkers that can target the architecture we desire. The 64-bit host
-    // linker is preferred, and hence first, due to 64-bit allowing it more
-    // address space to work with and potentially being faster.
-    fn bin_subdir(target: &str) -> Vec<(&'static str, &'static str)> {
-        let arch = target.split('-').next().unwrap();
-        match (arch, host_arch()) {
-            ("i586", X86) | ("i686", X86) => vec![("", "")],
-            ("i586", X86_64) | ("i686", X86_64) => vec![("amd64_x86", "amd64"), ("", "")],
-            ("x86_64", X86) => vec![("x86_amd64", "")],
-            ("x86_64", X86_64) => vec![("amd64", "amd64"), ("x86_amd64", "")],
-            ("arm", X86) | ("thumbv7a", X86) => vec![("x86_arm", "")],
-            ("arm", X86_64) | ("thumbv7a", X86_64) => vec![("amd64_arm", "amd64"), ("x86_arm", "")],
-            _ => vec![],
-        }
-    }
-
-    fn lib_subdir(target: &str) -> Option<&'static str> {
-        let arch = target.split('-').next().unwrap();
-        match arch {
-            "i586" | "i686" => Some("x86"),
-            "x86_64" => Some("x64"),
-            "arm" | "thumbv7a" => Some("arm"),
-            "aarch64" => Some("arm64"),
-            _ => None,
-        }
-    }
-
-    // MSVC's x86 libraries are not in a subfolder
-    fn vc_lib_subdir(target: &str) -> Option<&'static str> {
-        let arch = target.split('-').next().unwrap();
-        match arch {
-            "i586" | "i686" => Some(""),
-            "x86_64" => Some("amd64"),
-            "arm" | "thumbv7a" => Some("arm"),
-            "aarch64" => Some("arm64"),
-            _ => None,
-        }
-    }
-
-    #[allow(bad_style)]
-    fn host_arch() -> u16 {
-        type DWORD = u32;
-        type WORD = u16;
-        type LPVOID = *mut u8;
-        type DWORD_PTR = usize;
-
-        #[repr(C)]
-        struct SYSTEM_INFO {
-            wProcessorArchitecture: WORD,
-            _wReserved: WORD,
-            _dwPageSize: DWORD,
-            _lpMinimumApplicationAddress: LPVOID,
-            _lpMaximumApplicationAddress: LPVOID,
-            _dwActiveProcessorMask: DWORD_PTR,
-            _dwNumberOfProcessors: DWORD,
-            _dwProcessorType: DWORD,
-            _dwAllocationGranularity: DWORD,
-            _wProcessorLevel: WORD,
-            _wProcessorRevision: WORD,
-        }
-
-        extern "system" {
-            fn GetNativeSystemInfo(lpSystemInfo: *mut SYSTEM_INFO);
-        }
-
-        unsafe {
-            let mut info = mem::zeroed();
-            GetNativeSystemInfo(&mut info);
-            info.wProcessorArchitecture
-        }
-    }
-
-    // Given a registry key, look at all the sub keys and find the one which has
-    // the maximal numeric value.
-    //
-    // Returns the name of the maximal key as well as the opened maximal key.
-    fn max_version(key: &RegistryKey) -> Option<(OsString, RegistryKey)> {
-        let mut max_vers = 0;
-        let mut max_key = None;
-        for subkey in key.iter().filter_map(|k| k.ok()) {
-            let val = subkey
-                .to_str()
-                .and_then(|s| s.trim_left_matches("v").replace(".", "").parse().ok());
-            let val = match val {
-                Some(s) => s,
-                None => continue,
-            };
-            if val > max_vers {
-                if let Ok(k) = key.open(&subkey) {
-                    max_vers = val;
-                    max_key = Some((subkey, k));
-                }
-            }
-        }
-        max_key
-    }
-
-    pub fn has_msbuild_version(version: &str) -> bool {
-        match version {
-            "16.0" => {
-                find_msbuild_vs16("x86_64-pc-windows-msvc").is_some()
-                    || find_msbuild_vs16("i686-pc-windows-msvc").is_some()
-            }
-            "15.0" => {
-                find_msbuild_vs15("x86_64-pc-windows-msvc").is_some()
-                    || find_msbuild_vs15("i686-pc-windows-msvc").is_some()
-            }
-            "12.0" | "14.0" => LOCAL_MACHINE
-                .open(&OsString::from(format!(
-                    "SOFTWARE\\Microsoft\\MSBuild\\ToolsVersions\\{}",
-                    version
-                )))
-                .is_ok(),
-            _ => false,
-        }
-    }
-
-    pub fn find_devenv(target: &str) -> Option<Tool> {
-        find_devenv_vs15(&target)
-    }
-
-    fn find_devenv_vs15(target: &str) -> Option<Tool> {
-        find_tool_in_vs15_path(r"Common7\IDE\devenv.exe", target)
-    }
-
-    // see http://stackoverflow.com/questions/328017/path-to-msbuild
-    pub fn find_msbuild(target: &str) -> Option<Tool> {
-        // VS 15 (2017) changed how to locate msbuild
-        if let Some(r) = find_msbuild_vs16(target) {
-            return Some(r);
-        } else if let Some(r) = find_msbuild_vs15(target) {
-            return Some(r);
-        } else {
-            find_old_msbuild(target)
-        }
-    }
-
-    fn find_msbuild_vs15(target: &str) -> Option<Tool> {
-        find_tool_in_vs15_path(r"MSBuild\15.0\Bin\MSBuild.exe", target)
-    }
-
-    fn find_old_msbuild(target: &str) -> Option<Tool> {
-        let key = r"SOFTWARE\Microsoft\MSBuild\ToolsVersions";
-        LOCAL_MACHINE
-            .open(key.as_ref())
-            .ok()
-            .and_then(|key| {
-                max_version(&key).and_then(|(_vers, key)| key.query_str("MSBuildToolsPath").ok())
-            })
-            .map(|path| {
-                let mut path = PathBuf::from(path);
-                path.push("MSBuild.exe");
-                let mut tool = Tool::new(path);
-                if target.contains("x86_64") {
-                    tool.env.push(("Platform".into(), "X64".into()));
-                }
-                tool
-            })
-    }
-}