From 70a1cb9e62df17fbba0d30c884c7d98edf2ef780 Mon Sep 17 00:00:00 2001 From: bjorn3 <17426603+bjorn3@users.noreply.github.com> Date: Fri, 13 Jan 2023 12:16:11 +0000 Subject: [PATCH] Pass around Compiler instead of target triples --- build_system/abi_cafe.rs | 14 +++------ build_system/bench.rs | 9 +++--- build_system/build_backend.rs | 6 ++-- build_system/build_sysroot.rs | 35 ++++++++++++++--------- build_system/mod.rs | 54 ++++++++++++++--------------------- build_system/tests.rs | 11 +++---- build_system/utils.rs | 19 ++---------- 7 files changed, 64 insertions(+), 84 deletions(-) diff --git a/build_system/abi_cafe.rs b/build_system/abi_cafe.rs index a081fdaa1c7..5f20a377329 100644 --- a/build_system/abi_cafe.rs +++ b/build_system/abi_cafe.rs @@ -17,34 +17,28 @@ pub(crate) fn run( sysroot_kind: SysrootKind, dirs: &Dirs, cg_clif_dylib: &Path, - host_triple: &str, - target_triple: &str, + host_compiler: &Compiler, ) { if !config::get_bool("testsuite.abi-cafe") { eprintln!("[SKIP] abi-cafe"); return; } - if host_triple != target_triple { - eprintln!("[SKIP] abi-cafe (cross-compilation not supported)"); - return; - } - eprintln!("Building sysroot for abi-cafe"); build_sysroot::build_sysroot( dirs, channel, sysroot_kind, cg_clif_dylib, - host_triple, - target_triple, + host_compiler, + &host_compiler.triple, ); eprintln!("Running abi-cafe"); let pairs = ["rustc_calls_cgclif", "cgclif_calls_rustc", "cgclif_calls_cc", "cc_calls_cgclif"]; - let mut cmd = ABI_CAFE.run(&Compiler::host(), dirs); + let mut cmd = ABI_CAFE.run(host_compiler, dirs); cmd.arg("--"); cmd.arg("--pairs"); cmd.args(pairs); diff --git a/build_system/bench.rs b/build_system/bench.rs index e0956cb44ba..f5c5d92cb32 100644 --- a/build_system/bench.rs +++ b/build_system/bench.rs @@ -21,11 +21,11 @@ pub(crate) static SIMPLE_RAYTRACER: CargoProject = CargoProject::new(&SIMPLE_RAYTRACER_REPO.source_dir(), "simple_raytracer"); -pub(crate) fn benchmark(dirs: &Dirs) { - benchmark_simple_raytracer(dirs); +pub(crate) fn benchmark(dirs: &Dirs, host_compiler: &Compiler) { + benchmark_simple_raytracer(dirs, host_compiler); } -fn benchmark_simple_raytracer(dirs: &Dirs) { +fn benchmark_simple_raytracer(dirs: &Dirs, host_compiler: &Compiler) { if std::process::Command::new("hyperfine").output().is_err() { eprintln!("Hyperfine not installed"); eprintln!("Hint: Try `cargo install hyperfine` to install hyperfine"); @@ -33,8 +33,7 @@ fn benchmark_simple_raytracer(dirs: &Dirs) { } eprintln!("[LLVM BUILD] simple-raytracer"); - let host_compiler = Compiler::host(); - let build_cmd = SIMPLE_RAYTRACER_LLVM.build(&host_compiler, dirs); + let build_cmd = SIMPLE_RAYTRACER_LLVM.build(host_compiler, dirs); spawn_and_wait(build_cmd); fs::copy( SIMPLE_RAYTRACER_LLVM diff --git a/build_system/build_backend.rs b/build_system/build_backend.rs index 16b43c5fc85..00d9a6ddea8 100644 --- a/build_system/build_backend.rs +++ b/build_system/build_backend.rs @@ -10,10 +10,10 @@ pub(crate) fn build_backend( dirs: &Dirs, channel: &str, - host_triple: &str, + host_compiler: &Compiler, use_unstable_features: bool, ) -> PathBuf { - let mut cmd = CG_CLIF.build(&Compiler::host(), dirs); + let mut cmd = CG_CLIF.build(&host_compiler, dirs); cmd.env("CARGO_BUILD_INCREMENTAL", "true"); // Force incr comp even in release mode @@ -48,7 +48,7 @@ pub(crate) fn build_backend( CG_CLIF .target_dir(dirs) - .join(host_triple) + .join(&host_compiler.triple) .join(channel) .join(get_file_name("rustc_codegen_cranelift", "dylib")) } diff --git a/build_system/build_sysroot.rs b/build_system/build_sysroot.rs index 711d4ccc55b..f7bdf517976 100644 --- a/build_system/build_sysroot.rs +++ b/build_system/build_sysroot.rs @@ -17,7 +17,7 @@ pub(crate) fn build_sysroot( channel: &str, sysroot_kind: SysrootKind, cg_clif_dylib_src: &Path, - host_triple: &str, + host_compiler: &Compiler, target_triple: &str, ) { eprintln!("[BUILD] sysroot {:?}", sysroot_kind); @@ -53,7 +53,7 @@ pub(crate) fn build_sysroot( let default_sysroot = super::rustc_info::get_default_sysroot(); - let host_rustlib_lib = RUSTLIB_DIR.to_path(dirs).join(host_triple).join("lib"); + let host_rustlib_lib = RUSTLIB_DIR.to_path(dirs).join(&host_compiler.triple).join("lib"); let target_rustlib_lib = RUSTLIB_DIR.to_path(dirs).join(target_triple).join("lib"); fs::create_dir_all(&host_rustlib_lib).unwrap(); fs::create_dir_all(&target_rustlib_lib).unwrap(); @@ -83,7 +83,7 @@ pub(crate) fn build_sysroot( SysrootKind::None => {} // Nothing to do SysrootKind::Llvm => { for file in fs::read_dir( - default_sysroot.join("lib").join("rustlib").join(host_triple).join("lib"), + default_sysroot.join("lib").join("rustlib").join(&host_compiler.triple).join("lib"), ) .unwrap() { @@ -103,7 +103,7 @@ pub(crate) fn build_sysroot( try_hard_link(&file, host_rustlib_lib.join(file.file_name().unwrap())); } - if target_triple != host_triple { + if target_triple != host_compiler.triple { for file in fs::read_dir( default_sysroot.join("lib").join("rustlib").join(target_triple).join("lib"), ) @@ -115,9 +115,15 @@ pub(crate) fn build_sysroot( } } SysrootKind::Clif => { - build_clif_sysroot_for_triple(dirs, channel, host_triple, &cg_clif_dylib_path, None); + build_clif_sysroot_for_triple( + dirs, + channel, + host_compiler.clone(), + &cg_clif_dylib_path, + None, + ); - if host_triple != target_triple { + if host_compiler.triple != target_triple { // When cross-compiling it is often necessary to manually pick the right linker let linker = match target_triple { "aarch64-unknown-linux-gnu" => Some("aarch64-linux-gnu-gcc"), @@ -127,7 +133,11 @@ pub(crate) fn build_sysroot( build_clif_sysroot_for_triple( dirs, channel, - target_triple, + { + let mut target_compiler = host_compiler.clone(); + target_compiler.triple = target_triple.to_owned(); + target_compiler + }, &cg_clif_dylib_path, linker, ); @@ -155,7 +165,7 @@ pub(crate) fn build_sysroot( fn build_clif_sysroot_for_triple( dirs: &Dirs, channel: &str, - triple: &str, + mut compiler: Compiler, cg_clif_dylib_path: &Path, linker: Option<&str>, ) { @@ -177,7 +187,7 @@ fn build_clif_sysroot_for_triple( } } - let build_dir = STANDARD_LIBRARY.target_dir(dirs).join(triple).join(channel); + let build_dir = STANDARD_LIBRARY.target_dir(dirs).join(&compiler.triple).join(channel); if !super::config::get_bool("keep_sysroot") { // Cleanup the deps dir, but keep build scripts and the incremental cache for faster @@ -188,7 +198,7 @@ fn build_clif_sysroot_for_triple( } // Build sysroot - let mut rustflags = "-Zforce-unstable-if-unmarked -Cpanic=abort".to_string(); + let mut rustflags = " -Zforce-unstable-if-unmarked -Cpanic=abort".to_string(); rustflags.push_str(&format!(" -Zcodegen-backend={}", cg_clif_dylib_path.to_str().unwrap())); rustflags.push_str(&format!(" --sysroot={}", DIST_DIR.to_path(dirs).to_str().unwrap())); if channel == "release" { @@ -198,8 +208,7 @@ fn build_clif_sysroot_for_triple( use std::fmt::Write; write!(rustflags, " -Clinker={}", linker).unwrap(); } - let mut compiler = Compiler::with_triple(triple.to_owned()); - compiler.rustflags = rustflags; + compiler.rustflags += &rustflags; let mut build_cmd = STANDARD_LIBRARY.build(&compiler, dirs); if channel == "release" { build_cmd.arg("--release"); @@ -219,7 +228,7 @@ fn build_clif_sysroot_for_triple( }; try_hard_link( entry.path(), - RUSTLIB_DIR.to_path(dirs).join(triple).join("lib").join(entry.file_name()), + RUSTLIB_DIR.to_path(dirs).join(&compiler.triple).join("lib").join(entry.file_name()), ); } } diff --git a/build_system/mod.rs b/build_system/mod.rs index 1c25c515e6b..f2de07cf5eb 100644 --- a/build_system/mod.rs +++ b/build_system/mod.rs @@ -2,7 +2,7 @@ use std::path::PathBuf; use std::process; -use self::utils::is_ci; +use self::utils::{is_ci, Compiler}; mod abi_cafe; mod bench; @@ -121,24 +121,16 @@ pub fn main() { } } - let host_triple = if let Ok(host_triple) = std::env::var("HOST_TRIPLE") { - host_triple - } else if let Some(host_triple) = config::get_value("host") { - host_triple - } else { - rustc_info::get_host_triple() - }; - let target_triple = if let Ok(target_triple) = std::env::var("TARGET_TRIPLE") { - if target_triple != "" { - target_triple - } else { - host_triple.clone() // Empty target triple can happen on GHA - } - } else if let Some(target_triple) = config::get_value("target") { - target_triple - } else { - host_triple.clone() - }; + let host_compiler = Compiler::llvm_with_triple( + std::env::var("HOST_TRIPLE") + .ok() + .or_else(|| config::get_value("host")) + .unwrap_or_else(|| rustc_info::get_host_triple()), + ); + let target_triple = std::env::var("TARGET_TRIPLE") + .ok() + .or_else(|| config::get_value("target")) + .unwrap_or_else(|| host_compiler.triple.clone()); // FIXME allow changing the location of these dirs using cli arguments let current_dir = std::env::current_dir().unwrap(); @@ -167,7 +159,7 @@ pub fn main() { } let cg_clif_dylib = - build_backend::build_backend(&dirs, channel, &host_triple, use_unstable_features); + build_backend::build_backend(&dirs, channel, &host_compiler, use_unstable_features); match command { Command::Prepare => { // Handled above @@ -178,18 +170,16 @@ pub fn main() { channel, sysroot_kind, &cg_clif_dylib, - &host_triple, + &host_compiler, &target_triple, ); - abi_cafe::run( - channel, - sysroot_kind, - &dirs, - &cg_clif_dylib, - &host_triple, - &target_triple, - ); + if host_compiler.triple == target_triple { + abi_cafe::run(channel, sysroot_kind, &dirs, &cg_clif_dylib, &host_compiler); + } else { + eprintln!("[SKIP] abi-cafe (cross-compilation not supported)"); + return; + } } Command::Build => { build_sysroot::build_sysroot( @@ -197,7 +187,7 @@ pub fn main() { channel, sysroot_kind, &cg_clif_dylib, - &host_triple, + &host_compiler, &target_triple, ); } @@ -207,10 +197,10 @@ pub fn main() { channel, sysroot_kind, &cg_clif_dylib, - &host_triple, + &host_compiler, &target_triple, ); - bench::benchmark(&dirs); + bench::benchmark(&dirs, &host_compiler); } } } diff --git a/build_system/tests.rs b/build_system/tests.rs index 5b8b6f2df10..9139b3ccecc 100644 --- a/build_system/tests.rs +++ b/build_system/tests.rs @@ -385,10 +385,11 @@ pub(crate) fn run_tests( channel: &str, sysroot_kind: SysrootKind, cg_clif_dylib: &Path, - host_triple: &str, + host_compiler: &Compiler, target_triple: &str, ) { - let runner = TestRunner::new(dirs.clone(), host_triple.to_string(), target_triple.to_string()); + let runner = + TestRunner::new(dirs.clone(), host_compiler.triple.clone(), target_triple.to_string()); if config::get_bool("testsuite.no_sysroot") { build_sysroot::build_sysroot( @@ -396,7 +397,7 @@ pub(crate) fn run_tests( channel, SysrootKind::None, cg_clif_dylib, - &host_triple, + host_compiler, &target_triple, ); @@ -415,7 +416,7 @@ pub(crate) fn run_tests( channel, sysroot_kind, cg_clif_dylib, - &host_triple, + host_compiler, &target_triple, ); } @@ -445,7 +446,7 @@ impl TestRunner { pub fn new(dirs: Dirs, host_triple: String, target_triple: String) -> Self { let is_native = host_triple == target_triple; let jit_supported = - target_triple.contains("x86_64") && is_native && !host_triple.contains("windows"); + is_native && host_triple.contains("x86_64") && !host_triple.contains("windows"); let mut rustflags = env::var("RUSTFLAGS").ok().unwrap_or("".to_string()); let mut runner = vec![]; diff --git a/build_system/utils.rs b/build_system/utils.rs index 3d6617d4458..d244da1b2e0 100644 --- a/build_system/utils.rs +++ b/build_system/utils.rs @@ -5,10 +5,9 @@ use std::process::{self, Command, Stdio}; use super::path::{Dirs, RelPath}; -use super::rustc_info::{ - get_cargo_path, get_host_triple, get_rustc_path, get_rustdoc_path, get_wrapper_file_name, -}; +use super::rustc_info::{get_cargo_path, get_rustc_path, get_rustdoc_path, get_wrapper_file_name}; +#[derive(Clone, Debug)] pub(crate) struct Compiler { pub(crate) cargo: PathBuf, pub(crate) rustc: PathBuf, @@ -20,19 +19,7 @@ pub(crate) struct Compiler { } impl Compiler { - pub(crate) fn host() -> Compiler { - Compiler { - cargo: get_cargo_path(), - rustc: get_rustc_path(), - rustdoc: get_rustdoc_path(), - rustflags: String::new(), - rustdocflags: String::new(), - triple: get_host_triple(), - runner: vec![], - } - } - - pub(crate) fn with_triple(triple: String) -> Compiler { + pub(crate) fn llvm_with_triple(triple: String) -> Compiler { Compiler { cargo: get_cargo_path(), rustc: get_rustc_path(),