223 lines
8.2 KiB
Rust
223 lines
8.2 KiB
Rust
use std::fs;
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::{self, Command};
|
|
|
|
use super::rustc_info::{get_file_name, get_rustc_version, get_wrapper_file_name};
|
|
use super::utils::{spawn_and_wait, try_hard_link};
|
|
use super::SysrootKind;
|
|
|
|
pub(crate) fn build_sysroot(
|
|
channel: &str,
|
|
sysroot_kind: SysrootKind,
|
|
target_dir: &Path,
|
|
cg_clif_dylib_src: &Path,
|
|
host_triple: &str,
|
|
target_triple: &str,
|
|
) {
|
|
eprintln!("[BUILD] sysroot {:?}", sysroot_kind);
|
|
|
|
if target_dir.exists() {
|
|
fs::remove_dir_all(target_dir).unwrap();
|
|
}
|
|
fs::create_dir_all(target_dir.join("bin")).unwrap();
|
|
fs::create_dir_all(target_dir.join("lib")).unwrap();
|
|
|
|
// Copy the backend
|
|
let cg_clif_dylib_path = target_dir
|
|
.join(if cfg!(windows) {
|
|
// Windows doesn't have rpath support, so the cg_clif dylib needs to be next to the
|
|
// binaries.
|
|
"bin"
|
|
} else {
|
|
"lib"
|
|
})
|
|
.join(get_file_name("rustc_codegen_cranelift", "dylib"));
|
|
try_hard_link(cg_clif_dylib_src, &cg_clif_dylib_path);
|
|
|
|
// Build and copy rustc and cargo wrappers
|
|
for wrapper in ["rustc-clif", "cargo-clif"] {
|
|
let wrapper_name = get_wrapper_file_name(wrapper, "bin");
|
|
|
|
let mut build_cargo_wrapper_cmd = Command::new("rustc");
|
|
build_cargo_wrapper_cmd
|
|
.arg(PathBuf::from("scripts").join(format!("{wrapper}.rs")))
|
|
.arg("-o")
|
|
.arg(target_dir.join(wrapper_name))
|
|
.arg("-g");
|
|
spawn_and_wait(build_cargo_wrapper_cmd);
|
|
}
|
|
|
|
let default_sysroot = super::rustc_info::get_default_sysroot();
|
|
|
|
let rustlib = target_dir.join("lib").join("rustlib");
|
|
let host_rustlib_lib = rustlib.join(host_triple).join("lib");
|
|
let target_rustlib_lib = rustlib.join(target_triple).join("lib");
|
|
fs::create_dir_all(&host_rustlib_lib).unwrap();
|
|
fs::create_dir_all(&target_rustlib_lib).unwrap();
|
|
|
|
if target_triple == "x86_64-pc-windows-gnu" {
|
|
if !default_sysroot.join("lib").join("rustlib").join(target_triple).join("lib").exists() {
|
|
eprintln!(
|
|
"The x86_64-pc-windows-gnu target needs to be installed first before it is possible \
|
|
to compile a sysroot for it.",
|
|
);
|
|
process::exit(1);
|
|
}
|
|
for file in fs::read_dir(
|
|
default_sysroot.join("lib").join("rustlib").join(target_triple).join("lib"),
|
|
)
|
|
.unwrap()
|
|
{
|
|
let file = file.unwrap().path();
|
|
if file.extension().map_or(true, |ext| ext.to_str().unwrap() != "o") {
|
|
continue; // only copy object files
|
|
}
|
|
try_hard_link(&file, target_rustlib_lib.join(file.file_name().unwrap()));
|
|
}
|
|
}
|
|
|
|
match sysroot_kind {
|
|
SysrootKind::None => {} // Nothing to do
|
|
SysrootKind::Llvm => {
|
|
for file in fs::read_dir(
|
|
default_sysroot.join("lib").join("rustlib").join(host_triple).join("lib"),
|
|
)
|
|
.unwrap()
|
|
{
|
|
let file = file.unwrap().path();
|
|
let file_name_str = file.file_name().unwrap().to_str().unwrap();
|
|
if (file_name_str.contains("rustc_")
|
|
&& !file_name_str.contains("rustc_std_workspace_")
|
|
&& !file_name_str.contains("rustc_demangle"))
|
|
|| file_name_str.contains("chalk")
|
|
|| file_name_str.contains("tracing")
|
|
|| file_name_str.contains("regex")
|
|
{
|
|
// These are large crates that are part of the rustc-dev component and are not
|
|
// necessary to run regular programs.
|
|
continue;
|
|
}
|
|
try_hard_link(&file, host_rustlib_lib.join(file.file_name().unwrap()));
|
|
}
|
|
|
|
if target_triple != host_triple {
|
|
for file in fs::read_dir(
|
|
default_sysroot.join("lib").join("rustlib").join(target_triple).join("lib"),
|
|
)
|
|
.unwrap()
|
|
{
|
|
let file = file.unwrap().path();
|
|
try_hard_link(&file, target_rustlib_lib.join(file.file_name().unwrap()));
|
|
}
|
|
}
|
|
}
|
|
SysrootKind::Clif => {
|
|
build_clif_sysroot_for_triple(
|
|
channel,
|
|
target_dir,
|
|
host_triple,
|
|
&cg_clif_dylib_path,
|
|
None,
|
|
);
|
|
|
|
if host_triple != target_triple {
|
|
// When cross-compiling it is often necessary to manually pick the right linker
|
|
let linker = if target_triple == "aarch64-unknown-linux-gnu" {
|
|
Some("aarch64-linux-gnu-gcc")
|
|
} else {
|
|
None
|
|
};
|
|
build_clif_sysroot_for_triple(
|
|
channel,
|
|
target_dir,
|
|
target_triple,
|
|
&cg_clif_dylib_path,
|
|
linker,
|
|
);
|
|
}
|
|
|
|
// Copy std for the host to the lib dir. This is necessary for the jit mode to find
|
|
// libstd.
|
|
for file in fs::read_dir(host_rustlib_lib).unwrap() {
|
|
let file = file.unwrap().path();
|
|
let filename = file.file_name().unwrap().to_str().unwrap();
|
|
if filename.contains("std-") && !filename.contains(".rlib") {
|
|
try_hard_link(&file, target_dir.join("lib").join(file.file_name().unwrap()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn build_clif_sysroot_for_triple(
|
|
channel: &str,
|
|
target_dir: &Path,
|
|
triple: &str,
|
|
cg_clif_dylib_path: &Path,
|
|
linker: Option<&str>,
|
|
) {
|
|
match fs::read_to_string(Path::new("build_sysroot").join("rustc_version")) {
|
|
Err(e) => {
|
|
eprintln!("Failed to get rustc version for patched sysroot source: {}", e);
|
|
eprintln!("Hint: Try `./y.rs prepare` to patch the sysroot source");
|
|
process::exit(1);
|
|
}
|
|
Ok(source_version) => {
|
|
let rustc_version = get_rustc_version();
|
|
if source_version != rustc_version {
|
|
eprintln!("The patched sysroot source is outdated");
|
|
eprintln!("Source version: {}", source_version.trim());
|
|
eprintln!("Rustc version: {}", rustc_version.trim());
|
|
eprintln!("Hint: Try `./y.rs prepare` to update the patched sysroot source");
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
let build_dir = Path::new("build_sysroot").join("target").join(triple).join(channel);
|
|
|
|
if !super::config::get_bool("keep_sysroot") {
|
|
// Cleanup the deps dir, but keep build scripts and the incremental cache for faster
|
|
// recompilation as they are not affected by changes in cg_clif.
|
|
if build_dir.join("deps").exists() {
|
|
fs::remove_dir_all(build_dir.join("deps")).unwrap();
|
|
}
|
|
}
|
|
|
|
// Build sysroot
|
|
let mut build_cmd = Command::new("cargo");
|
|
build_cmd.arg("build").arg("--target").arg(triple).current_dir("build_sysroot");
|
|
let mut rustflags = "-Zforce-unstable-if-unmarked -Cpanic=abort".to_string();
|
|
rustflags.push_str(&format!(" -Zcodegen-backend={}", cg_clif_dylib_path.to_str().unwrap()));
|
|
if channel == "release" {
|
|
build_cmd.arg("--release");
|
|
rustflags.push_str(" -Zmir-opt-level=3");
|
|
}
|
|
if let Some(linker) = linker {
|
|
use std::fmt::Write;
|
|
write!(rustflags, " -Clinker={}", linker).unwrap();
|
|
}
|
|
build_cmd.env("RUSTFLAGS", rustflags);
|
|
build_cmd.env("__CARGO_DEFAULT_LIB_METADATA", "cg_clif");
|
|
spawn_and_wait(build_cmd);
|
|
|
|
// Copy all relevant files to the sysroot
|
|
for entry in
|
|
fs::read_dir(Path::new("build_sysroot/target").join(triple).join(channel).join("deps"))
|
|
.unwrap()
|
|
{
|
|
let entry = entry.unwrap();
|
|
if let Some(ext) = entry.path().extension() {
|
|
if ext == "rmeta" || ext == "d" || ext == "dSYM" || ext == "clif" {
|
|
continue;
|
|
}
|
|
} else {
|
|
continue;
|
|
};
|
|
try_hard_link(
|
|
entry.path(),
|
|
target_dir.join("lib").join("rustlib").join(triple).join("lib").join(entry.file_name()),
|
|
);
|
|
}
|
|
}
|