687 lines
27 KiB
Rust
687 lines
27 KiB
Rust
use std::{
|
|
env,
|
|
ffi::{OsStr, OsString},
|
|
fs::{self, File},
|
|
io::{BufRead, BufReader, BufWriter, ErrorKind, Write},
|
|
path::{Path, PathBuf},
|
|
process::{Command, Stdio},
|
|
};
|
|
|
|
use build_helper::ci::CiEnv;
|
|
use once_cell::sync::OnceCell;
|
|
use xz2::bufread::XzDecoder;
|
|
|
|
use crate::{
|
|
config::RustfmtMetadata,
|
|
llvm::detect_llvm_sha,
|
|
t,
|
|
util::{check_run, exe, program_out_of_date},
|
|
Config,
|
|
};
|
|
|
|
static SHOULD_FIX_BINS_AND_DYLIBS: OnceCell<bool> = OnceCell::new();
|
|
|
|
/// `Config::try_run` wrapper for this module to avoid warnings on `try_run`, since we don't have access to a `builder` yet.
|
|
fn try_run(config: &Config, cmd: &mut Command) -> Result<(), ()> {
|
|
#[allow(deprecated)]
|
|
config.try_run(cmd)
|
|
}
|
|
|
|
/// Generic helpers that are useful anywhere in bootstrap.
|
|
impl Config {
|
|
pub fn is_verbose(&self) -> bool {
|
|
self.verbose > 0
|
|
}
|
|
|
|
pub(crate) fn create(&self, path: &Path, s: &str) {
|
|
if self.dry_run() {
|
|
return;
|
|
}
|
|
t!(fs::write(path, s));
|
|
}
|
|
|
|
pub(crate) fn remove(&self, f: &Path) {
|
|
if self.dry_run() {
|
|
return;
|
|
}
|
|
fs::remove_file(f).unwrap_or_else(|_| panic!("failed to remove {:?}", f));
|
|
}
|
|
|
|
/// Create a temporary directory in `out` and return its path.
|
|
///
|
|
/// NOTE: this temporary directory is shared between all steps;
|
|
/// if you need an empty directory, create a new subdirectory inside it.
|
|
pub(crate) fn tempdir(&self) -> PathBuf {
|
|
let tmp = self.out.join("tmp");
|
|
t!(fs::create_dir_all(&tmp));
|
|
tmp
|
|
}
|
|
|
|
/// Runs a command, printing out nice contextual information if it fails.
|
|
/// Returns false if do not execute at all, otherwise returns its
|
|
/// `status.success()`.
|
|
pub(crate) fn check_run(&self, cmd: &mut Command) -> bool {
|
|
if self.dry_run() {
|
|
return true;
|
|
}
|
|
self.verbose(&format!("running: {cmd:?}"));
|
|
check_run(cmd, self.is_verbose())
|
|
}
|
|
|
|
/// Whether or not `fix_bin_or_dylib` needs to be run; can only be true
|
|
/// on NixOS
|
|
fn should_fix_bins_and_dylibs(&self) -> bool {
|
|
let val = *SHOULD_FIX_BINS_AND_DYLIBS.get_or_init(|| {
|
|
match Command::new("uname").arg("-s").stderr(Stdio::inherit()).output() {
|
|
Err(_) => return false,
|
|
Ok(output) if !output.status.success() => return false,
|
|
Ok(output) => {
|
|
let mut os_name = output.stdout;
|
|
if os_name.last() == Some(&b'\n') {
|
|
os_name.pop();
|
|
}
|
|
if os_name != b"Linux" {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the user has asked binaries to be patched for Nix, then
|
|
// don't check for NixOS or `/lib`.
|
|
// NOTE: this intentionally comes after the Linux check:
|
|
// - patchelf only works with ELF files, so no need to run it on Mac or Windows
|
|
// - On other Unix systems, there is no stable syscall interface, so Nix doesn't manage the global libc.
|
|
if let Some(explicit_value) = self.patch_binaries_for_nix {
|
|
return explicit_value;
|
|
}
|
|
|
|
// Use `/etc/os-release` instead of `/etc/NIXOS`.
|
|
// The latter one does not exist on NixOS when using tmpfs as root.
|
|
let is_nixos = match File::open("/etc/os-release") {
|
|
Err(e) if e.kind() == ErrorKind::NotFound => false,
|
|
Err(e) => panic!("failed to access /etc/os-release: {}", e),
|
|
Ok(os_release) => BufReader::new(os_release).lines().any(|l| {
|
|
let l = l.expect("reading /etc/os-release");
|
|
matches!(l.trim(), "ID=nixos" | "ID='nixos'" | "ID=\"nixos\"")
|
|
}),
|
|
};
|
|
if !is_nixos {
|
|
let in_nix_shell = env::var("IN_NIX_SHELL");
|
|
if let Ok(in_nix_shell) = in_nix_shell {
|
|
eprintln!(
|
|
"The IN_NIX_SHELL environment variable is `{in_nix_shell}`; \
|
|
you may need to set `patch-binaries-for-nix=true` in config.toml"
|
|
);
|
|
}
|
|
}
|
|
is_nixos
|
|
});
|
|
if val {
|
|
eprintln!("info: You seem to be using Nix.");
|
|
}
|
|
val
|
|
}
|
|
|
|
/// Modifies the interpreter section of 'fname' to fix the dynamic linker,
|
|
/// or the RPATH section, to fix the dynamic library search path
|
|
///
|
|
/// This is only required on NixOS and uses the PatchELF utility to
|
|
/// change the interpreter/RPATH of ELF executables.
|
|
///
|
|
/// Please see <https://nixos.org/patchelf.html> for more information
|
|
fn fix_bin_or_dylib(&self, fname: &Path) {
|
|
assert_eq!(SHOULD_FIX_BINS_AND_DYLIBS.get(), Some(&true));
|
|
println!("attempting to patch {}", fname.display());
|
|
|
|
// Only build `.nix-deps` once.
|
|
static NIX_DEPS_DIR: OnceCell<PathBuf> = OnceCell::new();
|
|
let mut nix_build_succeeded = true;
|
|
let nix_deps_dir = NIX_DEPS_DIR.get_or_init(|| {
|
|
// Run `nix-build` to "build" each dependency (which will likely reuse
|
|
// the existing `/nix/store` copy, or at most download a pre-built copy).
|
|
//
|
|
// Importantly, we create a gc-root called `.nix-deps` in the `build/`
|
|
// directory, but still reference the actual `/nix/store` path in the rpath
|
|
// as it makes it significantly more robust against changes to the location of
|
|
// the `.nix-deps` location.
|
|
//
|
|
// bintools: Needed for the path of `ld-linux.so` (via `nix-support/dynamic-linker`).
|
|
// zlib: Needed as a system dependency of `libLLVM-*.so`.
|
|
// patchelf: Needed for patching ELF binaries (see doc comment above).
|
|
let nix_deps_dir = self.out.join(".nix-deps");
|
|
const NIX_EXPR: &str = "
|
|
with (import <nixpkgs> {});
|
|
symlinkJoin {
|
|
name = \"rust-stage0-dependencies\";
|
|
paths = [
|
|
zlib
|
|
patchelf
|
|
stdenv.cc.bintools
|
|
];
|
|
}
|
|
";
|
|
nix_build_succeeded = try_run(
|
|
self,
|
|
Command::new("nix-build").args(&[
|
|
Path::new("-E"),
|
|
Path::new(NIX_EXPR),
|
|
Path::new("-o"),
|
|
&nix_deps_dir,
|
|
]),
|
|
)
|
|
.is_ok();
|
|
nix_deps_dir
|
|
});
|
|
if !nix_build_succeeded {
|
|
return;
|
|
}
|
|
|
|
let mut patchelf = Command::new(nix_deps_dir.join("bin/patchelf"));
|
|
let rpath_entries = {
|
|
// ORIGIN is a relative default, all binary and dynamic libraries we ship
|
|
// appear to have this (even when `../lib` is redundant).
|
|
// NOTE: there are only two paths here, delimited by a `:`
|
|
let mut entries = OsString::from("$ORIGIN/../lib:");
|
|
entries.push(t!(fs::canonicalize(nix_deps_dir)).join("lib"));
|
|
entries
|
|
};
|
|
patchelf.args(&[OsString::from("--set-rpath"), rpath_entries]);
|
|
if !fname.extension().map_or(false, |ext| ext == "so") {
|
|
// Finally, set the correct .interp for binaries
|
|
let dynamic_linker_path = nix_deps_dir.join("nix-support/dynamic-linker");
|
|
// FIXME: can we support utf8 here? `args` doesn't accept Vec<u8>, only OsString ...
|
|
let dynamic_linker = t!(String::from_utf8(t!(fs::read(dynamic_linker_path))));
|
|
patchelf.args(&["--set-interpreter", dynamic_linker.trim_end()]);
|
|
}
|
|
|
|
let _ = try_run(self, patchelf.arg(fname));
|
|
}
|
|
|
|
fn download_file(&self, url: &str, dest_path: &Path, help_on_error: &str) {
|
|
self.verbose(&format!("download {url}"));
|
|
// Use a temporary file in case we crash while downloading, to avoid a corrupt download in cache/.
|
|
let tempfile = self.tempdir().join(dest_path.file_name().unwrap());
|
|
// While bootstrap itself only supports http and https downloads, downstream forks might
|
|
// need to download components from other protocols. The match allows them adding more
|
|
// protocols without worrying about merge conflicts if we change the HTTP implementation.
|
|
match url.split_once("://").map(|(proto, _)| proto) {
|
|
Some("http") | Some("https") => {
|
|
self.download_http_with_retries(&tempfile, url, help_on_error)
|
|
}
|
|
Some(other) => panic!("unsupported protocol {other} in {url}"),
|
|
None => panic!("no protocol in {url}"),
|
|
}
|
|
t!(std::fs::rename(&tempfile, dest_path));
|
|
}
|
|
|
|
fn download_http_with_retries(&self, tempfile: &Path, url: &str, help_on_error: &str) {
|
|
println!("downloading {url}");
|
|
// Try curl. If that fails and we are on windows, fallback to PowerShell.
|
|
let mut curl = Command::new("curl");
|
|
curl.args(&[
|
|
"-y",
|
|
"30",
|
|
"-Y",
|
|
"10", // timeout if speed is < 10 bytes/sec for > 30 seconds
|
|
"--connect-timeout",
|
|
"30", // timeout if cannot connect within 30 seconds
|
|
"-o",
|
|
tempfile.to_str().unwrap(),
|
|
"--retry",
|
|
"3",
|
|
"-SRf",
|
|
]);
|
|
// Don't print progress in CI; the \r wrapping looks bad and downloads don't take long enough for progress to be useful.
|
|
if CiEnv::is_ci() {
|
|
curl.arg("-s");
|
|
} else {
|
|
curl.arg("--progress-bar");
|
|
}
|
|
curl.arg(url);
|
|
if !self.check_run(&mut curl) {
|
|
if self.build.contains("windows-msvc") {
|
|
eprintln!("Fallback to PowerShell");
|
|
for _ in 0..3 {
|
|
if try_run(self, Command::new("PowerShell.exe").args(&[
|
|
"/nologo",
|
|
"-Command",
|
|
"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12;",
|
|
&format!(
|
|
"(New-Object System.Net.WebClient).DownloadFile('{}', '{}')",
|
|
url, tempfile.to_str().expect("invalid UTF-8 not supported with powershell downloads"),
|
|
),
|
|
])).is_err() {
|
|
return;
|
|
}
|
|
eprintln!("\nspurious failure, trying again");
|
|
}
|
|
}
|
|
if !help_on_error.is_empty() {
|
|
eprintln!("{help_on_error}");
|
|
}
|
|
crate::exit!(1);
|
|
}
|
|
}
|
|
|
|
fn unpack(&self, tarball: &Path, dst: &Path, pattern: &str) {
|
|
eprintln!("extracting {} to {}", tarball.display(), dst.display());
|
|
if !dst.exists() {
|
|
t!(fs::create_dir_all(dst));
|
|
}
|
|
|
|
// `tarball` ends with `.tar.xz`; strip that suffix
|
|
// example: `rust-dev-nightly-x86_64-unknown-linux-gnu`
|
|
let uncompressed_filename =
|
|
Path::new(tarball.file_name().expect("missing tarball filename")).file_stem().unwrap();
|
|
let directory_prefix = Path::new(Path::new(uncompressed_filename).file_stem().unwrap());
|
|
|
|
// decompress the file
|
|
let data = t!(File::open(tarball), format!("file {} not found", tarball.display()));
|
|
let decompressor = XzDecoder::new(BufReader::new(data));
|
|
|
|
let mut tar = tar::Archive::new(decompressor);
|
|
|
|
// `compile::Sysroot` needs to know the contents of the `rustc-dev` tarball to avoid adding
|
|
// it to the sysroot unless it was explicitly requested. But parsing the 100 MB tarball is slow.
|
|
// Cache the entries when we extract it so we only have to read it once.
|
|
let mut recorded_entries =
|
|
if dst.ends_with("ci-rustc") { recorded_entries(dst, pattern) } else { None };
|
|
|
|
for member in t!(tar.entries()) {
|
|
let mut member = t!(member);
|
|
let original_path = t!(member.path()).into_owned();
|
|
// skip the top-level directory
|
|
if original_path == directory_prefix {
|
|
continue;
|
|
}
|
|
let mut short_path = t!(original_path.strip_prefix(directory_prefix));
|
|
if !short_path.starts_with(pattern) {
|
|
continue;
|
|
}
|
|
short_path = t!(short_path.strip_prefix(pattern));
|
|
let dst_path = dst.join(short_path);
|
|
self.verbose(&format!("extracting {} to {}", original_path.display(), dst.display()));
|
|
if !t!(member.unpack_in(dst)) {
|
|
panic!("path traversal attack ??");
|
|
}
|
|
if let Some(record) = &mut recorded_entries {
|
|
t!(writeln!(record, "{}", short_path.to_str().unwrap()));
|
|
}
|
|
let src_path = dst.join(original_path);
|
|
if src_path.is_dir() && dst_path.exists() {
|
|
continue;
|
|
}
|
|
t!(fs::rename(src_path, dst_path));
|
|
}
|
|
let dst_dir = dst.join(directory_prefix);
|
|
if dst_dir.exists() {
|
|
t!(fs::remove_dir_all(&dst_dir), format!("failed to remove {}", dst_dir.display()));
|
|
}
|
|
}
|
|
|
|
/// Returns whether the SHA256 checksum of `path` matches `expected`.
|
|
fn verify(&self, path: &Path, expected: &str) -> bool {
|
|
use sha2::Digest;
|
|
|
|
self.verbose(&format!("verifying {}", path.display()));
|
|
let mut hasher = sha2::Sha256::new();
|
|
// FIXME: this is ok for rustfmt (4.1 MB large at time of writing), but it seems memory-intensive for rustc and larger components.
|
|
// Consider using streaming IO instead?
|
|
let contents = if self.dry_run() { vec![] } else { t!(fs::read(path)) };
|
|
hasher.update(&contents);
|
|
let found = hex::encode(hasher.finalize().as_slice());
|
|
let verified = found == expected;
|
|
if !verified && !self.dry_run() {
|
|
println!(
|
|
"invalid checksum: \n\
|
|
found: {found}\n\
|
|
expected: {expected}",
|
|
);
|
|
}
|
|
return verified;
|
|
}
|
|
}
|
|
|
|
fn recorded_entries(dst: &Path, pattern: &str) -> Option<BufWriter<File>> {
|
|
let name = if pattern == "rustc-dev" {
|
|
".rustc-dev-contents"
|
|
} else if pattern.starts_with("rust-std") {
|
|
".rust-std-contents"
|
|
} else {
|
|
return None;
|
|
};
|
|
Some(BufWriter::new(t!(File::create(dst.join(name)))))
|
|
}
|
|
|
|
enum DownloadSource {
|
|
CI,
|
|
Dist,
|
|
}
|
|
|
|
/// Functions that are only ever called once, but named for clarify and to avoid thousand-line functions.
|
|
impl Config {
|
|
pub(crate) fn maybe_download_rustfmt(&self) -> Option<PathBuf> {
|
|
let RustfmtMetadata { date, version } = self.stage0_metadata.rustfmt.as_ref()?;
|
|
let channel = format!("{version}-{date}");
|
|
|
|
let host = self.build;
|
|
let bin_root = self.out.join(host.triple).join("rustfmt");
|
|
let rustfmt_path = bin_root.join("bin").join(exe("rustfmt", host));
|
|
let rustfmt_stamp = bin_root.join(".rustfmt-stamp");
|
|
if rustfmt_path.exists() && !program_out_of_date(&rustfmt_stamp, &channel) {
|
|
return Some(rustfmt_path);
|
|
}
|
|
|
|
self.download_component(
|
|
DownloadSource::Dist,
|
|
format!("rustfmt-{version}-{build}.tar.xz", build = host.triple),
|
|
"rustfmt-preview",
|
|
&date,
|
|
"rustfmt",
|
|
);
|
|
self.download_component(
|
|
DownloadSource::Dist,
|
|
format!("rustc-{version}-{build}.tar.xz", build = host.triple),
|
|
"rustc",
|
|
&date,
|
|
"rustfmt",
|
|
);
|
|
|
|
if self.should_fix_bins_and_dylibs() {
|
|
self.fix_bin_or_dylib(&bin_root.join("bin").join("rustfmt"));
|
|
self.fix_bin_or_dylib(&bin_root.join("bin").join("cargo-fmt"));
|
|
let lib_dir = bin_root.join("lib");
|
|
for lib in t!(fs::read_dir(&lib_dir), lib_dir.display().to_string()) {
|
|
let lib = t!(lib);
|
|
if lib.path().extension() == Some(OsStr::new("so")) {
|
|
self.fix_bin_or_dylib(&lib.path());
|
|
}
|
|
}
|
|
}
|
|
|
|
self.create(&rustfmt_stamp, &channel);
|
|
Some(rustfmt_path)
|
|
}
|
|
|
|
pub(crate) fn ci_rust_std_contents(&self) -> Vec<String> {
|
|
self.ci_component_contents(".rust-std-contents")
|
|
}
|
|
|
|
pub(crate) fn ci_rustc_dev_contents(&self) -> Vec<String> {
|
|
self.ci_component_contents(".rustc-dev-contents")
|
|
}
|
|
|
|
fn ci_component_contents(&self, stamp_file: &str) -> Vec<String> {
|
|
assert!(self.download_rustc());
|
|
if self.dry_run() {
|
|
return vec![];
|
|
}
|
|
|
|
let ci_rustc_dir = self.ci_rustc_dir();
|
|
let stamp_file = ci_rustc_dir.join(stamp_file);
|
|
let contents_file = t!(File::open(&stamp_file), stamp_file.display().to_string());
|
|
t!(BufReader::new(contents_file).lines().collect())
|
|
}
|
|
|
|
pub(crate) fn download_ci_rustc(&self, commit: &str) {
|
|
self.verbose(&format!("using downloaded stage2 artifacts from CI (commit {commit})"));
|
|
|
|
let version = self.artifact_version_part(commit);
|
|
// download-rustc doesn't need its own cargo, it can just use beta's. But it does need the
|
|
// `rustc_private` crates for tools.
|
|
let extra_components = ["rustc-dev"];
|
|
|
|
self.download_toolchain(
|
|
&version,
|
|
"ci-rustc",
|
|
&format!("{commit}-{}", self.llvm_assertions),
|
|
&extra_components,
|
|
Self::download_ci_component,
|
|
);
|
|
}
|
|
|
|
pub(crate) fn download_beta_toolchain(&self) {
|
|
self.verbose("downloading stage0 beta artifacts");
|
|
|
|
let date = &self.stage0_metadata.compiler.date;
|
|
let version = &self.stage0_metadata.compiler.version;
|
|
let extra_components = ["cargo"];
|
|
|
|
let download_beta_component = |config: &Config, filename, prefix: &_, date: &_| {
|
|
config.download_component(DownloadSource::Dist, filename, prefix, date, "stage0")
|
|
};
|
|
|
|
self.download_toolchain(
|
|
version,
|
|
"stage0",
|
|
date,
|
|
&extra_components,
|
|
download_beta_component,
|
|
);
|
|
}
|
|
|
|
fn download_toolchain(
|
|
&self,
|
|
version: &str,
|
|
sysroot: &str,
|
|
stamp_key: &str,
|
|
extra_components: &[&str],
|
|
download_component: fn(&Config, String, &str, &str),
|
|
) {
|
|
let host = self.build.triple;
|
|
let bin_root = self.out.join(host).join(sysroot);
|
|
let rustc_stamp = bin_root.join(".rustc-stamp");
|
|
|
|
if !bin_root.join("bin").join(exe("rustc", self.build)).exists()
|
|
|| program_out_of_date(&rustc_stamp, stamp_key)
|
|
{
|
|
if bin_root.exists() {
|
|
t!(fs::remove_dir_all(&bin_root));
|
|
}
|
|
let filename = format!("rust-std-{version}-{host}.tar.xz");
|
|
let pattern = format!("rust-std-{host}");
|
|
download_component(self, filename, &pattern, stamp_key);
|
|
let filename = format!("rustc-{version}-{host}.tar.xz");
|
|
download_component(self, filename, "rustc", stamp_key);
|
|
|
|
for component in extra_components {
|
|
let filename = format!("{component}-{version}-{host}.tar.xz");
|
|
download_component(self, filename, component, stamp_key);
|
|
}
|
|
|
|
if self.should_fix_bins_and_dylibs() {
|
|
self.fix_bin_or_dylib(&bin_root.join("bin").join("rustc"));
|
|
self.fix_bin_or_dylib(&bin_root.join("bin").join("rustdoc"));
|
|
self.fix_bin_or_dylib(
|
|
&bin_root.join("libexec").join("rust-analyzer-proc-macro-srv"),
|
|
);
|
|
let lib_dir = bin_root.join("lib");
|
|
for lib in t!(fs::read_dir(&lib_dir), lib_dir.display().to_string()) {
|
|
let lib = t!(lib);
|
|
if lib.path().extension() == Some(OsStr::new("so")) {
|
|
self.fix_bin_or_dylib(&lib.path());
|
|
}
|
|
}
|
|
}
|
|
|
|
t!(fs::write(rustc_stamp, stamp_key));
|
|
}
|
|
}
|
|
|
|
/// Download a single component of a CI-built toolchain (not necessarily a published nightly).
|
|
// NOTE: intentionally takes an owned string to avoid downloading multiple times by accident
|
|
fn download_ci_component(&self, filename: String, prefix: &str, commit_with_assertions: &str) {
|
|
Self::download_component(
|
|
self,
|
|
DownloadSource::CI,
|
|
filename,
|
|
prefix,
|
|
commit_with_assertions,
|
|
"ci-rustc",
|
|
)
|
|
}
|
|
|
|
fn download_component(
|
|
&self,
|
|
mode: DownloadSource,
|
|
filename: String,
|
|
prefix: &str,
|
|
key: &str,
|
|
destination: &str,
|
|
) {
|
|
let cache_dst = self.out.join("cache");
|
|
let cache_dir = cache_dst.join(key);
|
|
if !cache_dir.exists() {
|
|
t!(fs::create_dir_all(&cache_dir));
|
|
}
|
|
|
|
let bin_root = self.out.join(self.build.triple).join(destination);
|
|
let tarball = cache_dir.join(&filename);
|
|
let (base_url, url, should_verify) = match mode {
|
|
DownloadSource::CI => {
|
|
let dist_server = if self.llvm_assertions {
|
|
self.stage0_metadata.config.artifacts_with_llvm_assertions_server.clone()
|
|
} else {
|
|
self.stage0_metadata.config.artifacts_server.clone()
|
|
};
|
|
let url = format!(
|
|
"{}/{filename}",
|
|
key.strip_suffix(&format!("-{}", self.llvm_assertions)).unwrap()
|
|
);
|
|
(dist_server, url, false)
|
|
}
|
|
DownloadSource::Dist => {
|
|
let dist_server = env::var("RUSTUP_DIST_SERVER")
|
|
.unwrap_or(self.stage0_metadata.config.dist_server.to_string());
|
|
// NOTE: make `dist` part of the URL because that's how it's stored in src/stage0.json
|
|
(dist_server, format!("dist/{key}/{filename}"), true)
|
|
}
|
|
};
|
|
|
|
// For the beta compiler, put special effort into ensuring the checksums are valid.
|
|
// FIXME: maybe we should do this for download-rustc as well? but it would be a pain to update
|
|
// this on each and every nightly ...
|
|
let checksum = if should_verify {
|
|
let error = format!(
|
|
"src/stage0.json doesn't contain a checksum for {url}. \
|
|
Pre-built artifacts might not be available for this \
|
|
target at this time, see https://doc.rust-lang.org/nightly\
|
|
/rustc/platform-support.html for more information."
|
|
);
|
|
let sha256 = self.stage0_metadata.checksums_sha256.get(&url).expect(&error);
|
|
if tarball.exists() {
|
|
if self.verify(&tarball, sha256) {
|
|
self.unpack(&tarball, &bin_root, prefix);
|
|
return;
|
|
} else {
|
|
self.verbose(&format!(
|
|
"ignoring cached file {} due to failed verification",
|
|
tarball.display()
|
|
));
|
|
self.remove(&tarball);
|
|
}
|
|
}
|
|
Some(sha256)
|
|
} else if tarball.exists() {
|
|
self.unpack(&tarball, &bin_root, prefix);
|
|
return;
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let mut help_on_error = "";
|
|
if destination == "ci-rustc" {
|
|
help_on_error = "error: failed to download pre-built rustc from CI
|
|
|
|
note: old builds get deleted after a certain time
|
|
help: if trying to compile an old commit of rustc, disable `download-rustc` in config.toml:
|
|
|
|
[rust]
|
|
download-rustc = false
|
|
";
|
|
}
|
|
self.download_file(&format!("{base_url}/{url}"), &tarball, help_on_error);
|
|
if let Some(sha256) = checksum {
|
|
if !self.verify(&tarball, sha256) {
|
|
panic!("failed to verify {}", tarball.display());
|
|
}
|
|
}
|
|
|
|
self.unpack(&tarball, &bin_root, prefix);
|
|
}
|
|
|
|
pub(crate) fn maybe_download_ci_llvm(&self) {
|
|
if !self.llvm_from_ci {
|
|
return;
|
|
}
|
|
let llvm_root = self.ci_llvm_root();
|
|
let llvm_stamp = llvm_root.join(".llvm-stamp");
|
|
let llvm_sha = detect_llvm_sha(&self, self.rust_info.is_managed_git_subrepository());
|
|
let key = format!("{}{}", llvm_sha, self.llvm_assertions);
|
|
if program_out_of_date(&llvm_stamp, &key) && !self.dry_run() {
|
|
self.download_ci_llvm(&llvm_sha);
|
|
if self.should_fix_bins_and_dylibs() {
|
|
for entry in t!(fs::read_dir(llvm_root.join("bin"))) {
|
|
self.fix_bin_or_dylib(&t!(entry).path());
|
|
}
|
|
}
|
|
|
|
// Update the timestamp of llvm-config to force rustc_llvm to be
|
|
// rebuilt. This is a hacky workaround for a deficiency in Cargo where
|
|
// the rerun-if-changed directive doesn't handle changes very well.
|
|
// https://github.com/rust-lang/cargo/issues/10791
|
|
// Cargo only compares the timestamp of the file relative to the last
|
|
// time `rustc_llvm` build script ran. However, the timestamps of the
|
|
// files in the tarball are in the past, so it doesn't trigger a
|
|
// rebuild.
|
|
let now = filetime::FileTime::from_system_time(std::time::SystemTime::now());
|
|
let llvm_config = llvm_root.join("bin").join(exe("llvm-config", self.build));
|
|
t!(filetime::set_file_times(&llvm_config, now, now));
|
|
|
|
if self.should_fix_bins_and_dylibs() {
|
|
let llvm_lib = llvm_root.join("lib");
|
|
for entry in t!(fs::read_dir(&llvm_lib)) {
|
|
let lib = t!(entry).path();
|
|
if lib.extension().map_or(false, |ext| ext == "so") {
|
|
self.fix_bin_or_dylib(&lib);
|
|
}
|
|
}
|
|
}
|
|
|
|
t!(fs::write(llvm_stamp, key));
|
|
}
|
|
}
|
|
|
|
fn download_ci_llvm(&self, llvm_sha: &str) {
|
|
let llvm_assertions = self.llvm_assertions;
|
|
|
|
let cache_prefix = format!("llvm-{llvm_sha}-{llvm_assertions}");
|
|
let cache_dst = self.out.join("cache");
|
|
let rustc_cache = cache_dst.join(cache_prefix);
|
|
if !rustc_cache.exists() {
|
|
t!(fs::create_dir_all(&rustc_cache));
|
|
}
|
|
let base = if llvm_assertions {
|
|
&self.stage0_metadata.config.artifacts_with_llvm_assertions_server
|
|
} else {
|
|
&self.stage0_metadata.config.artifacts_server
|
|
};
|
|
let version = self.artifact_version_part(llvm_sha);
|
|
let filename = format!("rust-dev-{}-{}.tar.xz", version, self.build.triple);
|
|
let tarball = rustc_cache.join(&filename);
|
|
if !tarball.exists() {
|
|
let help_on_error = "error: failed to download llvm from ci
|
|
|
|
help: old builds get deleted after a certain time
|
|
help: if trying to compile an old commit of rustc, disable `download-ci-llvm` in config.toml:
|
|
|
|
[llvm]
|
|
download-ci-llvm = false
|
|
";
|
|
self.download_file(&format!("{base}/{llvm_sha}/{filename}"), &tarball, help_on_error);
|
|
}
|
|
let llvm_root = self.ci_llvm_root();
|
|
self.unpack(&tarball, &llvm_root, "rust-dev");
|
|
}
|
|
}
|