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