compiler/rustc_codegen_cranelift/build_system/utils.rs

   1 use std::env;
   2 use std::fs;
   3 use std::io::Write;
   4 use std::path::Path;
   5 use std::process::{self, Command, Stdio};
   6
   7 pub(crate) fn cargo_command(
   8     cargo: impl AsRef<Path>,
   9     subcommand: &str,
  10     triple: Option<&str>,
  11     source_dir: &Path,
  12 ) -> Command {
  13     let mut cmd = Command::new(cargo.as_ref());
  14     cmd.arg(subcommand)
  15         .arg("--manifest-path")
  16         .arg(source_dir.join("Cargo.toml"))
  17         .arg("--target-dir")
  18         .arg(source_dir.join("target"));
  19
  20     if let Some(triple) = triple {
  21         cmd.arg("--target").arg(triple);
  22     }
  23
  24     cmd
  25 }
  26
  27 pub(crate) fn hyperfine_command(
  28     warmup: u64,
  29     runs: u64,
  30     prepare: Option<Command>,
  31     a: Command,
  32     b: Command,
  33 ) -> Command {
  34     let mut bench = Command::new("hyperfine");
  35
  36     if warmup != 0 {
  37         bench.arg("--warmup").arg(warmup.to_string());
  38     }
  39
  40     if runs != 0 {
  41         bench.arg("--runs").arg(runs.to_string());
  42     }
  43
  44     if let Some(prepare) = prepare {
  45         bench.arg("--prepare").arg(format!("{:?}", prepare));
  46     }
  47
  48     bench.arg(format!("{:?}", a)).arg(format!("{:?}", b));
  49
  50     bench
  51 }
  52
  53 #[track_caller]
  54 pub(crate) fn try_hard_link(src: impl AsRef<Path>, dst: impl AsRef<Path>) {
  55     let src = src.as_ref();
  56     let dst = dst.as_ref();
  57     if let Err(_) = fs::hard_link(src, dst) {
  58         fs::copy(src, dst).unwrap(); // Fallback to copying if hardlinking failed
  59     }
  60 }
  61
  62 #[track_caller]
  63 pub(crate) fn spawn_and_wait(mut cmd: Command) {
  64     if !cmd.spawn().unwrap().wait().unwrap().success() {
  65         process::exit(1);
  66     }
  67 }
  68
  69 #[track_caller]
  70 pub(crate) fn spawn_and_wait_with_input(mut cmd: Command, input: String) -> String {
  71     let mut child = cmd
  72         .stdin(Stdio::piped())
  73         .stdout(Stdio::piped())
  74         .spawn()
  75         .expect("Failed to spawn child process");
  76
  77     let mut stdin = child.stdin.take().expect("Failed to open stdin");
  78     std::thread::spawn(move || {
  79         stdin.write_all(input.as_bytes()).expect("Failed to write to stdin");
  80     });
  81
  82     let output = child.wait_with_output().expect("Failed to read stdout");
  83     if !output.status.success() {
  84         process::exit(1);
  85     }
  86
  87     String::from_utf8(output.stdout).unwrap()
  88 }
  89
  90 pub(crate) fn copy_dir_recursively(from: &Path, to: &Path) {
  91     for entry in fs::read_dir(from).unwrap() {
  92         let entry = entry.unwrap();
  93         let filename = entry.file_name();
  94         if filename == "." || filename == ".." {
  95             continue;
  96         }
  97         if entry.metadata().unwrap().is_dir() {
  98             fs::create_dir(to.join(&filename)).unwrap();
  99             copy_dir_recursively(&from.join(&filename), &to.join(&filename));
 100         } else {
 101             fs::copy(from.join(&filename), to.join(&filename)).unwrap();
 102         }
 103     }
 104 }
 105
 106 pub(crate) fn is_ci() -> bool {
 107     env::var("CI").as_deref() == Ok("true")
 108 }