From a569c249c297a7c3e36ff80aeddf6f42aca5abe6 Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Fri, 13 Jul 2018 18:45:13 -0600 Subject: [PATCH 1/2] Do not attempt to recompile codegen backend(s) with --keep-stage Previously we'd attempt to recompile them and that would fail since we've essentially not built the entire compiler yet, or we're faking that fact. This commit should make us ignore the codegen backend build as well. Unlike the other compile steps, there is no CodegenBackendLink step that we run here, because that is done later as a part of assembling the final compiler and as an explicit function call. --- src/bootstrap/compile.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs index 7d94bac66f77..8cfd85590169 100644 --- a/src/bootstrap/compile.rs +++ b/src/bootstrap/compile.rs @@ -660,6 +660,16 @@ fn run(self, builder: &Builder) { builder.ensure(Rustc { compiler, target }); + if let Some(keep_stage) = builder.config.keep_stage { + if keep_stage <= compiler.stage { + println!("Warning: Using a potentially old codegen backend. \ + This may not behave well."); + // Codegen backends are linked separately from this step today, so we don't do + // anything here. + return; + } + } + if builder.force_use_stage1(compiler, target) { builder.ensure(CodegenBackend { compiler: builder.compiler(1, builder.config.build), From 8eddabaafd91e476956a1c52a1f966f11b4edb85 Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Sat, 14 Jul 2018 10:58:10 -0600 Subject: [PATCH 2/2] Change keep-stage to only affect the passed stage The best way to build a stage 2 rustc is now probably ./x.py build --stage 2 src/rustc # once ./x.py build --stage 2 --keep-stage 1 src/rustc --- src/bootstrap/compile.rs | 76 ++++++++++++++++++---------------------- src/bootstrap/config.rs | 2 +- src/bootstrap/flags.rs | 8 +++-- 3 files changed, 40 insertions(+), 46 deletions(-) diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs index 8cfd85590169..04e8e133b03a 100644 --- a/src/bootstrap/compile.rs +++ b/src/bootstrap/compile.rs @@ -67,16 +67,14 @@ fn run(self, builder: &Builder) { let target = self.target; let compiler = self.compiler; - if let Some(keep_stage) = builder.config.keep_stage { - if keep_stage <= compiler.stage { - println!("Warning: Using a potentially old libstd. This may not behave well."); - builder.ensure(StdLink { - compiler: compiler, - target_compiler: compiler, - target, - }); - return; - } + if builder.config.keep_stage.contains(&compiler.stage) { + builder.info("Warning: Using a potentially old libstd. This may not behave well."); + builder.ensure(StdLink { + compiler: compiler, + target_compiler: compiler, + target, + }); + return; } builder.ensure(StartupObjects { compiler, target }); @@ -362,20 +360,18 @@ fn run(self, builder: &Builder) { let target = self.target; let compiler = self.compiler; - if let Some(keep_stage) = builder.config.keep_stage { - if keep_stage <= compiler.stage { - println!("Warning: Using a potentially old libtest. This may not behave well."); - builder.ensure(TestLink { - compiler: compiler, - target_compiler: compiler, - target, - }); - return; - } - } - builder.ensure(Std { compiler, target }); + if builder.config.keep_stage.contains(&compiler.stage) { + builder.info("Warning: Using a potentially old libtest. This may not behave well."); + builder.ensure(TestLink { + compiler: compiler, + target_compiler: compiler, + target, + }); + return; + } + if builder.force_use_stage1(compiler, target) { builder.ensure(Test { compiler: builder.compiler(1, builder.config.build), @@ -490,20 +486,18 @@ fn run(self, builder: &Builder) { let compiler = self.compiler; let target = self.target; - if let Some(keep_stage) = builder.config.keep_stage { - if keep_stage <= compiler.stage { - println!("Warning: Using a potentially old librustc. This may not behave well."); - builder.ensure(RustcLink { - compiler: compiler, - target_compiler: compiler, - target, - }); - return; - } - } - builder.ensure(Test { compiler, target }); + if builder.config.keep_stage.contains(&compiler.stage) { + builder.info("Warning: Using a potentially old librustc. This may not behave well."); + builder.ensure(RustcLink { + compiler: compiler, + target_compiler: compiler, + target, + }); + return; + } + if builder.force_use_stage1(compiler, target) { builder.ensure(Rustc { compiler: builder.compiler(1, builder.config.build), @@ -660,14 +654,12 @@ fn run(self, builder: &Builder) { builder.ensure(Rustc { compiler, target }); - if let Some(keep_stage) = builder.config.keep_stage { - if keep_stage <= compiler.stage { - println!("Warning: Using a potentially old codegen backend. \ - This may not behave well."); - // Codegen backends are linked separately from this step today, so we don't do - // anything here. - return; - } + if builder.config.keep_stage.contains(&compiler.stage) { + builder.info("Warning: Using a potentially old codegen backend. \ + This may not behave well."); + // Codegen backends are linked separately from this step today, so we don't do + // anything here. + return; } if builder.force_use_stage1(compiler, target) { diff --git a/src/bootstrap/config.rs b/src/bootstrap/config.rs index 420ae1f349c3..0a8a5c87d0da 100644 --- a/src/bootstrap/config.rs +++ b/src/bootstrap/config.rs @@ -63,7 +63,7 @@ pub struct Config { pub on_fail: Option, pub stage: Option, - pub keep_stage: Option, + pub keep_stage: Vec, pub src: PathBuf, pub jobs: Option, pub cmd: Subcommand, diff --git a/src/bootstrap/flags.rs b/src/bootstrap/flags.rs index e5dceccdf8b9..6a013053e580 100644 --- a/src/bootstrap/flags.rs +++ b/src/bootstrap/flags.rs @@ -31,7 +31,7 @@ pub struct Flags { pub verbose: usize, // number of -v args; each extra -v after the first is passed to Cargo pub on_fail: Option, pub stage: Option, - pub keep_stage: Option, + pub keep_stage: Vec, pub host: Vec>, pub target: Vec>, @@ -122,7 +122,7 @@ pub fn parse(args: &[String]) -> Flags { opts.optopt("", "on-fail", "command to run on failure", "CMD"); opts.optflag("", "dry-run", "dry run; don't build anything"); opts.optopt("", "stage", "stage to build", "N"); - opts.optopt("", "keep-stage", "stage to keep without recompiling", "N"); + opts.optmulti("", "keep-stage", "stage(s) to keep without recompiling", "N"); opts.optopt("", "src", "path to the root of the rust checkout", "DIR"); opts.optopt("j", "jobs", "number of jobs to run in parallel", "JOBS"); opts.optflag("h", "help", "print this help message"); @@ -402,7 +402,9 @@ pub fn parse(args: &[String]) -> Flags { dry_run: matches.opt_present("dry-run"), on_fail: matches.opt_str("on-fail"), rustc_error_format: matches.opt_str("error-format"), - keep_stage: matches.opt_str("keep-stage").map(|j| j.parse().unwrap()), + keep_stage: matches.opt_strs("keep-stage") + .into_iter().map(|j| j.parse().unwrap()) + .collect(), host: split(matches.opt_strs("host")) .into_iter() .map(|x| INTERNER.intern_string(x))