chore: add vendor directory

4 files changed, 1233 insertions, 0 deletions

diff --git a/vendor/cc/src/target/apple.rs b/vendor/cc/src/target/apple.rs
new file mode 100644
index 00000000..bd65e00f
--- /dev/null
+++ b/vendor/cc/src/target/apple.rs
@@ -0,0 +1,49 @@
+use super::TargetInfo;
+
+impl TargetInfo<'_> {
+    pub(crate) fn apple_sdk_name(&self) -> &'static str {
+        match (self.os, self.abi) {
+            ("macos", "") => "macosx",
+            ("ios", "") => "iphoneos",
+            ("ios", "sim") => "iphonesimulator",
+            ("ios", "macabi") => "macosx",
+            ("tvos", "") => "appletvos",
+            ("tvos", "sim") => "appletvsimulator",
+            ("watchos", "") => "watchos",
+            ("watchos", "sim") => "watchsimulator",
+            ("visionos", "") => "xros",
+            ("visionos", "sim") => "xrsimulator",
+            (os, _) => panic!("invalid Apple target OS {}", os),
+        }
+    }
+
+    pub(crate) fn apple_version_flag(&self, min_version: &str) -> String {
+        // There are many aliases for these, and `-mtargetos=` is preferred on Clang nowadays, but
+        // for compatibility with older Clang, we use the earliest supported name here.
+        //
+        // NOTE: GCC does not support `-miphoneos-version-min=` etc. (because it does not support
+        // iOS in general), but we specify them anyhow in case we actually have a Clang-like
+        // compiler disguised as a GNU-like compiler, or in case GCC adds support for these in the
+        // future.
+        //
+        // See also:
+        // https://clang.llvm.org/docs/ClangCommandLineReference.html#cmdoption-clang-mmacos-version-min
+        // https://clang.llvm.org/docs/AttributeReference.html#availability
+        // https://gcc.gnu.org/onlinedocs/gcc/Darwin-Options.html#index-mmacosx-version-min
+        match (self.os, self.abi) {
+            ("macos", "") => format!("-mmacosx-version-min={min_version}"),
+            ("ios", "") => format!("-miphoneos-version-min={min_version}"),
+            ("ios", "sim") => format!("-mios-simulator-version-min={min_version}"),
+            ("ios", "macabi") => format!("-mtargetos=ios{min_version}-macabi"),
+            ("tvos", "") => format!("-mappletvos-version-min={min_version}"),
+            ("tvos", "sim") => format!("-mappletvsimulator-version-min={min_version}"),
+            ("watchos", "") => format!("-mwatchos-version-min={min_version}"),
+            ("watchos", "sim") => format!("-mwatchsimulator-version-min={min_version}"),
+            // `-mxros-version-min` does not exist
+            // https://github.com/llvm/llvm-project/issues/88271
+            ("visionos", "") => format!("-mtargetos=xros{min_version}"),
+            ("visionos", "sim") => format!("-mtargetos=xros{min_version}-simulator"),
+            (os, _) => panic!("invalid Apple target OS {}", os),
+        }
+    }
+}
diff --git a/vendor/cc/src/target/generated.rs b/vendor/cc/src/target/generated.rs
new file mode 100644
index 00000000..7db389d9
--- /dev/null
+++ b/vendor/cc/src/target/generated.rs
@@ -0,0 +1,306 @@
+//! This file is generated code. Please edit the generator in
+//! dev-tools/gen-target-info if you need to make changes, or see
+//! src/target/llvm.rs if you need to configure a specific LLVM triple.
+
+#[rustfmt::skip]
+pub(crate) const LLVM_TARGETS: &[(&str, &str)] = &[
+    ("aarch64-apple-darwin", "arm64-apple-macosx"),
+    ("aarch64-apple-ios", "arm64-apple-ios"),
+    ("aarch64-apple-ios-macabi", "arm64-apple-ios-macabi"),
+    ("aarch64-apple-ios-sim", "arm64-apple-ios-simulator"),
+    ("aarch64-apple-tvos", "arm64-apple-tvos"),
+    ("aarch64-apple-tvos-sim", "arm64-apple-tvos-simulator"),
+    ("aarch64-apple-visionos", "arm64-apple-xros"),
+    ("aarch64-apple-visionos-sim", "arm64-apple-xros-simulator"),
+    ("aarch64-apple-watchos", "arm64-apple-watchos"),
+    ("aarch64-apple-watchos-sim", "arm64-apple-watchos-simulator"),
+    ("aarch64-fuchsia", "aarch64-fuchsia"),
+    ("aarch64-kmc-solid_asp3", "aarch64-unknown-none"),
+    ("aarch64-linux-android", "aarch64-linux-android"),
+    ("aarch64-nintendo-switch-freestanding", "aarch64-unknown-none"),
+    ("aarch64-pc-windows-gnullvm", "aarch64-pc-windows-gnu"),
+    ("aarch64-pc-windows-msvc", "aarch64-pc-windows-msvc"),
+    ("aarch64-unknown-freebsd", "aarch64-unknown-freebsd"),
+    ("aarch64-unknown-fuchsia", "aarch64-unknown-fuchsia"),
+    ("aarch64-unknown-hermit", "aarch64-unknown-hermit"),
+    ("aarch64-unknown-illumos", "aarch64-unknown-solaris2.11"),
+    ("aarch64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"),
+    ("aarch64-unknown-linux-gnu_ilp32", "aarch64-unknown-linux-gnu_ilp32"),
+    ("aarch64-unknown-linux-musl", "aarch64-unknown-linux-musl"),
+    ("aarch64-unknown-linux-ohos", "aarch64-unknown-linux-ohos"),
+    ("aarch64-unknown-netbsd", "aarch64-unknown-netbsd"),
+    ("aarch64-unknown-none", "aarch64-unknown-none"),
+    ("aarch64-unknown-none-softfloat", "aarch64-unknown-none"),
+    ("aarch64-unknown-nto-qnx700", "aarch64-unknown-unknown"),
+    ("aarch64-unknown-nto-qnx710", "aarch64-unknown-unknown"),
+    ("aarch64-unknown-nto-qnx710_iosock", "aarch64-unknown-unknown"),
+    ("aarch64-unknown-nto-qnx800", "aarch64-unknown-unknown"),
+    ("aarch64-unknown-nuttx", "aarch64-unknown-none"),
+    ("aarch64-unknown-openbsd", "aarch64-unknown-openbsd"),
+    ("aarch64-unknown-redox", "aarch64-unknown-redox"),
+    ("aarch64-unknown-teeos", "aarch64-unknown-none"),
+    ("aarch64-unknown-trusty", "aarch64-unknown-unknown-musl"),
+    ("aarch64-unknown-uefi", "aarch64-unknown-windows"),
+    ("aarch64-uwp-windows-msvc", "aarch64-pc-windows-msvc"),
+    ("aarch64-wrs-vxworks", "aarch64-unknown-linux-gnu"),
+    ("aarch64_be-unknown-linux-gnu", "aarch64_be-unknown-linux-gnu"),
+    ("aarch64_be-unknown-linux-gnu_ilp32", "aarch64_be-unknown-linux-gnu_ilp32"),
+    ("aarch64_be-unknown-netbsd", "aarch64_be-unknown-netbsd"),
+    ("amdgcn-amd-amdhsa", "amdgcn-amd-amdhsa"),
+    ("arm-linux-androideabi", "arm-linux-androideabi"),
+    ("arm-unknown-linux-gnueabi", "arm-unknown-linux-gnueabi"),
+    ("arm-unknown-linux-gnueabihf", "arm-unknown-linux-gnueabihf"),
+    ("arm-unknown-linux-musleabi", "arm-unknown-linux-musleabi"),
+    ("arm-unknown-linux-musleabihf", "arm-unknown-linux-musleabihf"),
+    ("arm64_32-apple-watchos", "arm64_32-apple-watchos"),
+    ("arm64e-apple-darwin", "arm64e-apple-macosx"),
+    ("arm64e-apple-ios", "arm64e-apple-ios"),
+    ("arm64e-apple-tvos", "arm64e-apple-tvos"),
+    ("arm64ec-pc-windows-msvc", "arm64ec-pc-windows-msvc"),
+    ("armeb-unknown-linux-gnueabi", "armeb-unknown-linux-gnueabi"),
+    ("armebv7r-none-eabi", "armebv7r-none-eabi"),
+    ("armebv7r-none-eabihf", "armebv7r-none-eabihf"),
+    ("armv4t-none-eabi", "armv4t-none-eabi"),
+    ("armv4t-unknown-linux-gnueabi", "armv4t-unknown-linux-gnueabi"),
+    ("armv5te-none-eabi", "armv5te-none-eabi"),
+    ("armv5te-unknown-linux-gnueabi", "armv5te-unknown-linux-gnueabi"),
+    ("armv5te-unknown-linux-musleabi", "armv5te-unknown-linux-musleabi"),
+    ("armv5te-unknown-linux-uclibceabi", "armv5te-unknown-linux-gnueabi"),
+    ("armv6-unknown-freebsd", "armv6-unknown-freebsd-gnueabihf"),
+    ("armv6-unknown-netbsd-eabihf", "armv6-unknown-netbsdelf-eabihf"),
+    ("armv6k-nintendo-3ds", "armv6k-none-eabihf"),
+    ("armv7-apple-ios", "armv7-apple-ios7.0.0"),
+    ("armv7-linux-androideabi", "armv7-none-linux-android"),
+    ("armv7-rtems-eabihf", "armv7-unknown-none-eabihf"),
+    ("armv7-sony-vita-newlibeabihf", "thumbv7a-sony-vita-eabihf"),
+    ("armv7-unknown-freebsd", "armv7-unknown-freebsd-gnueabihf"),
+    ("armv7-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabi"),
+    ("armv7-unknown-linux-gnueabihf", "armv7-unknown-linux-gnueabihf"),
+    ("armv7-unknown-linux-musleabi", "armv7-unknown-linux-musleabi"),
+    ("armv7-unknown-linux-musleabihf", "armv7-unknown-linux-musleabihf"),
+    ("armv7-unknown-linux-ohos", "armv7-unknown-linux-ohos"),
+    ("armv7-unknown-linux-uclibceabi", "armv7-unknown-linux-gnueabi"),
+    ("armv7-unknown-linux-uclibceabihf", "armv7-unknown-linux-gnueabihf"),
+    ("armv7-unknown-netbsd-eabihf", "armv7-unknown-netbsdelf-eabihf"),
+    ("armv7-unknown-trusty", "armv7-unknown-unknown-gnueabi"),
+    ("armv7-wrs-vxworks-eabihf", "armv7-unknown-linux-gnueabihf"),
+    ("armv7a-kmc-solid_asp3-eabi", "armv7a-none-eabi"),
+    ("armv7a-kmc-solid_asp3-eabihf", "armv7a-none-eabihf"),
+    ("armv7a-none-eabi", "armv7a-none-eabi"),
+    ("armv7a-none-eabihf", "armv7a-none-eabihf"),
+    ("armv7a-nuttx-eabi", "armv7a-none-eabi"),
+    ("armv7a-nuttx-eabihf", "armv7a-none-eabihf"),
+    ("armv7k-apple-watchos", "armv7k-apple-watchos"),
+    ("armv7r-none-eabi", "armv7r-none-eabi"),
+    ("armv7r-none-eabihf", "armv7r-none-eabihf"),
+    ("armv7s-apple-ios", "armv7s-apple-ios"),
+    ("armv8r-none-eabihf", "armv8r-none-eabihf"),
+    ("asmjs-unknown-emscripten", "wasm32-unknown-emscripten"),
+    ("avr-none", "avr-unknown-unknown"),
+    ("avr-unknown-gnu-atmega328", "avr-unknown-unknown"),
+    ("bpfeb-unknown-none", "bpfeb"),
+    ("bpfel-unknown-none", "bpfel"),
+    ("csky-unknown-linux-gnuabiv2", "csky-unknown-linux-gnuabiv2"),
+    ("csky-unknown-linux-gnuabiv2hf", "csky-unknown-linux-gnuabiv2"),
+    ("hexagon-unknown-linux-musl", "hexagon-unknown-linux-musl"),
+    ("hexagon-unknown-none-elf", "hexagon-unknown-none-elf"),
+    ("i386-apple-ios", "i386-apple-ios-simulator"),
+    ("i586-pc-windows-msvc", "i586-pc-windows-msvc"),
+    ("i586-unknown-linux-gnu", "i586-unknown-linux-gnu"),
+    ("i586-unknown-linux-musl", "i586-unknown-linux-musl"),
+    ("i586-unknown-netbsd", "i586-unknown-netbsdelf"),
+    ("i586-unknown-redox", "i586-unknown-redox"),
+    ("i686-apple-darwin", "i686-apple-macosx"),
+    ("i686-linux-android", "i686-linux-android"),
+    ("i686-pc-nto-qnx700", "i586-pc-unknown"),
+    ("i686-pc-windows-gnu", "i686-pc-windows-gnu"),
+    ("i686-pc-windows-gnullvm", "i686-pc-windows-gnu"),
+    ("i686-pc-windows-msvc", "i686-pc-windows-msvc"),
+    ("i686-unknown-freebsd", "i686-unknown-freebsd"),
+    ("i686-unknown-haiku", "i686-unknown-haiku"),
+    ("i686-unknown-hurd-gnu", "i686-unknown-hurd-gnu"),
+    ("i686-unknown-linux-gnu", "i686-unknown-linux-gnu"),
+    ("i686-unknown-linux-musl", "i686-unknown-linux-musl"),
+    ("i686-unknown-netbsd", "i686-unknown-netbsdelf"),
+    ("i686-unknown-openbsd", "i686-unknown-openbsd"),
+    ("i686-unknown-uefi", "i686-unknown-windows-gnu"),
+    ("i686-uwp-windows-gnu", "i686-pc-windows-gnu"),
+    ("i686-uwp-windows-msvc", "i686-pc-windows-msvc"),
+    ("i686-win7-windows-gnu", "i686-pc-windows-gnu"),
+    ("i686-win7-windows-msvc", "i686-pc-windows-msvc"),
+    ("i686-wrs-vxworks", "i686-unknown-linux-gnu"),
+    ("loongarch32-unknown-none", "loongarch32-unknown-none"),
+    ("loongarch32-unknown-none-softfloat", "loongarch32-unknown-none"),
+    ("loongarch64-unknown-linux-gnu", "loongarch64-unknown-linux-gnu"),
+    ("loongarch64-unknown-linux-musl", "loongarch64-unknown-linux-musl"),
+    ("loongarch64-unknown-linux-ohos", "loongarch64-unknown-linux-ohos"),
+    ("loongarch64-unknown-none", "loongarch64-unknown-none"),
+    ("loongarch64-unknown-none-softfloat", "loongarch64-unknown-none"),
+    ("m68k-unknown-linux-gnu", "m68k-unknown-linux-gnu"),
+    ("m68k-unknown-none-elf", "m68k"),
+    ("mips-mti-none-elf", "mips"),
+    ("mips-unknown-linux-gnu", "mips-unknown-linux-gnu"),
+    ("mips-unknown-linux-musl", "mips-unknown-linux-musl"),
+    ("mips-unknown-linux-uclibc", "mips-unknown-linux-gnu"),
+    ("mips64-openwrt-linux-musl", "mips64-unknown-linux-musl"),
+    ("mips64-unknown-linux-gnuabi64", "mips64-unknown-linux-gnuabi64"),
+    ("mips64-unknown-linux-muslabi64", "mips64-unknown-linux-musl"),
+    ("mips64el-unknown-linux-gnuabi64", "mips64el-unknown-linux-gnuabi64"),
+    ("mips64el-unknown-linux-muslabi64", "mips64el-unknown-linux-musl"),
+    ("mipsel-mti-none-elf", "mipsel"),
+    ("mipsel-sony-psp", "mipsel-sony-psp"),
+    ("mipsel-sony-psx", "mipsel-sony-psx"),
+    ("mipsel-unknown-linux-gnu", "mipsel-unknown-linux-gnu"),
+    ("mipsel-unknown-linux-musl", "mipsel-unknown-linux-musl"),
+    ("mipsel-unknown-linux-uclibc", "mipsel-unknown-linux-gnu"),
+    ("mipsel-unknown-netbsd", "mipsel-unknown-netbsd"),
+    ("mipsel-unknown-none", "mipsel-unknown-none"),
+    ("mipsisa32r6-unknown-linux-gnu", "mipsisa32r6-unknown-linux-gnu"),
+    ("mipsisa32r6el-unknown-linux-gnu", "mipsisa32r6el-unknown-linux-gnu"),
+    ("mipsisa64r6-unknown-linux-gnuabi64", "mipsisa64r6-unknown-linux-gnuabi64"),
+    ("mipsisa64r6el-unknown-linux-gnuabi64", "mipsisa64r6el-unknown-linux-gnuabi64"),
+    ("msp430-none-elf", "msp430-none-elf"),
+    ("nvptx64-nvidia-cuda", "nvptx64-nvidia-cuda"),
+    ("powerpc-unknown-freebsd", "powerpc-unknown-freebsd13.0"),
+    ("powerpc-unknown-linux-gnu", "powerpc-unknown-linux-gnu"),
+    ("powerpc-unknown-linux-gnuspe", "powerpc-unknown-linux-gnuspe"),
+    ("powerpc-unknown-linux-musl", "powerpc-unknown-linux-musl"),
+    ("powerpc-unknown-linux-muslspe", "powerpc-unknown-linux-muslspe"),
+    ("powerpc-unknown-netbsd", "powerpc-unknown-netbsd"),
+    ("powerpc-unknown-openbsd", "powerpc-unknown-openbsd"),
+    ("powerpc-wrs-vxworks", "powerpc-unknown-linux-gnu"),
+    ("powerpc-wrs-vxworks-spe", "powerpc-unknown-linux-gnuspe"),
+    ("powerpc64-ibm-aix", "powerpc64-ibm-aix"),
+    ("powerpc64-unknown-freebsd", "powerpc64-unknown-freebsd"),
+    ("powerpc64-unknown-linux-gnu", "powerpc64-unknown-linux-gnu"),
+    ("powerpc64-unknown-linux-musl", "powerpc64-unknown-linux-musl"),
+    ("powerpc64-unknown-openbsd", "powerpc64-unknown-openbsd"),
+    ("powerpc64-wrs-vxworks", "powerpc64-unknown-linux-gnu"),
+    ("powerpc64le-unknown-freebsd", "powerpc64le-unknown-freebsd"),
+    ("powerpc64le-unknown-linux-gnu", "powerpc64le-unknown-linux-gnu"),
+    ("powerpc64le-unknown-linux-musl", "powerpc64le-unknown-linux-musl"),
+    ("riscv32-wrs-vxworks", "riscv32-unknown-linux-gnu"),
+    ("riscv32e-unknown-none-elf", "riscv32"),
+    ("riscv32em-unknown-none-elf", "riscv32"),
+    ("riscv32emc-unknown-none-elf", "riscv32"),
+    ("riscv32gc-unknown-linux-gnu", "riscv32-unknown-linux-gnu"),
+    ("riscv32gc-unknown-linux-musl", "riscv32-unknown-linux-musl"),
+    ("riscv32i-unknown-none-elf", "riscv32"),
+    ("riscv32im-risc0-zkvm-elf", "riscv32"),
+    ("riscv32im-unknown-none-elf", "riscv32"),
+    ("riscv32ima-unknown-none-elf", "riscv32"),
+    ("riscv32imac-esp-espidf", "riscv32"),
+    ("riscv32imac-unknown-none-elf", "riscv32"),
+    ("riscv32imac-unknown-nuttx-elf", "riscv32"),
+    ("riscv32imac-unknown-xous-elf", "riscv32"),
+    ("riscv32imafc-esp-espidf", "riscv32"),
+    ("riscv32imafc-unknown-none-elf", "riscv32"),
+    ("riscv32imafc-unknown-nuttx-elf", "riscv32"),
+    ("riscv32imc-esp-espidf", "riscv32"),
+    ("riscv32imc-unknown-none-elf", "riscv32"),
+    ("riscv32imc-unknown-nuttx-elf", "riscv32"),
+    ("riscv64-linux-android", "riscv64-linux-android"),
+    ("riscv64-wrs-vxworks", "riscv64-unknown-linux-gnu"),
+    ("riscv64gc-unknown-freebsd", "riscv64-unknown-freebsd"),
+    ("riscv64gc-unknown-fuchsia", "riscv64-unknown-fuchsia"),
+    ("riscv64gc-unknown-hermit", "riscv64-unknown-hermit"),
+    ("riscv64gc-unknown-linux-gnu", "riscv64-unknown-linux-gnu"),
+    ("riscv64gc-unknown-linux-musl", "riscv64-unknown-linux-musl"),
+    ("riscv64gc-unknown-netbsd", "riscv64-unknown-netbsd"),
+    ("riscv64gc-unknown-none-elf", "riscv64"),
+    ("riscv64gc-unknown-nuttx-elf", "riscv64"),
+    ("riscv64gc-unknown-openbsd", "riscv64-unknown-openbsd"),
+    ("riscv64imac-unknown-none-elf", "riscv64"),
+    ("riscv64imac-unknown-nuttx-elf", "riscv64"),
+    ("s390x-unknown-linux-gnu", "s390x-unknown-linux-gnu"),
+    ("s390x-unknown-linux-musl", "s390x-unknown-linux-musl"),
+    ("sparc-unknown-linux-gnu", "sparc-unknown-linux-gnu"),
+    ("sparc-unknown-none-elf", "sparc-unknown-none-elf"),
+    ("sparc64-unknown-linux-gnu", "sparc64-unknown-linux-gnu"),
+    ("sparc64-unknown-netbsd", "sparc64-unknown-netbsd"),
+    ("sparc64-unknown-openbsd", "sparc64-unknown-openbsd"),
+    ("sparcv9-sun-solaris", "sparcv9-sun-solaris"),
+    ("thumbv4t-none-eabi", "thumbv4t-none-eabi"),
+    ("thumbv5te-none-eabi", "thumbv5te-none-eabi"),
+    ("thumbv6m-none-eabi", "thumbv6m-none-eabi"),
+    ("thumbv6m-nuttx-eabi", "thumbv6m-none-eabi"),
+    ("thumbv7a-nuttx-eabi", "thumbv7a-none-eabi"),
+    ("thumbv7a-nuttx-eabihf", "thumbv7a-none-eabihf"),
+    ("thumbv7a-pc-windows-msvc", "thumbv7a-pc-windows-msvc"),
+    ("thumbv7a-uwp-windows-msvc", "thumbv7a-pc-windows-msvc"),
+    ("thumbv7em-none-eabi", "thumbv7em-none-eabi"),
+    ("thumbv7em-none-eabihf", "thumbv7em-none-eabihf"),
+    ("thumbv7em-nuttx-eabi", "thumbv7em-none-eabi"),
+    ("thumbv7em-nuttx-eabihf", "thumbv7em-none-eabihf"),
+    ("thumbv7m-none-eabi", "thumbv7m-none-eabi"),
+    ("thumbv7m-nuttx-eabi", "thumbv7m-none-eabi"),
+    ("thumbv7neon-linux-androideabi", "armv7-none-linux-android"),
+    ("thumbv7neon-unknown-linux-gnueabihf", "armv7-unknown-linux-gnueabihf"),
+    ("thumbv7neon-unknown-linux-musleabihf", "armv7-unknown-linux-musleabihf"),
+    ("thumbv8m.base-none-eabi", "thumbv8m.base-none-eabi"),
+    ("thumbv8m.base-nuttx-eabi", "thumbv8m.base-none-eabi"),
+    ("thumbv8m.main-none-eabi", "thumbv8m.main-none-eabi"),
+    ("thumbv8m.main-none-eabihf", "thumbv8m.main-none-eabihf"),
+    ("thumbv8m.main-nuttx-eabi", "thumbv8m.main-none-eabi"),
+    ("thumbv8m.main-nuttx-eabihf", "thumbv8m.main-none-eabihf"),
+    ("wasm32-unknown-emscripten", "wasm32-unknown-emscripten"),
+    ("wasm32-unknown-unknown", "wasm32-unknown-unknown"),
+    ("wasm32-wali-linux-musl", "wasm32-wasi"),
+    ("wasm32-wasi", "wasm32-wasi"),
+    ("wasm32-wasip1", "wasm32-wasip1"),
+    ("wasm32-wasip1-threads", "wasm32-wasi"),
+    ("wasm32-wasip2", "wasm32-wasip2"),
+    ("wasm32v1-none", "wasm32-unknown-unknown"),
+    ("wasm64-unknown-unknown", "wasm64-unknown-unknown"),
+    ("x86_64-apple-darwin", "x86_64-apple-macosx"),
+    ("x86_64-apple-ios", "x86_64-apple-ios-simulator"),
+    ("x86_64-apple-ios-macabi", "x86_64-apple-ios-macabi"),
+    ("x86_64-apple-tvos", "x86_64-apple-tvos-simulator"),
+    ("x86_64-apple-watchos-sim", "x86_64-apple-watchos-simulator"),
+    ("x86_64-fortanix-unknown-sgx", "x86_64-elf"),
+    ("x86_64-fuchsia", "x86_64-fuchsia"),
+    ("x86_64-linux-android", "x86_64-linux-android"),
+    ("x86_64-lynx-lynxos178", "x86_64-unknown-unknown-gnu"),
+    ("x86_64-pc-cygwin", "x86_64-pc-cygwin"),
+    ("x86_64-pc-nto-qnx710", "x86_64-pc-unknown"),
+    ("x86_64-pc-nto-qnx710_iosock", "x86_64-pc-unknown"),
+    ("x86_64-pc-nto-qnx800", "x86_64-pc-unknown"),
+    ("x86_64-pc-solaris", "x86_64-pc-solaris"),
+    ("x86_64-pc-windows-gnu", "x86_64-pc-windows-gnu"),
+    ("x86_64-pc-windows-gnullvm", "x86_64-pc-windows-gnu"),
+    ("x86_64-pc-windows-msvc", "x86_64-pc-windows-msvc"),
+    ("x86_64-sun-solaris", "x86_64-pc-solaris"),
+    ("x86_64-unikraft-linux-musl", "x86_64-unknown-linux-musl"),
+    ("x86_64-unknown-dragonfly", "x86_64-unknown-dragonfly"),
+    ("x86_64-unknown-freebsd", "x86_64-unknown-freebsd"),
+    ("x86_64-unknown-fuchsia", "x86_64-unknown-fuchsia"),
+    ("x86_64-unknown-haiku", "x86_64-unknown-haiku"),
+    ("x86_64-unknown-hermit", "x86_64-unknown-hermit"),
+    ("x86_64-unknown-hurd-gnu", "x86_64-unknown-hurd-gnu"),
+    ("x86_64-unknown-illumos", "x86_64-pc-solaris"),
+    ("x86_64-unknown-l4re-uclibc", "x86_64-unknown-l4re-gnu"),
+    ("x86_64-unknown-linux-gnu", "x86_64-unknown-linux-gnu"),
+    ("x86_64-unknown-linux-gnux32", "x86_64-unknown-linux-gnux32"),
+    ("x86_64-unknown-linux-musl", "x86_64-unknown-linux-musl"),
+    ("x86_64-unknown-linux-none", "x86_64-unknown-linux-none"),
+    ("x86_64-unknown-linux-ohos", "x86_64-unknown-linux-ohos"),
+    ("x86_64-unknown-netbsd", "x86_64-unknown-netbsd"),
+    ("x86_64-unknown-none", "x86_64-unknown-none-elf"),
+    ("x86_64-unknown-none-linuxkernel", "x86_64-unknown-none-elf"),
+    ("x86_64-unknown-openbsd", "x86_64-unknown-openbsd"),
+    ("x86_64-unknown-redox", "x86_64-unknown-redox"),
+    ("x86_64-unknown-trusty", "x86_64-unknown-unknown-musl"),
+    ("x86_64-unknown-uefi", "x86_64-unknown-windows"),
+    ("x86_64-uwp-windows-gnu", "x86_64-pc-windows-gnu"),
+    ("x86_64-uwp-windows-msvc", "x86_64-pc-windows-msvc"),
+    ("x86_64-win7-windows-gnu", "x86_64-pc-windows-gnu"),
+    ("x86_64-win7-windows-msvc", "x86_64-pc-windows-msvc"),
+    ("x86_64-wrs-vxworks", "x86_64-unknown-linux-gnu"),
+    ("x86_64h-apple-darwin", "x86_64h-apple-macosx"),
+    ("xtensa-esp32-espidf", "xtensa-none-elf"),
+    ("xtensa-esp32-none-elf", "xtensa-none-elf"),
+    ("xtensa-esp32s2-espidf", "xtensa-none-elf"),
+    ("xtensa-esp32s2-none-elf", "xtensa-none-elf"),
+    ("xtensa-esp32s3-espidf", "xtensa-none-elf"),
+    ("xtensa-esp32s3-none-elf", "xtensa-none-elf"),
+];
diff --git a/vendor/cc/src/target/llvm.rs b/vendor/cc/src/target/llvm.rs
new file mode 100644
index 00000000..124ab2a0
--- /dev/null
+++ b/vendor/cc/src/target/llvm.rs
@@ -0,0 +1,315 @@
+use std::borrow::Cow;
+
+use super::{generated, TargetInfo};
+
+impl TargetInfo<'_> {
+    /// The LLVM/Clang target triple.
+    ///
+    /// See <https://clang.llvm.org/docs/CrossCompilation.html#target-triple>.
+    ///
+    /// Rust and Clang don't really agree on target naming, so we first try to
+    /// find the matching trible based on `rustc`'s output, but if no such
+    /// triple exists, we attempt to construct the triple from scratch.
+    ///
+    /// NOTE: You should never need to match on this explicitly, use the
+    /// fields on [`TargetInfo`] instead.
+    pub(crate) fn llvm_target(
+        &self,
+        rustc_target: &str,
+        version: Option<&str>,
+    ) -> Cow<'static, str> {
+        if rustc_target == "armv7-apple-ios" {
+            // FIXME(madsmtm): Unnecessary once we bump MSRV to Rust 1.74
+            return Cow::Borrowed("armv7-apple-ios");
+        } else if self.os == "uefi" {
+            // Override the UEFI LLVM targets.
+            //
+            // The rustc mappings (as of 1.82) for the UEFI targets are:
+            // * i686-unknown-uefi -> i686-unknown-windows-gnu
+            // * x86_64-unknown-uefi -> x86_64-unknown-windows
+            // * aarch64-unknown-uefi -> aarch64-unknown-windows
+            //
+            // However, in cc-rs all the UEFI targets use
+            // -windows-gnu. This has been the case since 2021 [1].
+            // * i686-unknown-uefi -> i686-unknown-windows-gnu
+            // * x86_64-unknown-uefi -> x86_64-unknown-windows-gnu
+            // * aarch64-unknown-uefi -> aarch64-unknown-windows-gnu
+            //
+            // For now, override the UEFI mapping to keep the behavior
+            // of cc-rs unchanged.
+            //
+            // TODO: as discussed in [2], it may be possible to switch
+            // to new UEFI targets added to clang, and regardless it
+            // would be good to have consistency between rustc and
+            // cc-rs.
+            //
+            // [1]: https://github.com/rust-lang/cc-rs/pull/623
+            // [2]: https://github.com/rust-lang/cc-rs/pull/1264
+            return Cow::Owned(format!("{}-unknown-windows-gnu", self.full_arch));
+        }
+
+        // If no version is requested, let's take the triple directly from
+        // `rustc` (the logic below is not yet good enough for most targets).
+        //
+        // FIXME(madsmtm): This should ideally be removed.
+        if version.is_none() {
+            if let Ok(index) = generated::LLVM_TARGETS
+                .binary_search_by_key(&rustc_target, |(rustc_target, _)| rustc_target)
+            {
+                let (_, llvm_target) = &generated::LLVM_TARGETS[index];
+                return Cow::Borrowed(llvm_target);
+            }
+        }
+
+        // Otherwise, attempt to construct the triple from the target info.
+
+        let arch = match self.full_arch {
+            riscv32 if riscv32.starts_with("riscv32") => "riscv32",
+            riscv64 if riscv64.starts_with("riscv64") => "riscv64",
+            "aarch64" if self.vendor == "apple" => "arm64",
+            "armv7" if self.vendor == "sony" => "thumbv7a", // FIXME
+            arch => arch,
+        };
+        let vendor = match self.vendor {
+            "kmc" | "nintendo" => "unknown",
+            "unknown" if self.os == "android" => "linux",
+            "uwp" => "pc",
+            "espressif" => "",
+            _ if self.arch == "msp430" => "",
+            vendor => vendor,
+        };
+        let os = match self.os {
+            "macos" => "macosx",
+            "visionos" => "xros",
+            "uefi" => "windows",
+            "solid_asp3" | "horizon" | "teeos" | "nuttx" | "espidf" => "none",
+            "nto" => "unknown",    // FIXME
+            "trusty" => "unknown", // FIXME
+            os => os,
+        };
+        let version = version.unwrap_or("");
+        let env = match self.env {
+            "newlib" | "nto70" | "nto71" | "nto71_iosock" | "p1" | "p2" | "relibc" | "sgx"
+            | "uclibc" => "",
+            env => env,
+        };
+        let abi = match self.abi {
+            "sim" => "simulator",
+            "llvm" | "softfloat" | "uwp" | "vec-extabi" => "",
+            "ilp32" => "_ilp32",
+            "abi64" => "",
+            abi => abi,
+        };
+        Cow::Owned(match (vendor, env, abi) {
+            ("", "", "") => format!("{arch}-{os}{version}"),
+            ("", env, abi) => format!("{arch}-{os}{version}-{env}{abi}"),
+            (vendor, "", "") => format!("{arch}-{vendor}-{os}{version}"),
+            (vendor, env, abi) => format!("{arch}-{vendor}-{os}{version}-{env}{abi}"),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::process::Command;
+
+    use crate::TargetInfo;
+
+    #[test]
+    fn test_old_ios_target() {
+        assert_eq!(
+            TargetInfo {
+                full_arch: "armv7",
+                arch: "armv7",
+                vendor: "apple",
+                os: "ios",
+                env: "",
+                abi: "",
+            }
+            .llvm_target("armv7-apple-ios", None),
+            "armv7-apple-ios"
+        );
+    }
+
+    #[test]
+    fn basic_llvm_triple_guessing() {
+        assert_eq!(
+            TargetInfo {
+                full_arch: "aarch64",
+                arch: "aarch64",
+                vendor: "unknown",
+                os: "linux",
+                env: "",
+                abi: "",
+            }
+            .llvm_target("invalid", None),
+            "aarch64-unknown-linux"
+        );
+        assert_eq!(
+            TargetInfo {
+                full_arch: "x86_64",
+                arch: "x86_64",
+                vendor: "unknown",
+                os: "linux",
+                env: "gnu",
+                abi: "",
+            }
+            .llvm_target("invalid", None),
+            "x86_64-unknown-linux-gnu"
+        );
+        assert_eq!(
+            TargetInfo {
+                full_arch: "x86_64",
+                arch: "x86_64",
+                vendor: "unknown",
+                os: "linux",
+                env: "gnu",
+                abi: "eabi",
+            }
+            .llvm_target("invalid", None),
+            "x86_64-unknown-linux-gnueabi"
+        );
+        assert_eq!(
+            TargetInfo {
+                full_arch: "x86_64",
+                arch: "x86_64",
+                vendor: "apple",
+                os: "macos",
+                env: "",
+                abi: "",
+            }
+            .llvm_target("invalid", None),
+            "x86_64-apple-macosx"
+        );
+    }
+
+    #[test]
+    fn llvm_version() {
+        assert_eq!(
+            TargetInfo {
+                full_arch: "aarch64",
+                arch: "aarch64",
+                vendor: "apple",
+                os: "ios",
+                env: "",
+                abi: "sim",
+            }
+            .llvm_target("aarch64-apple-ios-sim", Some("14.0")),
+            "arm64-apple-ios14.0-simulator"
+        );
+        assert_eq!(
+            TargetInfo {
+                full_arch: "aarch64",
+                arch: "aarch64",
+                vendor: "apple",
+                os: "visionos",
+                env: "",
+                abi: "",
+            }
+            .llvm_target("aarch64-apple-visionos", Some("2.0")),
+            "arm64-apple-xros2.0"
+        );
+        assert_eq!(
+            TargetInfo {
+                full_arch: "aarch64",
+                arch: "aarch64",
+                vendor: "apple",
+                os: "ios",
+                env: "",
+                abi: "macabi",
+            }
+            .llvm_target("aarch64-apple-ios-macabi", Some("13.1")),
+            "arm64-apple-ios13.1-macabi"
+        );
+    }
+
+    #[test]
+    fn uefi() {
+        assert_eq!(
+            TargetInfo {
+                full_arch: "i686",
+                arch: "x86",
+                vendor: "unknown",
+                os: "uefi",
+                env: "",
+                abi: "",
+            }
+            .llvm_target("i686-unknown-uefi", None),
+            "i686-unknown-windows-gnu"
+        );
+        assert_eq!(
+            TargetInfo {
+                full_arch: "x86_64",
+                arch: "x86_64",
+                vendor: "unknown",
+                os: "uefi",
+                env: "",
+                abi: "",
+            }
+            .llvm_target("x86_64-unknown-uefi", None),
+            "x86_64-unknown-windows-gnu"
+        );
+        assert_eq!(
+            TargetInfo {
+                full_arch: "aarch64",
+                arch: "aarch64",
+                vendor: "unknown",
+                os: "uefi",
+                env: "",
+                abi: "",
+            }
+            .llvm_target("aarch64-unknown-uefi", None),
+            "aarch64-unknown-windows-gnu"
+        );
+    }
+
+    #[test]
+    #[ignore = "not yet done"]
+    fn llvm_for_all_rustc_targets() {
+        let rustc = std::env::var("RUSTC").unwrap_or_else(|_| "rustc".to_string());
+
+        let target_list = Command::new(&rustc)
+            .arg("--print=target-list")
+            .output()
+            .unwrap()
+            .stdout;
+        let target_list = String::from_utf8(target_list).unwrap();
+
+        let mut has_failure = false;
+        for target in target_list.lines() {
+            let spec_json = Command::new(&rustc)
+                .arg("--target")
+                .arg(target)
+                .arg("-Zunstable-options")
+                .arg("--print=target-spec-json")
+                .env("RUSTC_BOOTSTRAP", "1") // Crimes
+                .output()
+                .unwrap()
+                .stdout;
+            let spec_json = String::from_utf8(spec_json).unwrap();
+
+            // JSON crimes
+            let expected = spec_json
+                .split_once("llvm-target\": \"")
+                .unwrap()
+                .1
+                .split_once("\"")
+                .unwrap()
+                .0;
+            let actual = TargetInfo::from_rustc_target(target)
+                .map(|target| target.llvm_target("invalid", None));
+
+            if Some(expected) != actual.as_deref().ok() {
+                eprintln!("failed comparing {target}:");
+                eprintln!("  expected: Ok({expected:?})");
+                eprintln!("    actual: {actual:?}");
+                eprintln!();
+                has_failure = true;
+            }
+        }
+
+        if has_failure {
+            panic!("failed comparing targets");
+        }
+    }
+}
diff --git a/vendor/cc/src/target/parser.rs b/vendor/cc/src/target/parser.rs
new file mode 100644
index 00000000..c4cfcbbb
--- /dev/null
+++ b/vendor/cc/src/target/parser.rs
@@ -0,0 +1,563 @@
+use std::env;
+
+use crate::{target::TargetInfo, utilities::OnceLock, Error, ErrorKind};
+
+#[derive(Debug)]
+struct TargetInfoParserInner {
+    full_arch: Box<str>,
+    arch: Box<str>,
+    vendor: Box<str>,
+    os: Box<str>,
+    env: Box<str>,
+    abi: Box<str>,
+}
+
+impl TargetInfoParserInner {
+    fn from_cargo_environment_variables() -> Result<Self, Error> {
+        // `TARGET` must be present.
+        //
+        // No need to emit `rerun-if-env-changed` for this,
+        // as it is controlled by Cargo itself.
+        #[allow(clippy::disallowed_methods)]
+        let target_name = env::var("TARGET").map_err(|err| {
+            Error::new(
+                ErrorKind::EnvVarNotFound,
+                format!("failed reading TARGET: {err}"),
+            )
+        })?;
+
+        // Parse the full architecture name from the target name.
+        let (full_arch, _rest) = target_name.split_once('-').ok_or(Error::new(
+            ErrorKind::InvalidTarget,
+            format!("target `{target_name}` only had a single component (at least two required)"),
+        ))?;
+
+        let cargo_env = |name, fallback: Option<&str>| -> Result<Box<str>, Error> {
+            // No need to emit `rerun-if-env-changed` for these,
+            // as they are controlled by Cargo itself.
+            #[allow(clippy::disallowed_methods)]
+            match env::var(name) {
+                Ok(var) => Ok(var.into_boxed_str()),
+                Err(err) => match fallback {
+                    Some(fallback) => Ok(fallback.into()),
+                    None => Err(Error::new(
+                        ErrorKind::EnvVarNotFound,
+                        format!("did not find fallback information for target `{target_name}`, and failed reading {name}: {err}"),
+                    )),
+                },
+            }
+        };
+
+        // Prefer to use `CARGO_ENV_*` if set, since these contain the most
+        // correct information relative to the current `rustc`, and makes it
+        // possible to support custom target JSON specs unknown to `rustc`.
+        //
+        // NOTE: If the user is using an older `rustc`, that data may be older
+        // than our pre-generated data, but we still prefer Cargo's view of
+        // the world, since at least `cc` won't differ from `rustc` in that
+        // case.
+        //
+        // These may not be set in case the user depended on being able to
+        // just set `TARGET` outside of build scripts; in those cases, fall
+        // back back to data from the known set of target names instead.
+        //
+        // See discussion in #1225 for further details.
+        let fallback_target = TargetInfo::from_rustc_target(&target_name).ok();
+        let ft = fallback_target.as_ref();
+        let arch = cargo_env("CARGO_CFG_TARGET_ARCH", ft.map(|t| t.arch))?;
+        let vendor = cargo_env("CARGO_CFG_TARGET_VENDOR", ft.map(|t| t.vendor))?;
+        let os = cargo_env("CARGO_CFG_TARGET_OS", ft.map(|t| t.os))?;
+        let env = cargo_env("CARGO_CFG_TARGET_ENV", ft.map(|t| t.env))?;
+        // `target_abi` was stabilized in Rust 1.78, which is higher than our
+        // MSRV, so it may not always be available; In that case, fall back to
+        // `""`, which is _probably_ correct for unknown target names.
+        let abi = cargo_env("CARGO_CFG_TARGET_ABI", ft.map(|t| t.abi))
+            .unwrap_or_else(|_| String::default().into_boxed_str());
+
+        Ok(Self {
+            full_arch: full_arch.to_string().into_boxed_str(),
+            arch,
+            vendor,
+            os,
+            env,
+            abi,
+        })
+    }
+}
+
+/// Parser for [`TargetInfo`], contains cached information.
+#[derive(Default, Debug)]
+pub(crate) struct TargetInfoParser(OnceLock<Result<TargetInfoParserInner, Error>>);
+
+impl TargetInfoParser {
+    pub fn parse_from_cargo_environment_variables(&self) -> Result<TargetInfo<'_>, Error> {
+        match self
+            .0
+            .get_or_init(TargetInfoParserInner::from_cargo_environment_variables)
+        {
+            Ok(TargetInfoParserInner {
+                full_arch,
+                arch,
+                vendor,
+                os,
+                env,
+                abi,
+            }) => Ok(TargetInfo {
+                full_arch,
+                arch,
+                vendor,
+                os,
+                env,
+                abi,
+            }),
+            Err(e) => Err(e.clone()),
+        }
+    }
+}
+
+/// Parse the full architecture in the target name into the simpler
+/// `cfg(target_arch = "...")` that `rustc` exposes.
+fn parse_arch(full_arch: &str) -> Option<&str> {
+    // NOTE: Some of these don't necessarily match an existing target in
+    // `rustc`. They're parsed anyhow to be as forward-compatible as possible,
+    // while still being correct.
+    //
+    // See also:
+    // https://docs.rs/cfg-expr/0.18.0/cfg_expr/targets/index.html
+    // https://docs.rs/target-lexicon/0.13.2/target_lexicon/enum.Architecture.html
+    // https://gcc.gnu.org/onlinedocs/gcc/Submodel-Options.html
+    // `clang -print-targets`
+    Some(match full_arch {
+        arch if arch.starts_with("mipsisa32r6") => "mips32r6", // mipsisa32r6 | mipsisa32r6el
+        arch if arch.starts_with("mipsisa64r6") => "mips64r6", // mipsisa64r6 | mipsisa64r6el
+
+        arch if arch.starts_with("mips64") => "mips64", // mips64 | mips64el
+        arch if arch.starts_with("mips") => "mips",     // mips | mipsel
+
+        arch if arch.starts_with("loongarch64") => "loongarch64",
+        arch if arch.starts_with("loongarch32") => "loongarch32",
+
+        arch if arch.starts_with("powerpc64") => "powerpc64", // powerpc64 | powerpc64le
+        arch if arch.starts_with("powerpc") => "powerpc",
+        arch if arch.starts_with("ppc64") => "powerpc64",
+        arch if arch.starts_with("ppc") => "powerpc",
+
+        arch if arch.starts_with("x86_64") => "x86_64", // x86_64 | x86_64h
+        arch if arch.starts_with("i") && arch.ends_with("86") => "x86", // i386 | i586 | i686
+
+        "arm64ec" => "arm64ec", // https://github.com/rust-lang/rust/issues/131172
+        arch if arch.starts_with("aarch64") => "aarch64", // arm64e | arm64_32
+        arch if arch.starts_with("arm64") => "aarch64", // aarch64 | aarch64_be
+
+        arch if arch.starts_with("arm") => "arm", // arm | armv7s | armeb | ...
+        arch if arch.starts_with("thumb") => "arm", // thumbv4t | thumbv7a | thumbv8m | ...
+
+        arch if arch.starts_with("riscv64") => "riscv64",
+        arch if arch.starts_with("riscv32") => "riscv32",
+
+        arch if arch.starts_with("wasm64") => "wasm64",
+        arch if arch.starts_with("wasm32") => "wasm32", // wasm32 | wasm32v1
+        "asmjs" => "wasm32",
+
+        arch if arch.starts_with("nvptx64") => "nvptx64",
+        arch if arch.starts_with("nvptx") => "nvptx",
+
+        arch if arch.starts_with("bpf") => "bpf", // bpfeb | bpfel
+
+        // https://github.com/bytecodealliance/wasmtime/tree/v30.0.1/pulley
+        arch if arch.starts_with("pulley64") => "pulley64",
+        arch if arch.starts_with("pulley32") => "pulley32",
+
+        // https://github.com/Clever-ISA/Clever-ISA
+        arch if arch.starts_with("clever") => "clever",
+
+        "sparc" | "sparcv7" | "sparcv8" => "sparc",
+        "sparc64" | "sparcv9" => "sparc64",
+
+        "amdgcn" => "amdgpu",
+        "avr" => "avr",
+        "csky" => "csky",
+        "hexagon" => "hexagon",
+        "m68k" => "m68k",
+        "msp430" => "msp430",
+        "r600" => "r600",
+        "s390x" => "s390x",
+        "xtensa" => "xtensa",
+
+        _ => return None,
+    })
+}
+
+/// Parse environment and ABI from the last component of the target name.
+fn parse_envabi(last_component: &str) -> Option<(&str, &str)> {
+    let (env, abi) = match last_component {
+        // Combined environment and ABI
+
+        // gnullvm | gnueabi | gnueabihf | gnuabiv2 | gnuabi64 | gnuspe | gnux32 | gnu_ilp32
+        env_and_abi if env_and_abi.starts_with("gnu") => {
+            let abi = env_and_abi.strip_prefix("gnu").unwrap();
+            let abi = abi.strip_prefix("_").unwrap_or(abi);
+            ("gnu", abi)
+        }
+        // musl | musleabi | musleabihf | muslabi64 | muslspe
+        env_and_abi if env_and_abi.starts_with("musl") => {
+            ("musl", env_and_abi.strip_prefix("musl").unwrap())
+        }
+        // uclibc | uclibceabi | uclibceabihf
+        env_and_abi if env_and_abi.starts_with("uclibc") => {
+            ("uclibc", env_and_abi.strip_prefix("uclibc").unwrap())
+        }
+        // newlib | newlibeabihf
+        env_and_abi if env_and_abi.starts_with("newlib") => {
+            ("newlib", env_and_abi.strip_prefix("newlib").unwrap())
+        }
+
+        // Environments
+        "msvc" => ("msvc", ""),
+        "ohos" => ("ohos", ""),
+        "qnx700" => ("nto70", ""),
+        "qnx710_iosock" => ("nto71_iosock", ""),
+        "qnx710" => ("nto71", ""),
+        "qnx800" => ("nto80", ""),
+        "sgx" => ("sgx", ""),
+        "threads" => ("threads", ""),
+
+        // ABIs
+        "abi64" => ("", "abi64"),
+        "abiv2" => ("", "spe"),
+        "eabi" => ("", "eabi"),
+        "eabihf" => ("", "eabihf"),
+        "macabi" => ("", "macabi"),
+        "sim" => ("", "sim"),
+        "softfloat" => ("", "softfloat"),
+        "spe" => ("", "spe"),
+        "x32" => ("", "x32"),
+
+        // Badly named targets, ELF is already known from target OS.
+        // Probably too late to fix now though.
+        "elf" => ("", ""),
+        // Undesirable to expose to user code (yet):
+        // https://github.com/rust-lang/rust/pull/131166#issuecomment-2389541917
+        "freestanding" => ("", ""),
+
+        _ => return None,
+    };
+    Some((env, abi))
+}
+
+impl<'a> TargetInfo<'a> {
+    pub(crate) fn from_rustc_target(target: &'a str) -> Result<Self, Error> {
+        // FIXME(madsmtm): This target should be renamed, cannot be parsed
+        // with the means we do below (since `none` must not be interpreted
+        // as an env/ABI).
+        if target == "x86_64-unknown-linux-none" {
+            return Ok(Self {
+                full_arch: "x86_64",
+                arch: "x86_64",
+                vendor: "unknown",
+                os: "linux",
+                env: "",
+                abi: "",
+            });
+        }
+
+        let mut components = target.split('-');
+
+        // Insist that the target name contains at least a valid architecture.
+        let full_arch = components.next().ok_or(Error::new(
+            ErrorKind::InvalidTarget,
+            "target was empty".to_string(),
+        ))?;
+        let arch = parse_arch(full_arch).ok_or_else(|| {
+            Error::new(
+                ErrorKind::UnknownTarget,
+                format!("target `{target}` had an unknown architecture"),
+            )
+        })?;
+
+        // Newer target names have begun omitting the vendor, so the only
+        // component we know must be there is the OS name.
+        let components: Vec<_> = components.collect();
+        let (vendor, os, mut env, mut abi) = match &*components {
+            [] => {
+                return Err(Error::new(
+                    ErrorKind::InvalidTarget,
+                    format!("target `{target}` must have at least two components"),
+                ))
+            }
+            // Two components; format is `arch-os`.
+            [os] => ("unknown", *os, "", ""),
+            // The three-component case is a bit tricky to handle, it could
+            // either have the format `arch-vendor-os` or `arch-os-env+abi`.
+            [vendor_or_os, os_or_envabi] => {
+                // We differentiate between these by checking if the last
+                // component is an env/ABI; if it isn't, then it's probably
+                // an OS instead.
+                if let Some((env, abi)) = parse_envabi(os_or_envabi) {
+                    ("unknown", *vendor_or_os, env, abi)
+                } else {
+                    (*vendor_or_os, *os_or_envabi, "", "")
+                }
+            }
+            // Four components; format is `arch-vendor-os-env+abi`.
+            [vendor, os, envabi] => {
+                let (env, abi) = parse_envabi(envabi).ok_or_else(|| {
+                    Error::new(
+                        ErrorKind::UnknownTarget,
+                        format!("unknown environment/ABI `{envabi}` in target `{target}`"),
+                    )
+                })?;
+                (*vendor, *os, env, abi)
+            }
+            _ => {
+                return Err(Error::new(
+                    ErrorKind::InvalidTarget,
+                    format!("too many components in target `{target}`"),
+                ))
+            }
+        };
+
+        // Part of the architecture name is carried over into the ABI.
+        match full_arch {
+            // https://github.com/rust-lang/compiler-team/issues/830
+            arch if arch.starts_with("riscv32e") => {
+                abi = "ilp32e";
+            }
+            _ => {}
+        }
+
+        // Various environment/ABIs are determined based on OS name.
+        match os {
+            "3ds" | "rtems" | "espidf" => env = "newlib",
+            "vxworks" => env = "gnu",
+            "redox" => env = "relibc",
+            "aix" => abi = "vec-extabi",
+            _ => {}
+        }
+
+        // Extra overrides for badly named targets.
+        match target {
+            // Actually simulator targets.
+            "i386-apple-ios" | "x86_64-apple-ios" | "x86_64-apple-tvos" => {
+                abi = "sim";
+            }
+            // Name should've contained `muslabi64`.
+            "mips64-openwrt-linux-musl" => {
+                abi = "abi64";
+            }
+            // Specifies abi even though not in name.
+            "armv6-unknown-freebsd" | "armv6k-nintendo-3ds" | "armv7-unknown-freebsd" => {
+                abi = "eabihf";
+            }
+            // Specifies abi even though not in name.
+            "armv7-unknown-linux-ohos" | "armv7-unknown-trusty" => {
+                abi = "eabi";
+            }
+            _ => {}
+        }
+
+        let os = match os {
+            // Horizon is the common/internal OS name for 3DS and the Switch.
+            "3ds" | "switch" => "horizon",
+            // FIXME(madsmtm): macOS targets are badly named.
+            "darwin" => "macos",
+
+            // WASI targets contain the preview version in them too. Should've
+            // been `wasi-p1`/`wasi-p2`, but that's probably too late now.
+            os if os.starts_with("wasi") => {
+                env = os.strip_prefix("wasi").unwrap();
+                "wasi"
+            }
+            // FIXME(madsmtm): Badly named targets `*-linux-androideabi`,
+            // should be `*-android-eabi`.
+            "androideabi" => {
+                abi = "eabi";
+                "android"
+            }
+
+            os => os,
+        };
+
+        let vendor = match vendor {
+            // esp, esp32, esp32s2 etc.
+            vendor if vendor.starts_with("esp") => "espressif",
+            // FIXME(madsmtm): Badly named targets `*-linux-android*`,
+            // "linux" makes no sense as the vendor name.
+            "linux" if os == "android" || os == "androideabi" => "unknown",
+            // FIXME(madsmtm): Fix in `rustc` after
+            // https://github.com/rust-lang/compiler-team/issues/850.
+            "wali" => "unknown",
+            "lynx" => "unknown",
+            // Some Linux distributions set their name as the target vendor,
+            // so we have to assume that it can be an arbitary string.
+            vendor => vendor,
+        };
+
+        // Intentionally also marked as an ABI:
+        // https://github.com/rust-lang/rust/pull/86922
+        if vendor == "fortanix" {
+            abi = "fortanix";
+        }
+        if vendor == "uwp" {
+            abi = "uwp";
+        }
+
+        Ok(Self {
+            full_arch,
+            arch,
+            vendor,
+            os,
+            env,
+            abi,
+        })
+    }
+}
+
+#[cfg(test)]
+#[allow(unexpected_cfgs)]
+mod tests {
+    use std::process::Command;
+
+    use super::TargetInfo;
+    use crate::ErrorKind;
+
+    // Test tier 1 targets.
+    #[test]
+    fn tier1() {
+        let targets = [
+            "aarch64-unknown-linux-gnu",
+            "aarch64-apple-darwin",
+            "i686-pc-windows-gnu",
+            "i686-pc-windows-msvc",
+            "i686-unknown-linux-gnu",
+            "x86_64-apple-darwin",
+            "x86_64-pc-windows-gnu",
+            "x86_64-pc-windows-msvc",
+            "x86_64-unknown-linux-gnu",
+        ];
+
+        for target in targets {
+            // Check that they parse.
+            let _ = TargetInfo::from_rustc_target(target).unwrap();
+        }
+    }
+
+    // Various custom target names not (or no longer) known by `rustc`.
+    #[test]
+    fn parse_extra() {
+        let targets = [
+            "aarch64-unknown-none-gnu",
+            "aarch64-uwp-windows-gnu",
+            "arm-frc-linux-gnueabi",
+            "arm-unknown-netbsd-eabi",
+            "armv7neon-unknown-linux-gnueabihf",
+            "armv7neon-unknown-linux-musleabihf",
+            "thumbv7-unknown-linux-gnueabihf",
+            "thumbv7-unknown-linux-musleabihf",
+            "armv7-apple-ios",
+            "wasm32-wasi",
+            "x86_64-rumprun-netbsd",
+            "x86_64-unknown-linux",
+            "x86_64-alpine-linux-musl",
+            "x86_64-chimera-linux-musl",
+            "x86_64-foxkit-linux-musl",
+            "arm-poky-linux-gnueabi",
+            "x86_64-unknown-moturus",
+        ];
+
+        for target in targets {
+            // Check that they parse.
+            let _ = TargetInfo::from_rustc_target(target).unwrap();
+        }
+    }
+
+    fn target_from_rustc_cfgs<'a>(target: &'a str, cfgs: &'a str) -> TargetInfo<'a> {
+        // Cannot determine full architecture from cfgs.
+        let (full_arch, _rest) = target.split_once('-').expect("target to have arch");
+
+        let mut target = TargetInfo {
+            full_arch,
+            arch: "invalid-none-set",
+            vendor: "invalid-none-set",
+            os: "invalid-none-set",
+            env: "invalid-none-set",
+            // Not set in older Rust versions
+            abi: "",
+        };
+
+        for cfg in cfgs.lines() {
+            if let Some((name, value)) = cfg.split_once('=') {
+                // Remove whitespace, if `rustc` decided to insert any.
+                let name = name.trim();
+                let value = value.trim();
+
+                // Remove quotes around value.
+                let value = value.strip_prefix('"').unwrap_or(value);
+                let value = value.strip_suffix('"').unwrap_or(value);
+
+                match name {
+                    "target_arch" => target.arch = value,
+                    "target_vendor" => target.vendor = value,
+                    "target_os" => target.os = value,
+                    "target_env" => target.env = value,
+                    "target_abi" => target.abi = value,
+                    _ => {}
+                }
+            } else {
+                // Skip cfgs like `debug_assertions` and `unix`.
+            }
+        }
+
+        target
+    }
+
+    #[test]
+    fn unknown_env_determined_as_unknown() {
+        let err = TargetInfo::from_rustc_target("aarch64-unknown-linux-bogus").unwrap_err();
+        assert!(matches!(err.kind, ErrorKind::UnknownTarget));
+    }
+
+    // Used in .github/workflows/test-rustc-targets.yml
+    #[test]
+    #[cfg_attr(
+        not(rustc_target_test),
+        ignore = "must enable explicitly with --cfg=rustc_target_test"
+    )]
+    fn parse_rustc_targets() {
+        let rustc = std::env::var("RUSTC").unwrap_or_else(|_| "rustc".to_string());
+
+        let target_list = Command::new(&rustc)
+            .arg("--print=target-list")
+            .output()
+            .unwrap()
+            .stdout;
+        let target_list = String::from_utf8(target_list).unwrap();
+
+        let mut has_failure = false;
+        for target in target_list.lines() {
+            let cfgs = Command::new(&rustc)
+                .arg("--target")
+                .arg(target)
+                .arg("--print=cfg")
+                .output()
+                .unwrap()
+                .stdout;
+            let cfgs = String::from_utf8(cfgs).unwrap();
+
+            let expected = target_from_rustc_cfgs(target, &cfgs);
+            let actual = TargetInfo::from_rustc_target(target);
+
+            if Some(&expected) != actual.as_ref().ok() {
+                eprintln!("failed comparing {target}:");
+                eprintln!("  expected: Ok({expected:?})");
+                eprintln!("    actual: {actual:?}");
+                eprintln!();
+                has_failure = true;
+            }
+        }
+
+        if has_failure {
+            panic!("failed comparing targets");
+        }
+    }
+}