src/bootstrap/builder.rs

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