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 7d94bac66f7..8cfd8559016 100644 --- a/src/bootstrap/compile.rs +++ b/src/bootstrap/compile.rs @@ -660,6 +660,16 @@ impl Step for CodegenBackend { 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 8cfd8559016..04e8e133b03 100644 --- a/src/bootstrap/compile.rs +++ b/src/bootstrap/compile.rs @@ -67,16 +67,14 @@ impl Step for Std { 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 @@ impl Step for Test { 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 @@ impl Step for Rustc { 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 @@ impl Step for CodegenBackend { 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 420ae1f349c..0a8a5c87d0d 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 e5dceccdf8b..6a013053e58 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 @@ To learn more about a subcommand, run `./x.py -h`" 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 @@ Arguments: 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))