compiler/rustc_codegen_cranelift/src/config.rs

   1 use std::env;
   2 use std::str::FromStr;
   3
   4 fn bool_env_var(key: &str) -> bool {
   5     env::var(key).as_deref() == Ok("1")
   6 }
   7
   8 /// The mode to use for compilation.
   9 #[derive(Copy, Clone, Debug)]
  10 pub enum CodegenMode {
  11     /// AOT compile the crate. This is the default.
  12     Aot,
  13     /// JIT compile and execute the crate.
  14     Jit,
  15     /// JIT compile and execute the crate, but only compile functions the first time they are used.
  16     JitLazy,
  17 }
  18
  19 impl FromStr for CodegenMode {
  20     type Err = String;
  21
  22     fn from_str(s: &str) -> Result<Self, Self::Err> {
  23         match s {
  24             "aot" => Ok(CodegenMode::Aot),
  25             "jit" => Ok(CodegenMode::Jit),
  26             "jit-lazy" => Ok(CodegenMode::JitLazy),
  27             _ => Err(format!("Unknown codegen mode `{}`", s)),
  28         }
  29     }
  30 }
  31
  32 /// Configuration of cg_clif as passed in through `-Cllvm-args` and various env vars.
  33 #[derive(Clone, Debug)]
  34 pub struct BackendConfig {
  35     /// Should the crate be AOT compiled or JIT executed.
  36     ///
  37     /// Defaults to AOT compilation. Can be set using `-Cllvm-args=mode=...`.
  38     pub codegen_mode: CodegenMode,
  39
  40     /// When JIT mode is enable pass these arguments to the program.
  41     ///
  42     /// Defaults to the value of `CG_CLIF_JIT_ARGS`.
  43     pub jit_args: Vec<String>,
  44
  45     /// Enable the Cranelift ir verifier for all compilation passes. If not set it will only run
  46     /// once before passing the clif ir to Cranelift for compilation.
  47     ///
  48     /// Defaults to true when the `CG_CLIF_ENABLE_VERIFIER` env var is set to 1 or when cg_clif is
  49     /// compiled with debug assertions enabled or false otherwise. Can be set using
  50     /// `-Cllvm-args=enable_verifier=...`.
  51     pub enable_verifier: bool,
  52
  53     /// Don't cache object files in the incremental cache. Useful during development of cg_clif
  54     /// to make it possible to use incremental mode for all analyses performed by rustc without
  55     /// caching object files when their content should have been changed by a change to cg_clif.
  56     ///
  57     /// Defaults to true when the `CG_CLIF_DISABLE_INCR_CACHE` env var is set to 1 or false
  58     /// otherwise. Can be set using `-Cllvm-args=disable_incr_cache=...`.
  59     pub disable_incr_cache: bool,
  60 }
  61
  62 impl Default for BackendConfig {
  63     fn default() -> Self {
  64         BackendConfig {
  65             codegen_mode: CodegenMode::Aot,
  66             jit_args: {
  67                 let args = std::env::var("CG_CLIF_JIT_ARGS").unwrap_or_else(|_| String::new());
  68                 args.split(' ').map(|arg| arg.to_string()).collect()
  69             },
  70             enable_verifier: cfg!(debug_assertions) || bool_env_var("CG_CLIF_ENABLE_VERIFIER"),
  71             disable_incr_cache: bool_env_var("CG_CLIF_DISABLE_INCR_CACHE"),
  72         }
  73     }
  74 }
  75
  76 impl BackendConfig {
  77     /// Parse the configuration passed in using `-Cllvm-args`.
  78     pub fn from_opts(opts: &[String]) -> Result<Self, String> {
  79         fn parse_bool(name: &str, value: &str) -> Result<bool, String> {
  80             value.parse().map_err(|_| format!("failed to parse value `{}` for {}", value, name))
  81         }
  82
  83         let mut config = BackendConfig::default();
  84         for opt in opts {
  85             if let Some((name, value)) = opt.split_once('=') {
  86                 match name {
  87                     "mode" => config.codegen_mode = value.parse()?,
  88                     "enable_verifier" => config.enable_verifier = parse_bool(name, value)?,
  89                     "disable_incr_cache" => config.disable_incr_cache = parse_bool(name, value)?,
  90                     _ => return Err(format!("Unknown option `{}`", name)),
  91                 }
  92             } else {
  93                 return Err(format!("Invalid option `{}`", opt));
  94             }
  95         }
  96
  97         Ok(config)
  98     }
  99 }