use std::cmp;
use build_helper::t;
-use num_cpus;
use toml;
use serde::Deserialize;
use crate::cache::{INTERNER, Interned};
pub test_compare_mode: bool,
pub llvm_libunwind: bool,
- pub run_host_only: bool,
+ pub skip_only_host_steps: bool,
pub on_fail: Option<String>,
pub stage: Option<u32>,
pub rust_codegen_units: Option<u32>,
pub rust_codegen_units_std: Option<u32>,
pub rust_debug_assertions: bool,
- pub rust_debuginfo: bool,
- pub rust_debuginfo_lines: bool,
- pub rust_debuginfo_only_std: bool,
- pub rust_debuginfo_tools: bool,
+ pub rust_debuginfo_level_rustc: u32,
+ pub rust_debuginfo_level_std: u32,
+ pub rust_debuginfo_level_tools: u32,
+ pub rust_debuginfo_level_tests: u32,
pub rust_rpath: bool,
pub rustc_parallel: bool,
pub rustc_default_linker: Option<String>,
pub rust_optimize_tests: bool,
- pub rust_debuginfo_tests: bool,
pub rust_dist_src: bool,
pub rust_codegen_backends: Vec<Interned<String>>,
pub rust_codegen_backends_dir: String,
codegen_units: Option<u32>,
codegen_units_std: Option<u32>,
debug_assertions: Option<bool>,
- debuginfo: Option<bool>,
- debuginfo_lines: Option<bool>,
- debuginfo_only_std: Option<bool>,
- debuginfo_tools: Option<bool>,
+ debuginfo_level: Option<u32>,
+ debuginfo_level_rustc: Option<u32>,
+ debuginfo_level_std: Option<u32>,
+ debuginfo_level_tools: Option<u32>,
+ debuginfo_level_tests: Option<u32>,
parallel_compiler: Option<bool>,
backtrace: Option<bool>,
default_linker: Option<String>,
musl_root: Option<String>,
rpath: Option<bool>,
optimize_tests: Option<bool>,
- debuginfo_tests: Option<bool>,
codegen_tests: Option<bool>,
ignore_git: Option<bool>,
debug: Option<bool>,
config.rustc_error_format = flags.rustc_error_format;
config.on_fail = flags.on_fail;
config.stage = flags.stage;
- config.jobs = flags.jobs;
+ config.jobs = flags.jobs.map(threads_from_config);
config.cmd = flags.cmd;
config.incremental = flags.incremental;
config.dry_run = flags.dry_run;
}
// If --target was specified but --host wasn't specified, don't run any host-only tests.
- config.run_host_only = !(flags.host.is_empty() && !flags.target.is_empty());
+ let has_hosts = !flags.host.is_empty();
+ let has_targets = !flags.target.is_empty();
+ config.skip_only_host_steps = !has_hosts && has_targets;
let toml = file.map(|file| {
let contents = t!(fs::read_to_string(&file));
// Store off these values as options because if they're not provided
// we'll infer default values for them later
let mut llvm_assertions = None;
- let mut debuginfo_lines = None;
- let mut debuginfo_only_std = None;
- let mut debuginfo_tools = None;
let mut debug = None;
- let mut debuginfo = None;
let mut debug_assertions = None;
+ let mut debuginfo_level = None;
+ let mut debuginfo_level_rustc = None;
+ let mut debuginfo_level_std = None;
+ let mut debuginfo_level_tools = None;
+ let mut debuginfo_level_tests = None;
let mut optimize = None;
let mut ignore_git = None;
if let Some(ref rust) = toml.rust {
debug = rust.debug;
debug_assertions = rust.debug_assertions;
- debuginfo = rust.debuginfo;
- debuginfo_lines = rust.debuginfo_lines;
- debuginfo_only_std = rust.debuginfo_only_std;
- debuginfo_tools = rust.debuginfo_tools;
+ debuginfo_level = rust.debuginfo_level;
+ debuginfo_level_rustc = rust.debuginfo_level_rustc;
+ debuginfo_level_std = rust.debuginfo_level_std;
+ debuginfo_level_tools = rust.debuginfo_level_tools;
+ debuginfo_level_tests = rust.debuginfo_level_tests;
optimize = rust.optimize;
ignore_git = rust.ignore_git;
set(&mut config.rust_optimize_tests, rust.optimize_tests);
- set(&mut config.rust_debuginfo_tests, rust.debuginfo_tests);
set(&mut config.codegen_tests, rust.codegen_tests);
set(&mut config.rust_rpath, rust.rpath);
set(&mut config.jemalloc, rust.jemalloc);
set(&mut config.rust_codegen_backends_dir, rust.codegen_backends_dir.clone());
- match rust.codegen_units {
- Some(0) => config.rust_codegen_units = Some(num_cpus::get() as u32),
- Some(n) => config.rust_codegen_units = Some(n),
- None => {}
- }
-
- config.rust_codegen_units_std = rust.codegen_units_std;
+ config.rust_codegen_units = rust.codegen_units.map(threads_from_config);
+ config.rust_codegen_units_std = rust.codegen_units_std.map(threads_from_config);
}
if let Some(ref t) = toml.target {
let default = true;
config.rust_optimize = optimize.unwrap_or(default);
- let default = match &config.channel[..] {
- "stable" | "beta" | "nightly" => true,
- _ => false,
- };
- config.rust_debuginfo_lines = debuginfo_lines.unwrap_or(default);
- config.rust_debuginfo_only_std = debuginfo_only_std.unwrap_or(default);
- config.rust_debuginfo_tools = debuginfo_tools.unwrap_or(false);
-
let default = debug == Some(true);
- config.rust_debuginfo = debuginfo.unwrap_or(default);
config.rust_debug_assertions = debug_assertions.unwrap_or(default);
+ let with_defaults = |debuginfo_level_specific: Option<u32>| {
+ debuginfo_level_specific
+ .or(debuginfo_level)
+ .unwrap_or(if debug == Some(true) { 2 } else { 0 })
+ };
+ config.rust_debuginfo_level_rustc = with_defaults(debuginfo_level_rustc);
+ config.rust_debuginfo_level_std = with_defaults(debuginfo_level_std);
+ config.rust_debuginfo_level_tools = with_defaults(debuginfo_level_tools);
+ config.rust_debuginfo_level_tests = debuginfo_level_tests.unwrap_or(0);
+
let default = config.channel == "dev";
config.ignore_git = ignore_git.unwrap_or(default);
*field = v;
}
}
+
+fn threads_from_config(v: u32) -> u32 {
+ match v {
+ 0 => num_cpus::get() as u32,
+ n => n,
+ }
+}