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);
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");
}
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
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
CG_CLIF
.target_dir(dirs)
- .join(host_triple)
+ .join(&host_compiler.triple)
.join(channel)
.join(get_file_name("rustc_codegen_cranelift", "dylib"))
}
channel: &str,
sysroot_kind: SysrootKind,
cg_clif_dylib_src: &Path,
- host_triple: &str,
+ host_compiler: &Compiler,
target_triple: &str,
) {
eprintln!("[BUILD] sysroot {:?}", sysroot_kind);
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();
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()
{
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"),
)
}
}
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"),
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,
);
fn build_clif_sysroot_for_triple(
dirs: &Dirs,
channel: &str,
- triple: &str,
+ mut compiler: Compiler,
cg_clif_dylib_path: &Path,
linker: Option<&str>,
) {
}
}
- 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
}
// 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" {
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");
};
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()),
);
}
}
use std::path::PathBuf;
use std::process;
-use self::utils::is_ci;
+use self::utils::{is_ci, Compiler};
mod abi_cafe;
mod bench;
}
}
- 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();
}
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
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(
channel,
sysroot_kind,
&cg_clif_dylib,
- &host_triple,
+ &host_compiler,
&target_triple,
);
}
channel,
sysroot_kind,
&cg_clif_dylib,
- &host_triple,
+ &host_compiler,
&target_triple,
);
- bench::benchmark(&dirs);
+ bench::benchmark(&dirs, &host_compiler);
}
}
}
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(
channel,
SysrootKind::None,
cg_clif_dylib,
- &host_triple,
+ host_compiler,
&target_triple,
);
channel,
sysroot_kind,
cg_clif_dylib,
- &host_triple,
+ host_compiler,
&target_triple,
);
}
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![];
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,
}
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(),