src/bootstrap/builder.rs

   1 use std::any::{type_name, Any};
   2 use std::cell::{Cell, RefCell};
   3 use std::collections::BTreeSet;
   4 use std::env;
   5 use std::ffi::{OsStr, OsString};
   6 use std::fmt::{Debug, Write};
   7 use std::fs::{self, File};
   8 use std::hash::Hash;
   9 use std::io::{BufRead, BufReader, ErrorKind};
  10 use std::ops::Deref;
  11 use std::path::{Component, Path, PathBuf};
  12 use std::process::{Command, Stdio};
  13 use std::time::{Duration, Instant};
  14
  15 use crate::cache::{Cache, Interned, INTERNER};
  16 use crate::config::{SplitDebuginfo, TargetSelection};
  17 use crate::dist;
  18 use crate::doc;
  19 use crate::flags::{Color, Subcommand};
  20 use crate::install;
  21 use crate::native;
  22 use crate::run;
  23 use crate::test;
  24 use crate::tool::{self, SourceType};
  25 use crate::util::{self, add_dylib_path, add_link_lib_path, exe, libdir, output, t};
  26 use crate::EXTRA_CHECK_CFGS;
  27 use crate::{check, Config};
  28 use crate::{compile, Crate};
  29 use crate::{Build, CLang, DocTests, GitRepo, Mode};
  30
  31 pub use crate::Compiler;
  32 // FIXME: replace with std::lazy after it gets stabilized and reaches beta
  33 use once_cell::sync::{Lazy, OnceCell};
  34 use xz2::bufread::XzDecoder;
  35
  36 pub struct Builder<'a> {
  37     pub build: &'a Build,
  38     pub top_stage: u32,
  39     pub kind: Kind,
  40     cache: Cache,
  41     stack: RefCell<Vec<Box<dyn Any>>>,
  42     time_spent_on_dependencies: Cell<Duration>,
  43     pub paths: Vec<PathBuf>,
  44 }
  45
  46 impl<'a> Deref for Builder<'a> {
  47     type Target = Build;
  48
  49     fn deref(&self) -> &Self::Target {
  50         self.build
  51     }
  52 }
  53
  54 pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash {
  55     /// `PathBuf` when directories are created or to return a `Compiler` once
  56     /// it's been assembled.
  57     type Output: Clone;
  58
  59     /// Whether this step is run by default as part of its respective phase.
  60     /// `true` here can still be overwritten by `should_run` calling `default_condition`.
  61     const DEFAULT: bool = false;
  62
  63     /// If true, then this rule should be skipped if --target was specified, but --host was not
  64     const ONLY_HOSTS: bool = false;
  65
  66     /// Primary function to execute this rule. Can call `builder.ensure()`
  67     /// with other steps to run those.
  68     fn run(self, builder: &Builder<'_>) -> Self::Output;
  69
  70     /// When bootstrap is passed a set of paths, this controls whether this rule
  71     /// will execute. However, it does not get called in a "default" context
  72     /// when we are not passed any paths; in that case, `make_run` is called
  73     /// directly.
  74     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_>;
  75
  76     /// Builds up a "root" rule, either as a default rule or from a path passed
  77     /// to us.
  78     ///
  79     /// When path is `None`, we are executing in a context where no paths were
  80     /// passed. When `./x.py build` is run, for example, this rule could get
  81     /// called if it is in the correct list below with a path of `None`.
  82     fn make_run(_run: RunConfig<'_>) {
  83         // It is reasonable to not have an implementation of make_run for rules
  84         // who do not want to get called from the root context. This means that
  85         // they are likely dependencies (e.g., sysroot creation) or similar, and
  86         // as such calling them from ./x.py isn't logical.
  87         unimplemented!()
  88     }
  89 }
  90
  91 pub struct RunConfig<'a> {
  92     pub builder: &'a Builder<'a>,
  93     pub target: TargetSelection,
  94     pub paths: Vec<PathSet>,
  95 }
  96
  97 impl RunConfig<'_> {
  98     pub fn build_triple(&self) -> TargetSelection {
  99         self.builder.build.build
 100     }
 101 }
 102
 103 struct StepDescription {
 104     default: bool,
 105     only_hosts: bool,
 106     should_run: fn(ShouldRun<'_>) -> ShouldRun<'_>,
 107     make_run: fn(RunConfig<'_>),
 108     name: &'static str,
 109     kind: Kind,
 110 }
 111
 112 #[derive(Clone, PartialOrd, Ord, PartialEq, Eq)]
 113 pub struct TaskPath {
 114     pub path: PathBuf,
 115     pub kind: Option<Kind>,
 116 }
 117
 118 impl TaskPath {
 119     pub fn parse(path: impl Into<PathBuf>) -> TaskPath {
 120         let mut kind = None;
 121         let mut path = path.into();
 122
 123         let mut components = path.components();
 124         if let Some(Component::Normal(os_str)) = components.next() {
 125             if let Some(str) = os_str.to_str() {
 126                 if let Some((found_kind, found_prefix)) = str.split_once("::") {
 127                     if found_kind.is_empty() {
 128                         panic!("empty kind in task path {}", path.display());
 129                     }
 130                     kind = Kind::parse(found_kind);
 131                     assert!(kind.is_some());
 132                     path = Path::new(found_prefix).join(components.as_path());
 133                 }
 134             }
 135         }
 136
 137         TaskPath { path, kind }
 138     }
 139 }
 140
 141 impl Debug for TaskPath {
 142     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 143         if let Some(kind) = &self.kind {
 144             write!(f, "{}::", kind.as_str())?;
 145         }
 146         write!(f, "{}", self.path.display())
 147     }
 148 }
 149
 150 /// Collection of paths used to match a task rule.
 151 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
 152 pub enum PathSet {
 153     /// A collection of individual paths or aliases.
 154     ///
 155     /// These are generally matched as a path suffix. For example, a
 156     /// command-line value of `std` will match if `library/std` is in the
 157     /// set.
 158     ///
 159     /// NOTE: the paths within a set should always be aliases of one another.
 160     /// For example, `src/librustdoc` and `src/tools/rustdoc` should be in the same set,
 161     /// but `library/core` and `library/std` generally should not, unless there's no way (for that Step)
 162     /// to build them separately.
 163     Set(BTreeSet<TaskPath>),
 164     /// A "suite" of paths.
 165     ///
 166     /// These can match as a path suffix (like `Set`), or as a prefix. For
 167     /// example, a command-line value of `src/test/ui/abi/variadic-ffi.rs`
 168     /// will match `src/test/ui`. A command-line value of `ui` would also
 169     /// match `src/test/ui`.
 170     Suite(TaskPath),
 171 }
 172
 173 impl PathSet {
 174     fn empty() -> PathSet {
 175         PathSet::Set(BTreeSet::new())
 176     }
 177
 178     fn one<P: Into<PathBuf>>(path: P, kind: Kind) -> PathSet {
 179         let mut set = BTreeSet::new();
 180         set.insert(TaskPath { path: path.into(), kind: Some(kind) });
 181         PathSet::Set(set)
 182     }
 183
 184     fn has(&self, needle: &Path, module: Option<Kind>) -> bool {
 185         match self {
 186             PathSet::Set(set) => set.iter().any(|p| Self::check(p, needle, module)),
 187             PathSet::Suite(suite) => Self::check(suite, needle, module),
 188         }
 189     }
 190
 191     // internal use only
 192     fn check(p: &TaskPath, needle: &Path, module: Option<Kind>) -> bool {
 193         if let (Some(p_kind), Some(kind)) = (&p.kind, module) {
 194             p.path.ends_with(needle) && *p_kind == kind
 195         } else {
 196             p.path.ends_with(needle)
 197         }
 198     }
 199
 200     /// Return all `TaskPath`s in `Self` that contain any of the `needles`, removing the
 201     /// matched needles.
 202     ///
 203     /// This is used for `StepDescription::krate`, which passes all matching crates at once to
 204     /// `Step::make_run`, rather than calling it many times with a single crate.
 205     /// See `tests.rs` for examples.
 206     fn intersection_removing_matches(
 207         &self,
 208         needles: &mut Vec<&Path>,
 209         module: Option<Kind>,
 210     ) -> PathSet {
 211         let mut check = |p| {
 212             for (i, n) in needles.iter().enumerate() {
 213                 let matched = Self::check(p, n, module);
 214                 if matched {
 215                     needles.remove(i);
 216                     return true;
 217                 }
 218             }
 219             false
 220         };
 221         match self {
 222             PathSet::Set(set) => PathSet::Set(set.iter().filter(|&p| check(p)).cloned().collect()),
 223             PathSet::Suite(suite) => {
 224                 if check(suite) {
 225                     self.clone()
 226                 } else {
 227                     PathSet::empty()
 228                 }
 229             }
 230         }
 231     }
 232
 233     /// A convenience wrapper for Steps which know they have no aliases and all their sets contain only a single path.
 234     ///
 235     /// This can be used with [`ShouldRun::krate`], [`ShouldRun::path`], or [`ShouldRun::alias`].
 236     #[track_caller]
 237     pub fn assert_single_path(&self) -> &TaskPath {
 238         match self {
 239             PathSet::Set(set) => {
 240                 assert_eq!(set.len(), 1, "called assert_single_path on multiple paths");
 241                 set.iter().next().unwrap()
 242             }
 243             PathSet::Suite(_) => unreachable!("called assert_single_path on a Suite path"),
 244         }
 245     }
 246 }
 247
 248 impl StepDescription {
 249     fn from<S: Step>(kind: Kind) -> StepDescription {
 250         StepDescription {
 251             default: S::DEFAULT,
 252             only_hosts: S::ONLY_HOSTS,
 253             should_run: S::should_run,
 254             make_run: S::make_run,
 255             name: std::any::type_name::<S>(),
 256             kind,
 257         }
 258     }
 259
 260     fn maybe_run(&self, builder: &Builder<'_>, pathsets: Vec<PathSet>) {
 261         if pathsets.iter().any(|set| self.is_excluded(builder, set)) {
 262             return;
 263         }
 264
 265         // Determine the targets participating in this rule.
 266         let targets = if self.only_hosts { &builder.hosts } else { &builder.targets };
 267
 268         for target in targets {
 269             let run = RunConfig { builder, paths: pathsets.clone(), target: *target };
 270             (self.make_run)(run);
 271         }
 272     }
 273
 274     fn is_excluded(&self, builder: &Builder<'_>, pathset: &PathSet) -> bool {
 275         if builder.config.exclude.iter().any(|e| pathset.has(&e.path, e.kind)) {
 276             println!("Skipping {:?} because it is excluded", pathset);
 277             return true;
 278         }
 279
 280         if !builder.config.exclude.is_empty() {
 281             builder.verbose(&format!(
 282                 "{:?} not skipped for {:?} -- not in {:?}",
 283                 pathset, self.name, builder.config.exclude
 284             ));
 285         }
 286         false
 287     }
 288
 289     fn run(v: &[StepDescription], builder: &Builder<'_>, paths: &[PathBuf]) {
 290         let should_runs = v
 291             .iter()
 292             .map(|desc| (desc.should_run)(ShouldRun::new(builder, desc.kind)))
 293             .collect::<Vec<_>>();
 294
 295         // sanity checks on rules
 296         for (desc, should_run) in v.iter().zip(&should_runs) {
 297             assert!(
 298                 !should_run.paths.is_empty(),
 299                 "{:?} should have at least one pathset",
 300                 desc.name
 301             );
 302         }
 303
 304         if paths.is_empty() || builder.config.include_default_paths {
 305             for (desc, should_run) in v.iter().zip(&should_runs) {
 306                 if desc.default && should_run.is_really_default() {
 307                     desc.maybe_run(builder, should_run.paths.iter().cloned().collect());
 308                 }
 309             }
 310         }
 311
 312         // strip CurDir prefix if present
 313         let mut paths: Vec<_> =
 314             paths.into_iter().map(|p| p.strip_prefix(".").unwrap_or(p)).collect();
 315
 316         // Handle all test suite paths.
 317         // (This is separate from the loop below to avoid having to handle multiple paths in `is_suite_path` somehow.)
 318         paths.retain(|path| {
 319             for (desc, should_run) in v.iter().zip(&should_runs) {
 320                 if let Some(suite) = should_run.is_suite_path(&path) {
 321                     desc.maybe_run(builder, vec![suite.clone()]);
 322                     return false;
 323                 }
 324             }
 325             true
 326         });
 327
 328         if paths.is_empty() {
 329             return;
 330         }
 331
 332         // Handle all PathSets.
 333         for (desc, should_run) in v.iter().zip(&should_runs) {
 334             let pathsets = should_run.pathset_for_paths_removing_matches(&mut paths, desc.kind);
 335             if !pathsets.is_empty() {
 336                 desc.maybe_run(builder, pathsets);
 337             }
 338         }
 339
 340         if !paths.is_empty() {
 341             eprintln!("error: no `{}` rules matched {:?}", builder.kind.as_str(), paths,);
 342             eprintln!(
 343                 "help: run `x.py {} --help --verbose` to show a list of available paths",
 344                 builder.kind.as_str()
 345             );
 346             eprintln!(
 347                 "note: if you are adding a new Step to bootstrap itself, make sure you register it with `describe!`"
 348             );
 349             crate::detail_exit(1);
 350         }
 351     }
 352 }
 353
 354 enum ReallyDefault<'a> {
 355     Bool(bool),
 356     Lazy(Lazy<bool, Box<dyn Fn() -> bool + 'a>>),
 357 }
 358
 359 pub struct ShouldRun<'a> {
 360     pub builder: &'a Builder<'a>,
 361     kind: Kind,
 362
 363     // use a BTreeSet to maintain sort order
 364     paths: BTreeSet<PathSet>,
 365
 366     // If this is a default rule, this is an additional constraint placed on
 367     // its run. Generally something like compiler docs being enabled.
 368     is_really_default: ReallyDefault<'a>,
 369 }
 370
 371 impl<'a> ShouldRun<'a> {
 372     fn new(builder: &'a Builder<'_>, kind: Kind) -> ShouldRun<'a> {
 373         ShouldRun {
 374             builder,
 375             kind,
 376             paths: BTreeSet::new(),
 377             is_really_default: ReallyDefault::Bool(true), // by default no additional conditions
 378         }
 379     }
 380
 381     pub fn default_condition(mut self, cond: bool) -> Self {
 382         self.is_really_default = ReallyDefault::Bool(cond);
 383         self
 384     }
 385
 386     pub fn lazy_default_condition(mut self, lazy_cond: Box<dyn Fn() -> bool + 'a>) -> Self {
 387         self.is_really_default = ReallyDefault::Lazy(Lazy::new(lazy_cond));
 388         self
 389     }
 390
 391     pub fn is_really_default(&self) -> bool {
 392         match &self.is_really_default {
 393             ReallyDefault::Bool(val) => *val,
 394             ReallyDefault::Lazy(lazy) => *lazy.deref(),
 395         }
 396     }
 397
 398     /// Indicates it should run if the command-line selects the given crate or
 399     /// any of its (local) dependencies.
 400     ///
 401     /// Compared to `krate`, this treats the dependencies as aliases for the
 402     /// same job. Generally it is preferred to use `krate`, and treat each
 403     /// individual path separately. For example `./x.py test src/liballoc`
 404     /// (which uses `krate`) will test just `liballoc`. However, `./x.py check
 405     /// src/liballoc` (which uses `all_krates`) will check all of `libtest`.
 406     /// `all_krates` should probably be removed at some point.
 407     pub fn all_krates(mut self, name: &str) -> Self {
 408         let mut set = BTreeSet::new();
 409         for krate in self.builder.in_tree_crates(name, None) {
 410             let path = krate.local_path(self.builder);
 411             set.insert(TaskPath { path, kind: Some(self.kind) });
 412         }
 413         self.paths.insert(PathSet::Set(set));
 414         self
 415     }
 416
 417     /// Indicates it should run if the command-line selects the given crate or
 418     /// any of its (local) dependencies.
 419     ///
 420     /// `make_run` will be called a single time with all matching command-line paths.
 421     pub fn crate_or_deps(self, name: &str) -> Self {
 422         let crates = self.builder.in_tree_crates(name, None);
 423         self.crates(crates)
 424     }
 425
 426     /// Indicates it should run if the command-line selects any of the given crates.
 427     ///
 428     /// `make_run` will be called a single time with all matching command-line paths.
 429     pub(crate) fn crates(mut self, crates: Vec<&Crate>) -> Self {
 430         for krate in crates {
 431             let path = krate.local_path(self.builder);
 432             self.paths.insert(PathSet::one(path, self.kind));
 433         }
 434         self
 435     }
 436
 437     // single alias, which does not correspond to any on-disk path
 438     pub fn alias(mut self, alias: &str) -> Self {
 439         assert!(
 440             !self.builder.src.join(alias).exists(),
 441             "use `builder.path()` for real paths: {}",
 442             alias
 443         );
 444         self.paths.insert(PathSet::Set(
 445             std::iter::once(TaskPath { path: alias.into(), kind: Some(self.kind) }).collect(),
 446         ));
 447         self
 448     }
 449
 450     // single, non-aliased path
 451     pub fn path(self, path: &str) -> Self {
 452         self.paths(&[path])
 453     }
 454
 455     // multiple aliases for the same job
 456     pub fn paths(mut self, paths: &[&str]) -> Self {
 457         self.paths.insert(PathSet::Set(
 458             paths
 459                 .iter()
 460                 .map(|p| {
 461                     // FIXME(#96188): make sure this is actually a path.
 462                     // This currently breaks for paths within submodules.
 463                     //assert!(
 464                     //    self.builder.src.join(p).exists(),
 465                     //    "`should_run.paths` should correspond to real on-disk paths - use `alias` if there is no relevant path: {}",
 466                     //    p
 467                     //);
 468                     TaskPath { path: p.into(), kind: Some(self.kind) }
 469                 })
 470                 .collect(),
 471         ));
 472         self
 473     }
 474
 475     /// Handles individual files (not directories) within a test suite.
 476     fn is_suite_path(&self, requested_path: &Path) -> Option<&PathSet> {
 477         self.paths.iter().find(|pathset| match pathset {
 478             PathSet::Suite(suite) => requested_path.starts_with(&suite.path),
 479             PathSet::Set(_) => false,
 480         })
 481     }
 482
 483     pub fn suite_path(mut self, suite: &str) -> Self {
 484         self.paths.insert(PathSet::Suite(TaskPath { path: suite.into(), kind: Some(self.kind) }));
 485         self
 486     }
 487
 488     // allows being more explicit about why should_run in Step returns the value passed to it
 489     pub fn never(mut self) -> ShouldRun<'a> {
 490         self.paths.insert(PathSet::empty());
 491         self
 492     }
 493
 494     /// Given a set of requested paths, return the subset which match the Step for this `ShouldRun`,
 495     /// removing the matches from `paths`.
 496     ///
 497     /// NOTE: this returns multiple PathSets to allow for the possibility of multiple units of work
 498     /// within the same step. For example, `test::Crate` allows testing multiple crates in the same
 499     /// cargo invocation, which are put into separate sets because they aren't aliases.
 500     ///
 501     /// The reason we return PathSet instead of PathBuf is to allow for aliases that mean the same thing
 502     /// (for now, just `all_krates` and `paths`, but we may want to add an `aliases` function in the future?)
 503     fn pathset_for_paths_removing_matches(
 504         &self,
 505         paths: &mut Vec<&Path>,
 506         kind: Kind,
 507     ) -> Vec<PathSet> {
 508         let mut sets = vec![];
 509         for pathset in &self.paths {
 510             let subset = pathset.intersection_removing_matches(paths, Some(kind));
 511             if subset != PathSet::empty() {
 512                 sets.push(subset);
 513             }
 514         }
 515         sets
 516     }
 517 }
 518
 519 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
 520 pub enum Kind {
 521     Build,
 522     Check,
 523     Clippy,
 524     Fix,
 525     Format,
 526     Test,
 527     Bench,
 528     Doc,
 529     Clean,
 530     Dist,
 531     Install,
 532     Run,
 533     Setup,
 534 }
 535
 536 impl Kind {
 537     pub fn parse(string: &str) -> Option<Kind> {
 538         // these strings, including the one-letter aliases, must match the x.py help text
 539         Some(match string {
 540             "build" | "b" => Kind::Build,
 541             "check" | "c" => Kind::Check,
 542             "clippy" => Kind::Clippy,
 543             "fix" => Kind::Fix,
 544             "fmt" => Kind::Format,
 545             "test" | "t" => Kind::Test,
 546             "bench" => Kind::Bench,
 547             "doc" | "d" => Kind::Doc,
 548             "clean" => Kind::Clean,
 549             "dist" => Kind::Dist,
 550             "install" => Kind::Install,
 551             "run" | "r" => Kind::Run,
 552             "setup" => Kind::Setup,
 553             _ => return None,
 554         })
 555     }
 556
 557     pub fn as_str(&self) -> &'static str {
 558         match self {
 559             Kind::Build => "build",
 560             Kind::Check => "check",
 561             Kind::Clippy => "clippy",
 562             Kind::Fix => "fix",
 563             Kind::Format => "fmt",
 564             Kind::Test => "test",
 565             Kind::Bench => "bench",
 566             Kind::Doc => "doc",
 567             Kind::Clean => "clean",
 568             Kind::Dist => "dist",
 569             Kind::Install => "install",
 570             Kind::Run => "run",
 571             Kind::Setup => "setup",
 572         }
 573     }
 574 }
 575
 576 impl<'a> Builder<'a> {
 577     fn get_step_descriptions(kind: Kind) -> Vec<StepDescription> {
 578         macro_rules! describe {
 579             ($($rule:ty),+ $(,)?) => {{
 580                 vec![$(StepDescription::from::<$rule>(kind)),+]
 581             }};
 582         }
 583         match kind {
 584             Kind::Build => describe!(
 585                 compile::Std,
 586                 compile::Rustc,
 587                 compile::Assemble,
 588                 compile::CodegenBackend,
 589                 compile::StartupObjects,
 590                 tool::BuildManifest,
 591                 tool::Rustbook,
 592                 tool::ErrorIndex,
 593                 tool::UnstableBookGen,
 594                 tool::Tidy,
 595                 tool::Linkchecker,
 596                 tool::CargoTest,
 597                 tool::Compiletest,
 598                 tool::RemoteTestServer,
 599                 tool::RemoteTestClient,
 600                 tool::RustInstaller,
 601                 tool::Cargo,
 602                 tool::Rls,
 603                 tool::RustAnalyzer,
 604                 tool::RustAnalyzerProcMacroSrv,
 605                 tool::RustDemangler,
 606                 tool::Rustdoc,
 607                 tool::Clippy,
 608                 tool::CargoClippy,
 609                 native::Llvm,
 610                 native::Sanitizers,
 611                 tool::Rustfmt,
 612                 tool::Miri,
 613                 tool::CargoMiri,
 614                 native::Lld,
 615                 native::CrtBeginEnd
 616             ),
 617             Kind::Check | Kind::Clippy | Kind::Fix => describe!(
 618                 check::Std,
 619                 check::Rustc,
 620                 check::Rustdoc,
 621                 check::CodegenBackend,
 622                 check::Clippy,
 623                 check::Miri,
 624                 check::CargoMiri,
 625                 check::MiroptTestTools,
 626                 check::Rls,
 627                 check::RustAnalyzer,
 628                 check::Rustfmt,
 629                 check::Bootstrap
 630             ),
 631             Kind::Test => describe!(
 632                 crate::toolstate::ToolStateCheck,
 633                 test::ExpandYamlAnchors,
 634                 test::Tidy,
 635                 test::Ui,
 636                 test::RunPassValgrind,
 637                 test::MirOpt,
 638                 test::Codegen,
 639                 test::CodegenUnits,
 640                 test::Assembly,
 641                 test::Incremental,
 642                 test::Debuginfo,
 643                 test::UiFullDeps,
 644                 test::Rustdoc,
 645                 test::Pretty,
 646                 test::Crate,
 647                 test::CrateLibrustc,
 648                 test::CrateRustdoc,
 649                 test::CrateRustdocJsonTypes,
 650                 test::Linkcheck,
 651                 test::TierCheck,
 652                 test::ReplacePlaceholderTest,
 653                 test::Cargotest,
 654                 test::Cargo,
 655                 test::RustAnalyzer,
 656                 test::ErrorIndex,
 657                 test::Distcheck,
 658                 test::RunMakeFullDeps,
 659                 test::Nomicon,
 660                 test::Reference,
 661                 test::RustdocBook,
 662                 test::RustByExample,
 663                 test::TheBook,
 664                 test::UnstableBook,
 665                 test::RustcBook,
 666                 test::LintDocs,
 667                 test::RustcGuide,
 668                 test::EmbeddedBook,
 669                 test::EditionGuide,
 670                 test::Rustfmt,
 671                 test::Miri,
 672                 test::Clippy,
 673                 test::RustDemangler,
 674                 test::CompiletestTest,
 675                 test::RustdocJSStd,
 676                 test::RustdocJSNotStd,
 677                 test::RustdocGUI,
 678                 test::RustdocTheme,
 679                 test::RustdocUi,
 680                 test::RustdocJson,
 681                 test::HtmlCheck,
 682                 // Run bootstrap close to the end as it's unlikely to fail
 683                 test::Bootstrap,
 684                 // Run run-make last, since these won't pass without make on Windows
 685                 test::RunMake,
 686             ),
 687             Kind::Bench => describe!(test::Crate, test::CrateLibrustc),
 688             Kind::Doc => describe!(
 689                 doc::UnstableBook,
 690                 doc::UnstableBookGen,
 691                 doc::TheBook,
 692                 doc::Standalone,
 693                 doc::Std,
 694                 doc::Rustc,
 695                 doc::Rustdoc,
 696                 doc::Rustfmt,
 697                 doc::ErrorIndex,
 698                 doc::Nomicon,
 699                 doc::Reference,
 700                 doc::RustdocBook,
 701                 doc::RustByExample,
 702                 doc::RustcBook,
 703                 doc::CargoBook,
 704                 doc::Clippy,
 705                 doc::ClippyBook,
 706                 doc::Miri,
 707                 doc::EmbeddedBook,
 708                 doc::EditionGuide,
 709                 doc::StyleGuide,
 710             ),
 711             Kind::Dist => describe!(
 712                 dist::Docs,
 713                 dist::RustcDocs,
 714                 dist::JsonDocs,
 715                 dist::Mingw,
 716                 dist::Rustc,
 717                 dist::Std,
 718                 dist::RustcDev,
 719                 dist::Analysis,
 720                 dist::Src,
 721                 dist::Cargo,
 722                 dist::Rls,
 723                 dist::RustAnalyzer,
 724                 dist::Rustfmt,
 725                 dist::RustDemangler,
 726                 dist::Clippy,
 727                 dist::Miri,
 728                 dist::LlvmTools,
 729                 dist::RustDev,
 730                 dist::Bootstrap,
 731                 dist::Extended,
 732                 // It seems that PlainSourceTarball somehow changes how some of the tools
 733                 // perceive their dependencies (see #93033) which would invalidate fingerprints
 734                 // and force us to rebuild tools after vendoring dependencies.
 735                 // To work around this, create the Tarball after building all the tools.
 736                 dist::PlainSourceTarball,
 737                 dist::BuildManifest,
 738                 dist::ReproducibleArtifacts,
 739             ),
 740             Kind::Install => describe!(
 741                 install::Docs,
 742                 install::Std,
 743                 install::Cargo,
 744                 install::RustAnalyzer,
 745                 install::Rustfmt,
 746                 install::RustDemangler,
 747                 install::Clippy,
 748                 install::Miri,
 749                 install::Analysis,
 750                 install::Src,
 751                 install::Rustc
 752             ),
 753             Kind::Run => describe!(
 754                 run::ExpandYamlAnchors,
 755                 run::BuildManifest,
 756                 run::BumpStage0,
 757                 run::ReplaceVersionPlaceholder,
 758             ),
 759             // These commands either don't use paths, or they're special-cased in Build::build()
 760             Kind::Clean | Kind::Format | Kind::Setup => vec![],
 761         }
 762     }
 763
 764     pub fn get_help(build: &Build, kind: Kind) -> Option<String> {
 765         let step_descriptions = Builder::get_step_descriptions(kind);
 766         if step_descriptions.is_empty() {
 767             return None;
 768         }
 769
 770         let builder = Self::new_internal(build, kind, vec![]);
 771         let builder = &builder;
 772         // The "build" kind here is just a placeholder, it will be replaced with something else in
 773         // the following statement.
 774         let mut should_run = ShouldRun::new(builder, Kind::Build);
 775         for desc in step_descriptions {
 776             should_run.kind = desc.kind;
 777             should_run = (desc.should_run)(should_run);
 778         }
 779         let mut help = String::from("Available paths:\n");
 780         let mut add_path = |path: &Path| {
 781             t!(write!(help, "    ./x.py {} {}\n", kind.as_str(), path.display()));
 782         };
 783         for pathset in should_run.paths {
 784             match pathset {
 785                 PathSet::Set(set) => {
 786                     for path in set {
 787                         add_path(&path.path);
 788                     }
 789                 }
 790                 PathSet::Suite(path) => {
 791                     add_path(&path.path.join("..."));
 792                 }
 793             }
 794         }
 795         Some(help)
 796     }
 797
 798     fn new_internal(build: &Build, kind: Kind, paths: Vec<PathBuf>) -> Builder<'_> {
 799         Builder {
 800             build,
 801             top_stage: build.config.stage,
 802             kind,
 803             cache: Cache::new(),
 804             stack: RefCell::new(Vec::new()),
 805             time_spent_on_dependencies: Cell::new(Duration::new(0, 0)),
 806             paths,
 807         }
 808     }
 809
 810     pub fn new(build: &Build) -> Builder<'_> {
 811         let (kind, paths) = match build.config.cmd {
 812             Subcommand::Build { ref paths } => (Kind::Build, &paths[..]),
 813             Subcommand::Check { ref paths } => (Kind::Check, &paths[..]),
 814             Subcommand::Clippy { ref paths, .. } => (Kind::Clippy, &paths[..]),
 815             Subcommand::Fix { ref paths } => (Kind::Fix, &paths[..]),
 816             Subcommand::Doc { ref paths, .. } => (Kind::Doc, &paths[..]),
 817             Subcommand::Test { ref paths, .. } => (Kind::Test, &paths[..]),
 818             Subcommand::Bench { ref paths, .. } => (Kind::Bench, &paths[..]),
 819             Subcommand::Dist { ref paths } => (Kind::Dist, &paths[..]),
 820             Subcommand::Install { ref paths } => (Kind::Install, &paths[..]),
 821             Subcommand::Run { ref paths } => (Kind::Run, &paths[..]),
 822             Subcommand::Format { .. } => (Kind::Format, &[][..]),
 823             Subcommand::Clean { .. } | Subcommand::Setup { .. } => {
 824                 panic!()
 825             }
 826         };
 827
 828         Self::new_internal(build, kind, paths.to_owned())
 829     }
 830
 831     pub fn execute_cli(&self) {
 832         self.run_step_descriptions(&Builder::get_step_descriptions(self.kind), &self.paths);
 833     }
 834
 835     pub fn default_doc(&self, paths: &[PathBuf]) {
 836         self.run_step_descriptions(&Builder::get_step_descriptions(Kind::Doc), paths);
 837     }
 838
 839     /// NOTE: keep this in sync with `rustdoc::clean::utils::doc_rust_lang_org_channel`, or tests will fail on beta/stable.
 840     pub fn doc_rust_lang_org_channel(&self) -> String {
 841         let channel = match &*self.config.channel {
 842             "stable" => &self.version,
 843             "beta" => "beta",
 844             "nightly" | "dev" => "nightly",
 845             // custom build of rustdoc maybe? link to the latest stable docs just in case
 846             _ => "stable",
 847         };
 848         "https://doc.rust-lang.org/".to_owned() + channel
 849     }
 850
 851     fn run_step_descriptions(&self, v: &[StepDescription], paths: &[PathBuf]) {
 852         StepDescription::run(v, self, paths);
 853     }
 854
 855     /// Modifies the interpreter section of 'fname' to fix the dynamic linker,
 856     /// or the RPATH section, to fix the dynamic library search path
 857     ///
 858     /// This is only required on NixOS and uses the PatchELF utility to
 859     /// change the interpreter/RPATH of ELF executables.
 860     ///
 861     /// Please see https://nixos.org/patchelf.html for more information
 862     pub(crate) fn fix_bin_or_dylib(&self, fname: &Path) {
 863         // FIXME: cache NixOS detection?
 864         match Command::new("uname").arg("-s").stderr(Stdio::inherit()).output() {
 865             Err(_) => return,
 866             Ok(output) if !output.status.success() => return,
 867             Ok(output) => {
 868                 let mut s = output.stdout;
 869                 if s.last() == Some(&b'\n') {
 870                     s.pop();
 871                 }
 872                 if s != b"Linux" {
 873                     return;
 874                 }
 875             }
 876         }
 877
 878         // If the user has asked binaries to be patched for Nix, then
 879         // don't check for NixOS or `/lib`, just continue to the patching.
 880         // NOTE: this intentionally comes after the Linux check:
 881         // - patchelf only works with ELF files, so no need to run it on Mac or Windows
 882         // - On other Unix systems, there is no stable syscall interface, so Nix doesn't manage the global libc.
 883         if !self.config.patch_binaries_for_nix {
 884             // Use `/etc/os-release` instead of `/etc/NIXOS`.
 885             // The latter one does not exist on NixOS when using tmpfs as root.
 886             const NIX_IDS: &[&str] = &["ID=nixos", "ID='nixos'", "ID=\"nixos\""];
 887             let os_release = match File::open("/etc/os-release") {
 888                 Err(e) if e.kind() == ErrorKind::NotFound => return,
 889                 Err(e) => panic!("failed to access /etc/os-release: {}", e),
 890                 Ok(f) => f,
 891             };
 892             if !BufReader::new(os_release).lines().any(|l| NIX_IDS.contains(&t!(l).trim())) {
 893                 return;
 894             }
 895             if Path::new("/lib").exists() {
 896                 return;
 897             }
 898         }
 899
 900         // At this point we're pretty sure the user is running NixOS or using Nix
 901         println!("info: you seem to be using Nix. Attempting to patch {}", fname.display());
 902
 903         // Only build `.nix-deps` once.
 904         static NIX_DEPS_DIR: OnceCell<PathBuf> = OnceCell::new();
 905         let mut nix_build_succeeded = true;
 906         let nix_deps_dir = NIX_DEPS_DIR.get_or_init(|| {
 907             // Run `nix-build` to "build" each dependency (which will likely reuse
 908             // the existing `/nix/store` copy, or at most download a pre-built copy).
 909             //
 910             // Importantly, we create a gc-root called `.nix-deps` in the `build/`
 911             // directory, but still reference the actual `/nix/store` path in the rpath
 912             // as it makes it significantly more robust against changes to the location of
 913             // the `.nix-deps` location.
 914             //
 915             // bintools: Needed for the path of `ld-linux.so` (via `nix-support/dynamic-linker`).
 916             // zlib: Needed as a system dependency of `libLLVM-*.so`.
 917             // patchelf: Needed for patching ELF binaries (see doc comment above).
 918             let nix_deps_dir = self.out.join(".nix-deps");
 919             const NIX_EXPR: &str = "
 920             with (import <nixpkgs> {});
 921             symlinkJoin {
 922                 name = \"rust-stage0-dependencies\";
 923                 paths = [
 924                     zlib
 925                     patchelf
 926                     stdenv.cc.bintools
 927                 ];
 928             }
 929             ";
 930             nix_build_succeeded = self.try_run(Command::new("nix-build").args(&[
 931                 Path::new("-E"),
 932                 Path::new(NIX_EXPR),
 933                 Path::new("-o"),
 934                 &nix_deps_dir,
 935             ]));
 936             nix_deps_dir
 937         });
 938         if !nix_build_succeeded {
 939             return;
 940         }
 941
 942         let mut patchelf = Command::new(nix_deps_dir.join("bin/patchelf"));
 943         let rpath_entries = {
 944             // ORIGIN is a relative default, all binary and dynamic libraries we ship
 945             // appear to have this (even when `../lib` is redundant).
 946             // NOTE: there are only two paths here, delimited by a `:`
 947             let mut entries = OsString::from("$ORIGIN/../lib:");
 948             entries.push(t!(fs::canonicalize(nix_deps_dir)));
 949             entries.push("/lib");
 950             entries
 951         };
 952         patchelf.args(&[OsString::from("--set-rpath"), rpath_entries]);
 953         if !fname.extension().map_or(false, |ext| ext == "so") {
 954             // Finally, set the correct .interp for binaries
 955             let dynamic_linker_path = nix_deps_dir.join("nix-support/dynamic-linker");
 956             // FIXME: can we support utf8 here? `args` doesn't accept Vec<u8>, only OsString ...
 957             let dynamic_linker = t!(String::from_utf8(t!(fs::read(dynamic_linker_path))));
 958             patchelf.args(&["--set-interpreter", dynamic_linker.trim_end()]);
 959         }
 960
 961         self.try_run(patchelf.arg(fname));
 962     }
 963
 964     pub(crate) fn download_component(&self, url: &str, dest_path: &Path, help_on_error: &str) {
 965         self.verbose(&format!("download {url}"));
 966         // Use a temporary file in case we crash while downloading, to avoid a corrupt download in cache/.
 967         let tempfile = self.tempdir().join(dest_path.file_name().unwrap());
 968         // While bootstrap itself only supports http and https downloads, downstream forks might
 969         // need to download components from other protocols. The match allows them adding more
 970         // protocols without worrying about merge conflicts if we change the HTTP implementation.
 971         match url.split_once("://").map(|(proto, _)| proto) {
 972             Some("http") | Some("https") => {
 973                 self.download_http_with_retries(&tempfile, url, help_on_error)
 974             }
 975             Some(other) => panic!("unsupported protocol {other} in {url}"),
 976             None => panic!("no protocol in {url}"),
 977         }
 978         t!(std::fs::rename(&tempfile, dest_path));
 979     }
 980
 981     fn download_http_with_retries(&self, tempfile: &Path, url: &str, help_on_error: &str) {
 982         println!("downloading {}", url);
 983         // Try curl. If that fails and we are on windows, fallback to PowerShell.
 984         let mut curl = Command::new("curl");
 985         curl.args(&[
 986             "-#",
 987             "-y",
 988             "30",
 989             "-Y",
 990             "10", // timeout if speed is < 10 bytes/sec for > 30 seconds
 991             "--connect-timeout",
 992             "30", // timeout if cannot connect within 30 seconds
 993             "--retry",
 994             "3",
 995             "-Sf",
 996             "-o",
 997         ]);
 998         curl.arg(tempfile);
 999         curl.arg(url);
1000         if !self.check_run(&mut curl) {
1001             if self.build.build.contains("windows-msvc") {
1002                 println!("Fallback to PowerShell");
1003                 for _ in 0..3 {
1004                     if self.try_run(Command::new("PowerShell.exe").args(&[
1005                         "/nologo",
1006                         "-Command",
1007                         "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12;",
1008                         &format!(
1009                             "(New-Object System.Net.WebClient).DownloadFile('{}', '{}')",
1010                             url, tempfile.to_str().expect("invalid UTF-8 not supported with powershell downloads"),
1011                         ),
1012                     ])) {
1013                         return;
1014                     }
1015                     println!("\nspurious failure, trying again");
1016                 }
1017             }
1018             if !help_on_error.is_empty() {
1019                 eprintln!("{}", help_on_error);
1020             }
1021             crate::detail_exit(1);
1022         }
1023     }
1024
1025     pub(crate) fn unpack(&self, tarball: &Path, dst: &Path, pattern: &str) {
1026         println!("extracting {} to {}", tarball.display(), dst.display());
1027         if !dst.exists() {
1028             t!(fs::create_dir_all(dst));
1029         }
1030
1031         // `tarball` ends with `.tar.xz`; strip that suffix
1032         // example: `rust-dev-nightly-x86_64-unknown-linux-gnu`
1033         let uncompressed_filename =
1034             Path::new(tarball.file_name().expect("missing tarball filename")).file_stem().unwrap();
1035         let directory_prefix = Path::new(Path::new(uncompressed_filename).file_stem().unwrap());
1036
1037         // decompress the file
1038         let data = t!(File::open(tarball));
1039         let decompressor = XzDecoder::new(BufReader::new(data));
1040
1041         let mut tar = tar::Archive::new(decompressor);
1042         for member in t!(tar.entries()) {
1043             let mut member = t!(member);
1044             let original_path = t!(member.path()).into_owned();
1045             // skip the top-level directory
1046             if original_path == directory_prefix {
1047                 continue;
1048             }
1049             let mut short_path = t!(original_path.strip_prefix(directory_prefix));
1050             if !short_path.starts_with(pattern) {
1051                 continue;
1052             }
1053             short_path = t!(short_path.strip_prefix(pattern));
1054             let dst_path = dst.join(short_path);
1055             self.verbose(&format!("extracting {} to {}", original_path.display(), dst.display()));
1056             if !t!(member.unpack_in(dst)) {
1057                 panic!("path traversal attack ??");
1058             }
1059             let src_path = dst.join(original_path);
1060             if src_path.is_dir() && dst_path.exists() {
1061                 continue;
1062             }
1063             t!(fs::rename(src_path, dst_path));
1064         }
1065         t!(fs::remove_dir_all(dst.join(directory_prefix)));
1066     }
1067
1068     /// Returns whether the SHA256 checksum of `path` matches `expected`.
1069     pub(crate) fn verify(&self, path: &Path, expected: &str) -> bool {
1070         use sha2::Digest;
1071
1072         self.verbose(&format!("verifying {}", path.display()));
1073         let mut hasher = sha2::Sha256::new();
1074         // FIXME: this is ok for rustfmt (4.1 MB large at time of writing), but it seems memory-intensive for rustc and larger components.
1075         // Consider using streaming IO instead?
1076         let contents = if self.config.dry_run { vec![] } else { t!(fs::read(path)) };
1077         hasher.update(&contents);
1078         let found = hex::encode(hasher.finalize().as_slice());
1079         let verified = found == expected;
1080         if !verified && !self.config.dry_run {
1081             println!(
1082                 "invalid checksum: \n\
1083                 found:    {found}\n\
1084                 expected: {expected}",
1085             );
1086         }
1087         return verified;
1088     }
1089
1090     /// Obtain a compiler at a given stage and for a given host. Explicitly does
1091     /// not take `Compiler` since all `Compiler` instances are meant to be
1092     /// obtained through this function, since it ensures that they are valid
1093     /// (i.e., built and assembled).
1094     pub fn compiler(&self, stage: u32, host: TargetSelection) -> Compiler {
1095         self.ensure(compile::Assemble { target_compiler: Compiler { stage, host } })
1096     }
1097
1098     /// Similar to `compiler`, except handles the full-bootstrap option to
1099     /// silently use the stage1 compiler instead of a stage2 compiler if one is
1100     /// requested.
1101     ///
1102     /// Note that this does *not* have the side effect of creating
1103     /// `compiler(stage, host)`, unlike `compiler` above which does have such
1104     /// a side effect. The returned compiler here can only be used to compile
1105     /// new artifacts, it can't be used to rely on the presence of a particular
1106     /// sysroot.
1107     ///
1108     /// See `force_use_stage1` for documentation on what each argument is.
1109     pub fn compiler_for(
1110         &self,
1111         stage: u32,
1112         host: TargetSelection,
1113         target: TargetSelection,
1114     ) -> Compiler {
1115         if self.build.force_use_stage1(Compiler { stage, host }, target) {
1116             self.compiler(1, self.config.build)
1117         } else {
1118             self.compiler(stage, host)
1119         }
1120     }
1121
1122     pub fn sysroot(&self, compiler: Compiler) -> Interned<PathBuf> {
1123         self.ensure(compile::Sysroot { compiler })
1124     }
1125
1126     /// Returns the libdir where the standard library and other artifacts are
1127     /// found for a compiler's sysroot.
1128     pub fn sysroot_libdir(&self, compiler: Compiler, target: TargetSelection) -> Interned<PathBuf> {
1129         #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1130         struct Libdir {
1131             compiler: Compiler,
1132             target: TargetSelection,
1133         }
1134         impl Step for Libdir {
1135             type Output = Interned<PathBuf>;
1136
1137             fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
1138                 run.never()
1139             }
1140
1141             fn run(self, builder: &Builder<'_>) -> Interned<PathBuf> {
1142                 let lib = builder.sysroot_libdir_relative(self.compiler);
1143                 let sysroot = builder
1144                     .sysroot(self.compiler)
1145                     .join(lib)
1146                     .join("rustlib")
1147                     .join(self.target.triple)
1148                     .join("lib");
1149                 // Avoid deleting the rustlib/ directory we just copied
1150                 // (in `impl Step for Sysroot`).
1151                 if !builder.download_rustc() {
1152                     let _ = fs::remove_dir_all(&sysroot);
1153                     t!(fs::create_dir_all(&sysroot));
1154                 }
1155                 INTERNER.intern_path(sysroot)
1156             }
1157         }
1158         self.ensure(Libdir { compiler, target })
1159     }
1160
1161     pub fn sysroot_codegen_backends(&self, compiler: Compiler) -> PathBuf {
1162         self.sysroot_libdir(compiler, compiler.host).with_file_name("codegen-backends")
1163     }
1164
1165     /// Returns the compiler's libdir where it stores the dynamic libraries that
1166     /// it itself links against.
1167     ///
1168     /// For example this returns `<sysroot>/lib` on Unix and `<sysroot>/bin` on
1169     /// Windows.
1170     pub fn rustc_libdir(&self, compiler: Compiler) -> PathBuf {
1171         if compiler.is_snapshot(self) {
1172             self.rustc_snapshot_libdir()
1173         } else {
1174             match self.config.libdir_relative() {
1175                 Some(relative_libdir) if compiler.stage >= 1 => {
1176                     self.sysroot(compiler).join(relative_libdir)
1177                 }
1178                 _ => self.sysroot(compiler).join(libdir(compiler.host)),
1179             }
1180         }
1181     }
1182
1183     /// Returns the compiler's relative libdir where it stores the dynamic libraries that
1184     /// it itself links against.
1185     ///
1186     /// For example this returns `lib` on Unix and `bin` on
1187     /// Windows.
1188     pub fn libdir_relative(&self, compiler: Compiler) -> &Path {
1189         if compiler.is_snapshot(self) {
1190             libdir(self.config.build).as_ref()
1191         } else {
1192             match self.config.libdir_relative() {
1193                 Some(relative_libdir) if compiler.stage >= 1 => relative_libdir,
1194                 _ => libdir(compiler.host).as_ref(),
1195             }
1196         }
1197     }
1198
1199     /// Returns the compiler's relative libdir where the standard library and other artifacts are
1200     /// found for a compiler's sysroot.
1201     ///
1202     /// For example this returns `lib` on Unix and Windows.
1203     pub fn sysroot_libdir_relative(&self, compiler: Compiler) -> &Path {
1204         match self.config.libdir_relative() {
1205             Some(relative_libdir) if compiler.stage >= 1 => relative_libdir,
1206             _ if compiler.stage == 0 => &self.build.initial_libdir,
1207             _ => Path::new("lib"),
1208         }
1209     }
1210
1211     pub fn rustc_lib_paths(&self, compiler: Compiler) -> Vec<PathBuf> {
1212         let mut dylib_dirs = vec![self.rustc_libdir(compiler)];
1213
1214         // Ensure that the downloaded LLVM libraries can be found.
1215         if self.config.llvm_from_ci {
1216             let ci_llvm_lib = self.out.join(&*compiler.host.triple).join("ci-llvm").join("lib");
1217             dylib_dirs.push(ci_llvm_lib);
1218         }
1219
1220         dylib_dirs
1221     }
1222
1223     /// Adds the compiler's directory of dynamic libraries to `cmd`'s dynamic
1224     /// library lookup path.
1225     pub fn add_rustc_lib_path(&self, compiler: Compiler, cmd: &mut Command) {
1226         // Windows doesn't need dylib path munging because the dlls for the
1227         // compiler live next to the compiler and the system will find them
1228         // automatically.
1229         if cfg!(windows) {
1230             return;
1231         }
1232
1233         add_dylib_path(self.rustc_lib_paths(compiler), cmd);
1234     }
1235
1236     /// Gets a path to the compiler specified.
1237     pub fn rustc(&self, compiler: Compiler) -> PathBuf {
1238         if compiler.is_snapshot(self) {
1239             self.initial_rustc.clone()
1240         } else {
1241             self.sysroot(compiler).join("bin").join(exe("rustc", compiler.host))
1242         }
1243     }
1244
1245     /// Gets the paths to all of the compiler's codegen backends.
1246     fn codegen_backends(&self, compiler: Compiler) -> impl Iterator<Item = PathBuf> {
1247         fs::read_dir(self.sysroot_codegen_backends(compiler))
1248             .into_iter()
1249             .flatten()
1250             .filter_map(Result::ok)
1251             .map(|entry| entry.path())
1252     }
1253
1254     pub fn rustdoc(&self, compiler: Compiler) -> PathBuf {
1255         self.ensure(tool::Rustdoc { compiler })
1256     }
1257
1258     pub fn rustdoc_cmd(&self, compiler: Compiler) -> Command {
1259         let mut cmd = Command::new(&self.bootstrap_out.join("rustdoc"));
1260         cmd.env("RUSTC_STAGE", compiler.stage.to_string())
1261             .env("RUSTC_SYSROOT", self.sysroot(compiler))
1262             // Note that this is *not* the sysroot_libdir because rustdoc must be linked
1263             // equivalently to rustc.
1264             .env("RUSTDOC_LIBDIR", self.rustc_libdir(compiler))
1265             .env("CFG_RELEASE_CHANNEL", &self.config.channel)
1266             .env("RUSTDOC_REAL", self.rustdoc(compiler))
1267             .env("RUSTC_BOOTSTRAP", "1");
1268
1269         cmd.arg("-Wrustdoc::invalid_codeblock_attributes");
1270
1271         if self.config.deny_warnings {
1272             cmd.arg("-Dwarnings");
1273         }
1274         cmd.arg("-Znormalize-docs");
1275
1276         // Remove make-related flags that can cause jobserver problems.
1277         cmd.env_remove("MAKEFLAGS");
1278         cmd.env_remove("MFLAGS");
1279
1280         if let Some(linker) = self.linker(compiler.host) {
1281             cmd.env("RUSTDOC_LINKER", linker);
1282         }
1283         if self.is_fuse_ld_lld(compiler.host) {
1284             cmd.env("RUSTDOC_FUSE_LD_LLD", "1");
1285         }
1286         cmd
1287     }
1288
1289     /// Return the path to `llvm-config` for the target, if it exists.
1290     ///
1291     /// Note that this returns `None` if LLVM is disabled, or if we're in a
1292     /// check build or dry-run, where there's no need to build all of LLVM.
1293     fn llvm_config(&self, target: TargetSelection) -> Option<PathBuf> {
1294         if self.config.llvm_enabled() && self.kind != Kind::Check && !self.config.dry_run {
1295             let llvm_config = self.ensure(native::Llvm { target });
1296             if llvm_config.is_file() {
1297                 return Some(llvm_config);
1298             }
1299         }
1300         None
1301     }
1302
1303     /// Convenience wrapper to allow `builder.llvm_link_shared()` instead of `builder.config.llvm_link_shared(&builder)`.
1304     pub(crate) fn llvm_link_shared(&self) -> bool {
1305         Config::llvm_link_shared(self)
1306     }
1307
1308     pub(crate) fn download_rustc(&self) -> bool {
1309         Config::download_rustc(self)
1310     }
1311
1312     pub(crate) fn initial_rustfmt(&self) -> Option<PathBuf> {
1313         Config::initial_rustfmt(self)
1314     }
1315
1316     /// Prepares an invocation of `cargo` to be run.
1317     ///
1318     /// This will create a `Command` that represents a pending execution of
1319     /// Cargo. This cargo will be configured to use `compiler` as the actual
1320     /// rustc compiler, its output will be scoped by `mode`'s output directory,
1321     /// it will pass the `--target` flag for the specified `target`, and will be
1322     /// executing the Cargo command `cmd`.
1323     pub fn cargo(
1324         &self,
1325         compiler: Compiler,
1326         mode: Mode,
1327         source_type: SourceType,
1328         target: TargetSelection,
1329         cmd: &str,
1330     ) -> Cargo {
1331         let mut cargo = Command::new(&self.initial_cargo);
1332         let out_dir = self.stage_out(compiler, mode);
1333         // Run cargo from the source root so it can find .cargo/config.
1334         // This matters when using vendoring and the working directory is outside the repository.
1335         cargo.current_dir(&self.src);
1336
1337         // Codegen backends are not yet tracked by -Zbinary-dep-depinfo,
1338         // so we need to explicitly clear out if they've been updated.
1339         for backend in self.codegen_backends(compiler) {
1340             self.clear_if_dirty(&out_dir, &backend);
1341         }
1342
1343         if cmd == "doc" || cmd == "rustdoc" {
1344             let my_out = match mode {
1345                 // This is the intended out directory for compiler documentation.
1346                 Mode::Rustc | Mode::ToolRustc => self.compiler_doc_out(target),
1347                 Mode::Std => out_dir.join(target.triple).join("doc"),
1348                 _ => panic!("doc mode {:?} not expected", mode),
1349             };
1350             let rustdoc = self.rustdoc(compiler);
1351             self.clear_if_dirty(&my_out, &rustdoc);
1352         }
1353
1354         cargo.env("CARGO_TARGET_DIR", &out_dir).arg(cmd);
1355
1356         let profile_var = |name: &str| {
1357             let profile = if self.config.rust_optimize { "RELEASE" } else { "DEV" };
1358             format!("CARGO_PROFILE_{}_{}", profile, name)
1359         };
1360
1361         // See comment in rustc_llvm/build.rs for why this is necessary, largely llvm-config
1362         // needs to not accidentally link to libLLVM in stage0/lib.
1363         cargo.env("REAL_LIBRARY_PATH_VAR", &util::dylib_path_var());
1364         if let Some(e) = env::var_os(util::dylib_path_var()) {
1365             cargo.env("REAL_LIBRARY_PATH", e);
1366         }
1367
1368         // Found with `rg "init_env_logger\("`. If anyone uses `init_env_logger`
1369         // from out of tree it shouldn't matter, since x.py is only used for
1370         // building in-tree.
1371         let color_logs = ["RUSTDOC_LOG_COLOR", "RUSTC_LOG_COLOR", "RUST_LOG_COLOR"];
1372         match self.build.config.color {
1373             Color::Always => {
1374                 cargo.arg("--color=always");
1375                 for log in &color_logs {
1376                     cargo.env(log, "always");
1377                 }
1378             }
1379             Color::Never => {
1380                 cargo.arg("--color=never");
1381                 for log in &color_logs {
1382                     cargo.env(log, "never");
1383                 }
1384             }
1385             Color::Auto => {} // nothing to do
1386         }
1387
1388         if cmd != "install" {
1389             cargo.arg("--target").arg(target.rustc_target_arg());
1390         } else {
1391             assert_eq!(target, compiler.host);
1392         }
1393
1394         // Set a flag for `check`/`clippy`/`fix`, so that certain build
1395         // scripts can do less work (i.e. not building/requiring LLVM).
1396         if cmd == "check" || cmd == "clippy" || cmd == "fix" {
1397             // If we've not yet built LLVM, or it's stale, then bust
1398             // the rustc_llvm cache. That will always work, even though it
1399             // may mean that on the next non-check build we'll need to rebuild
1400             // rustc_llvm. But if LLVM is stale, that'll be a tiny amount
1401             // of work comparatively, and we'd likely need to rebuild it anyway,
1402             // so that's okay.
1403             if crate::native::prebuilt_llvm_config(self, target).is_err() {
1404                 cargo.env("RUST_CHECK", "1");
1405             }
1406         }
1407
1408         let stage = if compiler.stage == 0 && self.local_rebuild {
1409             // Assume the local-rebuild rustc already has stage1 features.
1410             1
1411         } else {
1412             compiler.stage
1413         };
1414
1415         let mut rustflags = Rustflags::new(target);
1416         if stage != 0 {
1417             if let Ok(s) = env::var("CARGOFLAGS_NOT_BOOTSTRAP") {
1418                 cargo.args(s.split_whitespace());
1419             }
1420             rustflags.env("RUSTFLAGS_NOT_BOOTSTRAP");
1421         } else {
1422             if let Ok(s) = env::var("CARGOFLAGS_BOOTSTRAP") {
1423                 cargo.args(s.split_whitespace());
1424             }
1425             rustflags.env("RUSTFLAGS_BOOTSTRAP");
1426             if cmd == "clippy" {
1427                 // clippy overwrites sysroot if we pass it to cargo.
1428                 // Pass it directly to clippy instead.
1429                 // NOTE: this can't be fixed in clippy because we explicitly don't set `RUSTC`,
1430                 // so it has no way of knowing the sysroot.
1431                 rustflags.arg("--sysroot");
1432                 rustflags.arg(
1433                     self.sysroot(compiler)
1434                         .as_os_str()
1435                         .to_str()
1436                         .expect("sysroot must be valid UTF-8"),
1437                 );
1438                 // Only run clippy on a very limited subset of crates (in particular, not build scripts).
1439                 cargo.arg("-Zunstable-options");
1440                 // Explicitly does *not* set `--cfg=bootstrap`, since we're using a nightly clippy.
1441                 let host_version = Command::new("rustc").arg("--version").output().map_err(|_| ());
1442                 let output = host_version.and_then(|output| {
1443                     if output.status.success() {
1444                         Ok(output)
1445                     } else {
1446                         Err(())
1447                     }
1448                 }).unwrap_or_else(|_| {
1449                     eprintln!(
1450                         "error: `x.py clippy` requires a host `rustc` toolchain with the `clippy` component"
1451                     );
1452                     eprintln!("help: try `rustup component add clippy`");
1453                     crate::detail_exit(1);
1454                 });
1455                 if !t!(std::str::from_utf8(&output.stdout)).contains("nightly") {
1456                     rustflags.arg("--cfg=bootstrap");
1457                 }
1458             } else {
1459                 rustflags.arg("--cfg=bootstrap");
1460             }
1461         }
1462
1463         let use_new_symbol_mangling = match self.config.rust_new_symbol_mangling {
1464             Some(setting) => {
1465                 // If an explicit setting is given, use that
1466                 setting
1467             }
1468             None => {
1469                 if mode == Mode::Std {
1470                     // The standard library defaults to the legacy scheme
1471                     false
1472                 } else {
1473                     // The compiler and tools default to the new scheme
1474                     true
1475                 }
1476             }
1477         };
1478
1479         if use_new_symbol_mangling {
1480             rustflags.arg("-Csymbol-mangling-version=v0");
1481         } else {
1482             rustflags.arg("-Csymbol-mangling-version=legacy");
1483             rustflags.arg("-Zunstable-options");
1484         }
1485
1486         // Enable cfg checking of cargo features for everything but std and also enable cfg
1487         // checking of names and values.
1488         //
1489         // Note: `std`, `alloc` and `core` imports some dependencies by #[path] (like
1490         // backtrace, core_simd, std_float, ...), those dependencies have their own
1491         // features but cargo isn't involved in the #[path] process and so cannot pass the
1492         // complete list of features, so for that reason we don't enable checking of
1493         // features for std crates.
1494         cargo.arg(if mode != Mode::Std {
1495             "-Zcheck-cfg=names,values,output,features"
1496         } else {
1497             "-Zcheck-cfg=names,values,output"
1498         });
1499
1500         // Add extra cfg not defined in/by rustc
1501         //
1502         // Note: Altrough it would seems that "-Zunstable-options" to `rustflags` is useless as
1503         // cargo would implicitly add it, it was discover that sometimes bootstrap only use
1504         // `rustflags` without `cargo` making it required.
1505         rustflags.arg("-Zunstable-options");
1506         for (restricted_mode, name, values) in EXTRA_CHECK_CFGS {
1507             if *restricted_mode == None || *restricted_mode == Some(mode) {
1508                 // Creating a string of the values by concatenating each value:
1509                 // ',"tvos","watchos"' or '' (nothing) when there are no values
1510                 let values = match values {
1511                     Some(values) => values
1512                         .iter()
1513                         .map(|val| [",", "\"", val, "\""])
1514                         .flatten()
1515                         .collect::<String>(),
1516                     None => String::new(),
1517                 };
1518                 rustflags.arg(&format!("--check-cfg=values({name}{values})"));
1519             }
1520         }
1521
1522         // FIXME: It might be better to use the same value for both `RUSTFLAGS` and `RUSTDOCFLAGS`,
1523         // but this breaks CI. At the very least, stage0 `rustdoc` needs `--cfg bootstrap`. See
1524         // #71458.
1525         let mut rustdocflags = rustflags.clone();
1526         rustdocflags.propagate_cargo_env("RUSTDOCFLAGS");
1527         if stage == 0 {
1528             rustdocflags.env("RUSTDOCFLAGS_BOOTSTRAP");
1529         } else {
1530             rustdocflags.env("RUSTDOCFLAGS_NOT_BOOTSTRAP");
1531         }
1532
1533         if let Ok(s) = env::var("CARGOFLAGS") {
1534             cargo.args(s.split_whitespace());
1535         }
1536
1537         match mode {
1538             Mode::Std | Mode::ToolBootstrap | Mode::ToolStd => {}
1539             Mode::Rustc | Mode::Codegen | Mode::ToolRustc => {
1540                 // Build proc macros both for the host and the target
1541                 if target != compiler.host && cmd != "check" {
1542                     cargo.arg("-Zdual-proc-macros");
1543                     rustflags.arg("-Zdual-proc-macros");
1544                 }
1545             }
1546         }
1547
1548         // This tells Cargo (and in turn, rustc) to output more complete
1549         // dependency information.  Most importantly for rustbuild, this
1550         // includes sysroot artifacts, like libstd, which means that we don't
1551         // need to track those in rustbuild (an error prone process!). This
1552         // feature is currently unstable as there may be some bugs and such, but
1553         // it represents a big improvement in rustbuild's reliability on
1554         // rebuilds, so we're using it here.
1555         //
1556         // For some additional context, see #63470 (the PR originally adding
1557         // this), as well as #63012 which is the tracking issue for this
1558         // feature on the rustc side.
1559         cargo.arg("-Zbinary-dep-depinfo");
1560         match mode {
1561             Mode::ToolBootstrap => {
1562                 // Restrict the allowed features to those passed by rustbuild, so we don't depend on nightly accidentally.
1563                 rustflags.arg("-Zallow-features=binary-dep-depinfo");
1564             }
1565             Mode::ToolStd => {
1566                 // Right now this is just compiletest and a few other tools that build on stable.
1567                 // Allow them to use `feature(test)`, but nothing else.
1568                 rustflags.arg("-Zallow-features=binary-dep-depinfo,test,proc_macro_internals,proc_macro_diagnostic,proc_macro_span");
1569             }
1570             Mode::Std | Mode::Rustc | Mode::Codegen | Mode::ToolRustc => {}
1571         }
1572
1573         cargo.arg("-j").arg(self.jobs().to_string());
1574         // Remove make-related flags to ensure Cargo can correctly set things up
1575         cargo.env_remove("MAKEFLAGS");
1576         cargo.env_remove("MFLAGS");
1577
1578         // FIXME: Temporary fix for https://github.com/rust-lang/cargo/issues/3005
1579         // Force cargo to output binaries with disambiguating hashes in the name
1580         let mut metadata = if compiler.stage == 0 {
1581             // Treat stage0 like a special channel, whether it's a normal prior-
1582             // release rustc or a local rebuild with the same version, so we
1583             // never mix these libraries by accident.
1584             "bootstrap".to_string()
1585         } else {
1586             self.config.channel.to_string()
1587         };
1588         // We want to make sure that none of the dependencies between
1589         // std/test/rustc unify with one another. This is done for weird linkage
1590         // reasons but the gist of the problem is that if librustc, libtest, and
1591         // libstd all depend on libc from crates.io (which they actually do) we
1592         // want to make sure they all get distinct versions. Things get really
1593         // weird if we try to unify all these dependencies right now, namely
1594         // around how many times the library is linked in dynamic libraries and
1595         // such. If rustc were a static executable or if we didn't ship dylibs
1596         // this wouldn't be a problem, but we do, so it is. This is in general
1597         // just here to make sure things build right. If you can remove this and
1598         // things still build right, please do!
1599         match mode {
1600             Mode::Std => metadata.push_str("std"),
1601             // When we're building rustc tools, they're built with a search path
1602             // that contains things built during the rustc build. For example,
1603             // bitflags is built during the rustc build, and is a dependency of
1604             // rustdoc as well. We're building rustdoc in a different target
1605             // directory, though, which means that Cargo will rebuild the
1606             // dependency. When we go on to build rustdoc, we'll look for
1607             // bitflags, and find two different copies: one built during the
1608             // rustc step and one that we just built. This isn't always a
1609             // problem, somehow -- not really clear why -- but we know that this
1610             // fixes things.
1611             Mode::ToolRustc => metadata.push_str("tool-rustc"),
1612             // Same for codegen backends.
1613             Mode::Codegen => metadata.push_str("codegen"),
1614             _ => {}
1615         }
1616         cargo.env("__CARGO_DEFAULT_LIB_METADATA", &metadata);
1617
1618         if cmd == "clippy" {
1619             rustflags.arg("-Zforce-unstable-if-unmarked");
1620         }
1621
1622         rustflags.arg("-Zmacro-backtrace");
1623
1624         let want_rustdoc = self.doc_tests != DocTests::No;
1625
1626         // We synthetically interpret a stage0 compiler used to build tools as a
1627         // "raw" compiler in that it's the exact snapshot we download. Normally
1628         // the stage0 build means it uses libraries build by the stage0
1629         // compiler, but for tools we just use the precompiled libraries that
1630         // we've downloaded
1631         let use_snapshot = mode == Mode::ToolBootstrap;
1632         assert!(!use_snapshot || stage == 0 || self.local_rebuild);
1633
1634         let maybe_sysroot = self.sysroot(compiler);
1635         let sysroot = if use_snapshot { self.rustc_snapshot_sysroot() } else { &maybe_sysroot };
1636         let libdir = self.rustc_libdir(compiler);
1637
1638         // Clear the output directory if the real rustc we're using has changed;
1639         // Cargo cannot detect this as it thinks rustc is bootstrap/debug/rustc.
1640         //
1641         // Avoid doing this during dry run as that usually means the relevant
1642         // compiler is not yet linked/copied properly.
1643         //
1644         // Only clear out the directory if we're compiling std; otherwise, we
1645         // should let Cargo take care of things for us (via depdep info)
1646         if !self.config.dry_run && mode == Mode::Std && cmd == "build" {
1647             self.clear_if_dirty(&out_dir, &self.rustc(compiler));
1648         }
1649
1650         // Customize the compiler we're running. Specify the compiler to cargo
1651         // as our shim and then pass it some various options used to configure
1652         // how the actual compiler itself is called.
1653         //
1654         // These variables are primarily all read by
1655         // src/bootstrap/bin/{rustc.rs,rustdoc.rs}
1656         cargo
1657             .env("RUSTBUILD_NATIVE_DIR", self.native_dir(target))
1658             .env("RUSTC_REAL", self.rustc(compiler))
1659             .env("RUSTC_STAGE", stage.to_string())
1660             .env("RUSTC_SYSROOT", &sysroot)
1661             .env("RUSTC_LIBDIR", &libdir)
1662             .env("RUSTDOC", self.bootstrap_out.join("rustdoc"))
1663             .env(
1664                 "RUSTDOC_REAL",
1665                 if cmd == "doc" || cmd == "rustdoc" || (cmd == "test" && want_rustdoc) {
1666                     self.rustdoc(compiler)
1667                 } else {
1668                     PathBuf::from("/path/to/nowhere/rustdoc/not/required")
1669                 },
1670             )
1671             .env("RUSTC_ERROR_METADATA_DST", self.extended_error_dir())
1672             .env("RUSTC_BREAK_ON_ICE", "1");
1673         // Clippy support is a hack and uses the default `cargo-clippy` in path.
1674         // Don't override RUSTC so that the `cargo-clippy` in path will be run.
1675         if cmd != "clippy" {
1676             cargo.env("RUSTC", self.bootstrap_out.join("rustc"));
1677         }
1678
1679         // Dealing with rpath here is a little special, so let's go into some
1680         // detail. First off, `-rpath` is a linker option on Unix platforms
1681         // which adds to the runtime dynamic loader path when looking for
1682         // dynamic libraries. We use this by default on Unix platforms to ensure
1683         // that our nightlies behave the same on Windows, that is they work out
1684         // of the box. This can be disabled, of course, but basically that's why
1685         // we're gated on RUSTC_RPATH here.
1686         //
1687         // Ok, so the astute might be wondering "why isn't `-C rpath` used
1688         // here?" and that is indeed a good question to ask. This codegen
1689         // option is the compiler's current interface to generating an rpath.
1690         // Unfortunately it doesn't quite suffice for us. The flag currently
1691         // takes no value as an argument, so the compiler calculates what it
1692         // should pass to the linker as `-rpath`. This unfortunately is based on
1693         // the **compile time** directory structure which when building with
1694         // Cargo will be very different than the runtime directory structure.
1695         //
1696         // All that's a really long winded way of saying that if we use
1697         // `-Crpath` then the executables generated have the wrong rpath of
1698         // something like `$ORIGIN/deps` when in fact the way we distribute
1699         // rustc requires the rpath to be `$ORIGIN/../lib`.
1700         //
1701         // So, all in all, to set up the correct rpath we pass the linker
1702         // argument manually via `-C link-args=-Wl,-rpath,...`. Plus isn't it
1703         // fun to pass a flag to a tool to pass a flag to pass a flag to a tool
1704         // to change a flag in a binary?
1705         if self.config.rust_rpath && util::use_host_linker(target) {
1706             let rpath = if target.contains("apple") {
1707                 // Note that we need to take one extra step on macOS to also pass
1708                 // `-Wl,-instal_name,@rpath/...` to get things to work right. To
1709                 // do that we pass a weird flag to the compiler to get it to do
1710                 // so. Note that this is definitely a hack, and we should likely
1711                 // flesh out rpath support more fully in the future.
1712                 rustflags.arg("-Zosx-rpath-install-name");
1713                 Some("-Wl,-rpath,@loader_path/../lib")
1714             } else if !target.contains("windows") {
1715                 rustflags.arg("-Clink-args=-Wl,-z,origin");
1716                 Some("-Wl,-rpath,$ORIGIN/../lib")
1717             } else {
1718                 None
1719             };
1720             if let Some(rpath) = rpath {
1721                 rustflags.arg(&format!("-Clink-args={}", rpath));
1722             }
1723         }
1724
1725         if let Some(host_linker) = self.linker(compiler.host) {
1726             cargo.env("RUSTC_HOST_LINKER", host_linker);
1727         }
1728         if self.is_fuse_ld_lld(compiler.host) {
1729             cargo.env("RUSTC_HOST_FUSE_LD_LLD", "1");
1730             cargo.env("RUSTDOC_FUSE_LD_LLD", "1");
1731         }
1732
1733         if let Some(target_linker) = self.linker(target) {
1734             let target = crate::envify(&target.triple);
1735             cargo.env(&format!("CARGO_TARGET_{}_LINKER", target), target_linker);
1736         }
1737         if self.is_fuse_ld_lld(target) {
1738             rustflags.arg("-Clink-args=-fuse-ld=lld");
1739         }
1740         self.lld_flags(target).for_each(|flag| {
1741             rustdocflags.arg(&flag);
1742         });
1743
1744         if !(["build", "check", "clippy", "fix", "rustc"].contains(&cmd)) && want_rustdoc {
1745             cargo.env("RUSTDOC_LIBDIR", self.rustc_libdir(compiler));
1746         }
1747
1748         let debuginfo_level = match mode {
1749             Mode::Rustc | Mode::Codegen => self.config.rust_debuginfo_level_rustc,
1750             Mode::Std => self.config.rust_debuginfo_level_std,
1751             Mode::ToolBootstrap | Mode::ToolStd | Mode::ToolRustc => {
1752                 self.config.rust_debuginfo_level_tools
1753             }
1754         };
1755         cargo.env(profile_var("DEBUG"), debuginfo_level.to_string());
1756         cargo.env(
1757             profile_var("DEBUG_ASSERTIONS"),
1758             if mode == Mode::Std {
1759                 self.config.rust_debug_assertions_std.to_string()
1760             } else {
1761                 self.config.rust_debug_assertions.to_string()
1762             },
1763         );
1764         cargo.env(
1765             profile_var("OVERFLOW_CHECKS"),
1766             if mode == Mode::Std {
1767                 self.config.rust_overflow_checks_std.to_string()
1768             } else {
1769                 self.config.rust_overflow_checks.to_string()
1770             },
1771         );
1772
1773         let split_debuginfo_is_stable = target.contains("linux")
1774             || target.contains("apple")
1775             || (target.contains("msvc")
1776                 && self.config.rust_split_debuginfo == SplitDebuginfo::Packed)
1777             || (target.contains("windows")
1778                 && self.config.rust_split_debuginfo == SplitDebuginfo::Off);
1779
1780         if !split_debuginfo_is_stable {
1781             rustflags.arg("-Zunstable-options");
1782         }
1783         match self.config.rust_split_debuginfo {
1784             SplitDebuginfo::Packed => rustflags.arg("-Csplit-debuginfo=packed"),
1785             SplitDebuginfo::Unpacked => rustflags.arg("-Csplit-debuginfo=unpacked"),
1786             SplitDebuginfo::Off => rustflags.arg("-Csplit-debuginfo=off"),
1787         };
1788
1789         if self.config.cmd.bless() {
1790             // Bless `expect!` tests.
1791             cargo.env("UPDATE_EXPECT", "1");
1792         }
1793
1794         if !mode.is_tool() {
1795             cargo.env("RUSTC_FORCE_UNSTABLE", "1");
1796         }
1797
1798         if let Some(x) = self.crt_static(target) {
1799             if x {
1800                 rustflags.arg("-Ctarget-feature=+crt-static");
1801             } else {
1802                 rustflags.arg("-Ctarget-feature=-crt-static");
1803             }
1804         }
1805
1806         if let Some(x) = self.crt_static(compiler.host) {
1807             cargo.env("RUSTC_HOST_CRT_STATIC", x.to_string());
1808         }
1809
1810         if let Some(map_to) = self.build.debuginfo_map_to(GitRepo::Rustc) {
1811             let map = format!("{}={}", self.build.src.display(), map_to);
1812             cargo.env("RUSTC_DEBUGINFO_MAP", map);
1813
1814             // `rustc` needs to know the virtual `/rustc/$hash` we're mapping to,
1815             // in order to opportunistically reverse it later.
1816             cargo.env("CFG_VIRTUAL_RUST_SOURCE_BASE_DIR", map_to);
1817         }
1818
1819         // Enable usage of unstable features
1820         cargo.env("RUSTC_BOOTSTRAP", "1");
1821         self.add_rust_test_threads(&mut cargo);
1822
1823         // Almost all of the crates that we compile as part of the bootstrap may
1824         // have a build script, including the standard library. To compile a
1825         // build script, however, it itself needs a standard library! This
1826         // introduces a bit of a pickle when we're compiling the standard
1827         // library itself.
1828         //
1829         // To work around this we actually end up using the snapshot compiler
1830         // (stage0) for compiling build scripts of the standard library itself.
1831         // The stage0 compiler is guaranteed to have a libstd available for use.
1832         //
1833         // For other crates, however, we know that we've already got a standard
1834         // library up and running, so we can use the normal compiler to compile
1835         // build scripts in that situation.
1836         if mode == Mode::Std {
1837             cargo
1838                 .env("RUSTC_SNAPSHOT", &self.initial_rustc)
1839                 .env("RUSTC_SNAPSHOT_LIBDIR", self.rustc_snapshot_libdir());
1840         } else {
1841             cargo
1842                 .env("RUSTC_SNAPSHOT", self.rustc(compiler))
1843                 .env("RUSTC_SNAPSHOT_LIBDIR", self.rustc_libdir(compiler));
1844         }
1845
1846         // Tools that use compiler libraries may inherit the `-lLLVM` link
1847         // requirement, but the `-L` library path is not propagated across
1848         // separate Cargo projects. We can add LLVM's library path to the
1849         // platform-specific environment variable as a workaround.
1850         if mode == Mode::ToolRustc || mode == Mode::Codegen {
1851             if let Some(llvm_config) = self.llvm_config(target) {
1852                 let llvm_libdir = output(Command::new(&llvm_config).arg("--libdir"));
1853                 add_link_lib_path(vec![llvm_libdir.trim().into()], &mut cargo);
1854             }
1855         }
1856
1857         // Compile everything except libraries and proc macros with the more
1858         // efficient initial-exec TLS model. This doesn't work with `dlopen`,
1859         // so we can't use it by default in general, but we can use it for tools
1860         // and our own internal libraries.
1861         if !mode.must_support_dlopen() && !target.triple.starts_with("powerpc-") {
1862             cargo.env("RUSTC_TLS_MODEL_INITIAL_EXEC", "1");
1863         }
1864
1865         if self.config.incremental {
1866             cargo.env("CARGO_INCREMENTAL", "1");
1867         } else {
1868             // Don't rely on any default setting for incr. comp. in Cargo
1869             cargo.env("CARGO_INCREMENTAL", "0");
1870         }
1871
1872         if let Some(ref on_fail) = self.config.on_fail {
1873             cargo.env("RUSTC_ON_FAIL", on_fail);
1874         }
1875
1876         if self.config.print_step_timings {
1877             cargo.env("RUSTC_PRINT_STEP_TIMINGS", "1");
1878         }
1879
1880         if self.config.print_step_rusage {
1881             cargo.env("RUSTC_PRINT_STEP_RUSAGE", "1");
1882         }
1883
1884         if self.config.backtrace_on_ice {
1885             cargo.env("RUSTC_BACKTRACE_ON_ICE", "1");
1886         }
1887
1888         cargo.env("RUSTC_VERBOSE", self.verbosity.to_string());
1889
1890         if source_type == SourceType::InTree {
1891             let mut lint_flags = Vec::new();
1892             // When extending this list, add the new lints to the RUSTFLAGS of the
1893             // build_bootstrap function of src/bootstrap/bootstrap.py as well as
1894             // some code doesn't go through this `rustc` wrapper.
1895             lint_flags.push("-Wrust_2018_idioms");
1896             lint_flags.push("-Wunused_lifetimes");
1897             lint_flags.push("-Wsemicolon_in_expressions_from_macros");
1898
1899             if self.config.deny_warnings {
1900                 lint_flags.push("-Dwarnings");
1901                 rustdocflags.arg("-Dwarnings");
1902             }
1903
1904             // This does not use RUSTFLAGS due to caching issues with Cargo.
1905             // Clippy is treated as an "in tree" tool, but shares the same
1906             // cache as other "submodule" tools. With these options set in
1907             // RUSTFLAGS, that causes *every* shared dependency to be rebuilt.
1908             // By injecting this into the rustc wrapper, this circumvents
1909             // Cargo's fingerprint detection. This is fine because lint flags
1910             // are always ignored in dependencies. Eventually this should be
1911             // fixed via better support from Cargo.
1912             cargo.env("RUSTC_LINT_FLAGS", lint_flags.join(" "));
1913
1914             rustdocflags.arg("-Wrustdoc::invalid_codeblock_attributes");
1915         }
1916
1917         if mode == Mode::Rustc {
1918             rustflags.arg("-Zunstable-options");
1919             rustflags.arg("-Wrustc::internal");
1920         }
1921
1922         // Throughout the build Cargo can execute a number of build scripts
1923         // compiling C/C++ code and we need to pass compilers, archivers, flags, etc
1924         // obtained previously to those build scripts.
1925         // Build scripts use either the `cc` crate or `configure/make` so we pass
1926         // the options through environment variables that are fetched and understood by both.
1927         //
1928         // FIXME: the guard against msvc shouldn't need to be here
1929         if target.contains("msvc") {
1930             if let Some(ref cl) = self.config.llvm_clang_cl {
1931                 cargo.env("CC", cl).env("CXX", cl);
1932             }
1933         } else {
1934             let ccache = self.config.ccache.as_ref();
1935             let ccacheify = |s: &Path| {
1936                 let ccache = match ccache {
1937                     Some(ref s) => s,
1938                     None => return s.display().to_string(),
1939                 };
1940                 // FIXME: the cc-rs crate only recognizes the literal strings
1941                 // `ccache` and `sccache` when doing caching compilations, so we
1942                 // mirror that here. It should probably be fixed upstream to
1943                 // accept a new env var or otherwise work with custom ccache
1944                 // vars.
1945                 match &ccache[..] {
1946                     "ccache" | "sccache" => format!("{} {}", ccache, s.display()),
1947                     _ => s.display().to_string(),
1948                 }
1949             };
1950             let triple_underscored = target.triple.replace("-", "_");
1951             let cc = ccacheify(&self.cc(target));
1952             cargo.env(format!("CC_{}", triple_underscored), &cc);
1953
1954             let cflags = self.cflags(target, GitRepo::Rustc, CLang::C).join(" ");
1955             cargo.env(format!("CFLAGS_{}", triple_underscored), &cflags);
1956
1957             if let Some(ar) = self.ar(target) {
1958                 let ranlib = format!("{} s", ar.display());
1959                 cargo
1960                     .env(format!("AR_{}", triple_underscored), ar)
1961                     .env(format!("RANLIB_{}", triple_underscored), ranlib);
1962             }
1963
1964             if let Ok(cxx) = self.cxx(target) {
1965                 let cxx = ccacheify(&cxx);
1966                 let cxxflags = self.cflags(target, GitRepo::Rustc, CLang::Cxx).join(" ");
1967                 cargo
1968                     .env(format!("CXX_{}", triple_underscored), &cxx)
1969                     .env(format!("CXXFLAGS_{}", triple_underscored), cxxflags);
1970             }
1971         }
1972
1973         if mode == Mode::Std && self.config.extended && compiler.is_final_stage(self) {
1974             rustflags.arg("-Zsave-analysis");
1975             cargo.env(
1976                 "RUST_SAVE_ANALYSIS_CONFIG",
1977                 "{\"output_file\": null,\"full_docs\": false,\
1978                        \"pub_only\": true,\"reachable_only\": false,\
1979                        \"distro_crate\": true,\"signatures\": false,\"borrow_data\": false}",
1980             );
1981         }
1982
1983         // If Control Flow Guard is enabled, pass the `control-flow-guard` flag to rustc
1984         // when compiling the standard library, since this might be linked into the final outputs
1985         // produced by rustc. Since this mitigation is only available on Windows, only enable it
1986         // for the standard library in case the compiler is run on a non-Windows platform.
1987         // This is not needed for stage 0 artifacts because these will only be used for building
1988         // the stage 1 compiler.
1989         if cfg!(windows)
1990             && mode == Mode::Std
1991             && self.config.control_flow_guard
1992             && compiler.stage >= 1
1993         {
1994             rustflags.arg("-Ccontrol-flow-guard");
1995         }
1996
1997         // For `cargo doc` invocations, make rustdoc print the Rust version into the docs
1998         // This replaces spaces with newlines because RUSTDOCFLAGS does not
1999         // support arguments with regular spaces. Hopefully someday Cargo will
2000         // have space support.
2001         let rust_version = self.rust_version().replace(' ', "\n");
2002         rustdocflags.arg("--crate-version").arg(&rust_version);
2003
2004         // Environment variables *required* throughout the build
2005         //
2006         // FIXME: should update code to not require this env var
2007         cargo.env("CFG_COMPILER_HOST_TRIPLE", target.triple);
2008
2009         // Set this for all builds to make sure doc builds also get it.
2010         cargo.env("CFG_RELEASE_CHANNEL", &self.config.channel);
2011
2012         // This one's a bit tricky. As of the time of this writing the compiler
2013         // links to the `winapi` crate on crates.io. This crate provides raw
2014         // bindings to Windows system functions, sort of like libc does for
2015         // Unix. This crate also, however, provides "import libraries" for the
2016         // MinGW targets. There's an import library per dll in the windows
2017         // distribution which is what's linked to. These custom import libraries
2018         // are used because the winapi crate can reference Windows functions not
2019         // present in the MinGW import libraries.
2020         //
2021         // For example MinGW may ship libdbghelp.a, but it may not have
2022         // references to all the functions in the dbghelp dll. Instead the
2023         // custom import library for dbghelp in the winapi crates has all this
2024         // information.
2025         //
2026         // Unfortunately for us though the import libraries are linked by
2027         // default via `-ldylib=winapi_foo`. That is, they're linked with the
2028         // `dylib` type with a `winapi_` prefix (so the winapi ones don't
2029         // conflict with the system MinGW ones). This consequently means that
2030         // the binaries we ship of things like rustc_codegen_llvm (aka the rustc_codegen_llvm
2031         // DLL) when linked against *again*, for example with procedural macros
2032         // or plugins, will trigger the propagation logic of `-ldylib`, passing
2033         // `-lwinapi_foo` to the linker again. This isn't actually available in
2034         // our distribution, however, so the link fails.
2035         //
2036         // To solve this problem we tell winapi to not use its bundled import
2037         // libraries. This means that it will link to the system MinGW import
2038         // libraries by default, and the `-ldylib=foo` directives will still get
2039         // passed to the final linker, but they'll look like `-lfoo` which can
2040         // be resolved because MinGW has the import library. The downside is we
2041         // don't get newer functions from Windows, but we don't use any of them
2042         // anyway.
2043         if !mode.is_tool() {
2044             cargo.env("WINAPI_NO_BUNDLED_LIBRARIES", "1");
2045         }
2046
2047         for _ in 0..self.verbosity {
2048             cargo.arg("-v");
2049         }
2050
2051         match (mode, self.config.rust_codegen_units_std, self.config.rust_codegen_units) {
2052             (Mode::Std, Some(n), _) | (_, _, Some(n)) => {
2053                 cargo.env(profile_var("CODEGEN_UNITS"), n.to_string());
2054             }
2055             _ => {
2056                 // Don't set anything
2057             }
2058         }
2059
2060         if self.config.rust_optimize {
2061             // FIXME: cargo bench/install do not accept `--release`
2062             if cmd != "bench" && cmd != "install" {
2063                 cargo.arg("--release");
2064             }
2065         }
2066
2067         if self.config.locked_deps {
2068             cargo.arg("--locked");
2069         }
2070         if self.config.vendor || self.is_sudo {
2071             cargo.arg("--frozen");
2072         }
2073
2074         // Try to use a sysroot-relative bindir, in case it was configured absolutely.
2075         cargo.env("RUSTC_INSTALL_BINDIR", self.config.bindir_relative());
2076
2077         self.ci_env.force_coloring_in_ci(&mut cargo);
2078
2079         // When we build Rust dylibs they're all intended for intermediate
2080         // usage, so make sure we pass the -Cprefer-dynamic flag instead of
2081         // linking all deps statically into the dylib.
2082         if matches!(mode, Mode::Std | Mode::Rustc) {
2083             rustflags.arg("-Cprefer-dynamic");
2084         }
2085
2086         // When building incrementally we default to a lower ThinLTO import limit
2087         // (unless explicitly specified otherwise). This will produce a somewhat
2088         // slower code but give way better compile times.
2089         {
2090             let limit = match self.config.rust_thin_lto_import_instr_limit {
2091                 Some(limit) => Some(limit),
2092                 None if self.config.incremental => Some(10),
2093                 _ => None,
2094             };
2095
2096             if let Some(limit) = limit {
2097                 rustflags.arg(&format!("-Cllvm-args=-import-instr-limit={}", limit));
2098             }
2099         }
2100
2101         Cargo { command: cargo, rustflags, rustdocflags }
2102     }
2103
2104     /// Ensure that a given step is built, returning its output. This will
2105     /// cache the step, so it is safe (and good!) to call this as often as
2106     /// needed to ensure that all dependencies are built.
2107     pub fn ensure<S: Step>(&'a self, step: S) -> S::Output {
2108         {
2109             let mut stack = self.stack.borrow_mut();
2110             for stack_step in stack.iter() {
2111                 // should skip
2112                 if stack_step.downcast_ref::<S>().map_or(true, |stack_step| *stack_step != step) {
2113                     continue;
2114                 }
2115                 let mut out = String::new();
2116                 out += &format!("\n\nCycle in build detected when adding {:?}\n", step);
2117                 for el in stack.iter().rev() {
2118                     out += &format!("\t{:?}\n", el);
2119                 }
2120                 panic!("{}", out);
2121             }
2122             if let Some(out) = self.cache.get(&step) {
2123                 self.verbose_than(1, &format!("{}c {:?}", "  ".repeat(stack.len()), step));
2124
2125                 return out;
2126             }
2127             self.verbose_than(1, &format!("{}> {:?}", "  ".repeat(stack.len()), step));
2128             stack.push(Box::new(step.clone()));
2129         }
2130
2131         #[cfg(feature = "build-metrics")]
2132         self.metrics.enter_step(&step);
2133
2134         let (out, dur) = {
2135             let start = Instant::now();
2136             let zero = Duration::new(0, 0);
2137             let parent = self.time_spent_on_dependencies.replace(zero);
2138             let out = step.clone().run(self);
2139             let dur = start.elapsed();
2140             let deps = self.time_spent_on_dependencies.replace(parent + dur);
2141             (out, dur - deps)
2142         };
2143
2144         if self.config.print_step_timings && !self.config.dry_run {
2145             let step_string = format!("{:?}", step);
2146             let brace_index = step_string.find("{").unwrap_or(0);
2147             let type_string = type_name::<S>();
2148             println!(
2149                 "[TIMING] {} {} -- {}.{:03}",
2150                 &type_string.strip_prefix("bootstrap::").unwrap_or(type_string),
2151                 &step_string[brace_index..],
2152                 dur.as_secs(),
2153                 dur.subsec_millis()
2154             );
2155         }
2156
2157         #[cfg(feature = "build-metrics")]
2158         self.metrics.exit_step();
2159
2160         {
2161             let mut stack = self.stack.borrow_mut();
2162             let cur_step = stack.pop().expect("step stack empty");
2163             assert_eq!(cur_step.downcast_ref(), Some(&step));
2164         }
2165         self.verbose_than(1, &format!("{}< {:?}", "  ".repeat(self.stack.borrow().len()), step));
2166         self.cache.put(step, out.clone());
2167         out
2168     }
2169
2170     /// Ensure that a given step is built *only if it's supposed to be built by default*, returning
2171     /// its output. This will cache the step, so it's safe (and good!) to call this as often as
2172     /// needed to ensure that all dependencies are build.
2173     pub(crate) fn ensure_if_default<T, S: Step<Output = Option<T>>>(
2174         &'a self,
2175         step: S,
2176         kind: Kind,
2177     ) -> S::Output {
2178         let desc = StepDescription::from::<S>(kind);
2179         let should_run = (desc.should_run)(ShouldRun::new(self, desc.kind));
2180
2181         // Avoid running steps contained in --exclude
2182         for pathset in &should_run.paths {
2183             if desc.is_excluded(self, pathset) {
2184                 return None;
2185             }
2186         }
2187
2188         // Only execute if it's supposed to run as default
2189         if desc.default && should_run.is_really_default() { self.ensure(step) } else { None }
2190     }
2191
2192     /// Checks if any of the "should_run" paths is in the `Builder` paths.
2193     pub(crate) fn was_invoked_explicitly<S: Step>(&'a self, kind: Kind) -> bool {
2194         let desc = StepDescription::from::<S>(kind);
2195         let should_run = (desc.should_run)(ShouldRun::new(self, desc.kind));
2196
2197         for path in &self.paths {
2198             if should_run.paths.iter().any(|s| s.has(path, Some(desc.kind)))
2199                 && !desc.is_excluded(
2200                     self,
2201                     &PathSet::Suite(TaskPath { path: path.clone(), kind: Some(desc.kind) }),
2202                 )
2203             {
2204                 return true;
2205             }
2206         }
2207
2208         false
2209     }
2210
2211     pub(crate) fn maybe_open_in_browser<S: Step>(&self, path: impl AsRef<Path>) {
2212         if self.was_invoked_explicitly::<S>(Kind::Doc) {
2213             self.open_in_browser(path);
2214         }
2215     }
2216
2217     pub(crate) fn open_in_browser(&self, path: impl AsRef<Path>) {
2218         if self.config.dry_run || !self.config.cmd.open() {
2219             return;
2220         }
2221
2222         let path = path.as_ref();
2223         self.info(&format!("Opening doc {}", path.display()));
2224         if let Err(err) = opener::open(path) {
2225             self.info(&format!("{}\n", err));
2226         }
2227     }
2228 }
2229
2230 #[cfg(test)]
2231 mod tests;
2232
2233 #[derive(Debug, Clone)]
2234 struct Rustflags(String, TargetSelection);
2235
2236 impl Rustflags {
2237     fn new(target: TargetSelection) -> Rustflags {
2238         let mut ret = Rustflags(String::new(), target);
2239         ret.propagate_cargo_env("RUSTFLAGS");
2240         ret
2241     }
2242
2243     /// By default, cargo will pick up on various variables in the environment. However, bootstrap
2244     /// reuses those variables to pass additional flags to rustdoc, so by default they get overridden.
2245     /// Explicitly add back any previous value in the environment.
2246     ///
2247     /// `prefix` is usually `RUSTFLAGS` or `RUSTDOCFLAGS`.
2248     fn propagate_cargo_env(&mut self, prefix: &str) {
2249         // Inherit `RUSTFLAGS` by default ...
2250         self.env(prefix);
2251
2252         // ... and also handle target-specific env RUSTFLAGS if they're configured.
2253         let target_specific = format!("CARGO_TARGET_{}_{}", crate::envify(&self.1.triple), prefix);
2254         self.env(&target_specific);
2255     }
2256
2257     fn env(&mut self, env: &str) {
2258         if let Ok(s) = env::var(env) {
2259             for part in s.split(' ') {
2260                 self.arg(part);
2261             }
2262         }
2263     }
2264
2265     fn arg(&mut self, arg: &str) -> &mut Self {
2266         assert_eq!(arg.split(' ').count(), 1);
2267         if !self.0.is_empty() {
2268             self.0.push(' ');
2269         }
2270         self.0.push_str(arg);
2271         self
2272     }
2273 }
2274
2275 #[derive(Debug)]
2276 pub struct Cargo {
2277     command: Command,
2278     rustflags: Rustflags,
2279     rustdocflags: Rustflags,
2280 }
2281
2282 impl Cargo {
2283     pub fn rustdocflag(&mut self, arg: &str) -> &mut Cargo {
2284         self.rustdocflags.arg(arg);
2285         self
2286     }
2287     pub fn rustflag(&mut self, arg: &str) -> &mut Cargo {
2288         self.rustflags.arg(arg);
2289         self
2290     }
2291
2292     pub fn arg(&mut self, arg: impl AsRef<OsStr>) -> &mut Cargo {
2293         self.command.arg(arg.as_ref());
2294         self
2295     }
2296
2297     pub fn args<I, S>(&mut self, args: I) -> &mut Cargo
2298     where
2299         I: IntoIterator<Item = S>,
2300         S: AsRef<OsStr>,
2301     {
2302         for arg in args {
2303             self.arg(arg.as_ref());
2304         }
2305         self
2306     }
2307
2308     pub fn env(&mut self, key: impl AsRef<OsStr>, value: impl AsRef<OsStr>) -> &mut Cargo {
2309         // These are managed through rustflag/rustdocflag interfaces.
2310         assert_ne!(key.as_ref(), "RUSTFLAGS");
2311         assert_ne!(key.as_ref(), "RUSTDOCFLAGS");
2312         self.command.env(key.as_ref(), value.as_ref());
2313         self
2314     }
2315
2316     pub fn add_rustc_lib_path(&mut self, builder: &Builder<'_>, compiler: Compiler) {
2317         builder.add_rustc_lib_path(compiler, &mut self.command);
2318     }
2319
2320     pub fn current_dir(&mut self, dir: &Path) -> &mut Cargo {
2321         self.command.current_dir(dir);
2322         self
2323     }
2324 }
2325
2326 impl From<Cargo> for Command {
2327     fn from(mut cargo: Cargo) -> Command {
2328         let rustflags = &cargo.rustflags.0;
2329         if !rustflags.is_empty() {
2330             cargo.command.env("RUSTFLAGS", rustflags);
2331         }
2332
2333         let rustdocflags = &cargo.rustdocflags.0;
2334         if !rustdocflags.is_empty() {
2335             cargo.command.env("RUSTDOCFLAGS", rustdocflags);
2336         }
2337
2338         cargo.command
2339     }
2340 }