compiler/rustc_codegen_cranelift/src/bin/cg_clif_build_sysroot.rs

   1 //! The only difference between this and cg_clif.rs is that this binary defaults to using cg_llvm
   2 //! instead of cg_clif and requires `--clif` to use cg_clif and that this binary doesn't have JIT
   3 //! support.
   4 //! This is necessary as with Cargo `RUSTC` applies to both target crates and host crates. The host
   5 //! crates must be built with cg_llvm as we are currently building a sysroot for cg_clif.
   6 //! `RUSTFLAGS` however is only applied to target crates, so `--clif` would only be passed to the
   7 //! target crates.
   8
   9 #![feature(rustc_private)]
  10
  11 extern crate rustc_data_structures;
  12 extern crate rustc_driver;
  13 extern crate rustc_interface;
  14 extern crate rustc_session;
  15 extern crate rustc_target;
  16
  17 use std::path::PathBuf;
  18
  19 use rustc_interface::interface;
  20 use rustc_session::config::ErrorOutputType;
  21 use rustc_session::early_error;
  22 use rustc_target::spec::PanicStrategy;
  23
  24 fn find_sysroot() -> String {
  25     // Taken from https://github.com/Manishearth/rust-clippy/pull/911.
  26     let home = option_env!("RUSTUP_HOME").or(option_env!("MULTIRUST_HOME"));
  27     let toolchain = option_env!("RUSTUP_TOOLCHAIN").or(option_env!("MULTIRUST_TOOLCHAIN"));
  28     match (home, toolchain) {
  29         (Some(home), Some(toolchain)) => format!("{}/toolchains/{}", home, toolchain),
  30         _ => option_env!("RUST_SYSROOT")
  31             .expect("need to specify RUST_SYSROOT env var or use rustup or multirust")
  32             .to_owned(),
  33     }
  34 }
  35
  36 pub struct CraneliftPassesCallbacks {
  37     use_clif: bool,
  38 }
  39
  40 impl rustc_driver::Callbacks for CraneliftPassesCallbacks {
  41     fn config(&mut self, config: &mut interface::Config) {
  42         if !self.use_clif {
  43             config.opts.maybe_sysroot = Some(PathBuf::from(find_sysroot()));
  44             return;
  45         }
  46
  47         // FIXME workaround for an ICE
  48         config.opts.debugging_opts.trim_diagnostic_paths = false;
  49
  50         config.opts.cg.panic = Some(PanicStrategy::Abort);
  51         config.opts.debugging_opts.panic_abort_tests = true;
  52         config.opts.maybe_sysroot = Some(
  53             std::env::current_exe()
  54                 .unwrap()
  55                 .parent()
  56                 .unwrap()
  57                 .parent()
  58                 .unwrap()
  59                 .parent()
  60                 .unwrap()
  61                 .join("build_sysroot")
  62                 .join("sysroot"),
  63         );
  64     }
  65 }
  66
  67 fn main() {
  68     rustc_driver::init_rustc_env_logger();
  69     rustc_driver::install_ice_hook();
  70     let exit_code = rustc_driver::catch_with_exit_code(|| {
  71         let mut use_clif = false;
  72
  73         let args = std::env::args_os()
  74             .enumerate()
  75             .map(|(i, arg)| {
  76                 arg.into_string().unwrap_or_else(|arg| {
  77                     early_error(
  78                         ErrorOutputType::default(),
  79                         &format!("Argument {} is not valid Unicode: {:?}", i, arg),
  80                     )
  81                 })
  82             })
  83             .filter(|arg| {
  84                 if arg == "--clif" {
  85                     use_clif = true;
  86                     false
  87                 } else {
  88                     true
  89                 }
  90             })
  91             .collect::<Vec<_>>();
  92
  93         let mut callbacks = CraneliftPassesCallbacks { use_clif };
  94
  95         let mut run_compiler = rustc_driver::RunCompiler::new(&args, &mut callbacks);
  96         if use_clif {
  97             run_compiler.set_make_codegen_backend(Some(Box::new(move |_| {
  98                 Box::new(rustc_codegen_cranelift::CraneliftCodegenBackend {
  99                     config: rustc_codegen_cranelift::BackendConfig { use_jit: false },
 100                 })
 101             })));
 102         }
 103         run_compiler.run()
 104     });
 105     std::process::exit(exit_code)
 106 }