]> git.lizzy.rs Git - rust.git/blob - src/bootstrap/lib.rs
Add an unstable FileTypeExt extension trait for Windows
[rust.git] / src / bootstrap / lib.rs
1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 //! Implementation of rustbuild, the Rust build system.
12 //!
13 //! This module, and its descendants, are the implementation of the Rust build
14 //! system. Most of this build system is backed by Cargo but the outer layer
15 //! here serves as the ability to orchestrate calling Cargo, sequencing Cargo
16 //! builds, building artifacts like LLVM, etc. The goals of rustbuild are:
17 //!
18 //! * To be an easily understandable, easily extensible, and maintainable build
19 //!   system.
20 //! * Leverage standard tools in the Rust ecosystem to build the compiler, aka
21 //!   crates.io and Cargo.
22 //! * A standard interface to build across all platforms, including MSVC
23 //!
24 //! ## Architecture
25 //!
26 //! The build system defers most of the complicated logic managing invocations
27 //! of rustc and rustdoc to Cargo itself. However, moving through various stages
28 //! and copying artifacts is still necessary for it to do. Each time rustbuild
29 //! is invoked, it will iterate through the list of predefined steps and execute
30 //! each serially in turn if it matches the paths passed or is a default rule.
31 //! For each step rustbuild relies on the step internally being incremental and
32 //! parallel. Note, though, that the `-j` parameter to rustbuild gets forwarded
33 //! to appropriate test harnesses and such.
34 //!
35 //! Most of the "meaty" steps that matter are backed by Cargo, which does indeed
36 //! have its own parallelism and incremental management. Later steps, like
37 //! tests, aren't incremental and simply run the entire suite currently.
38 //! However, compiletest itself tries to avoid running tests when the artifacts
39 //! that are involved (mainly the compiler) haven't changed.
40 //!
41 //! When you execute `x.py build`, the steps which are executed are:
42 //!
43 //! * First, the python script is run. This will automatically download the
44 //!   stage0 rustc and cargo according to `src/stage0.txt`, or use the cached
45 //!   versions if they're available. These are then used to compile rustbuild
46 //!   itself (using Cargo). Finally, control is then transferred to rustbuild.
47 //!
48 //! * Rustbuild takes over, performs sanity checks, probes the environment,
49 //!   reads configuration, and starts executing steps as it reads the command
50 //!   line arguments (paths) or going through the default rules.
51 //!
52 //!   The build output will be something like the following:
53 //!
54 //!   Building stage0 std artifacts
55 //!   Copying stage0 std
56 //!   Building stage0 test artifacts
57 //!   Copying stage0 test
58 //!   Building stage0 compiler artifacts
59 //!   Copying stage0 rustc
60 //!   Assembling stage1 compiler
61 //!   Building stage1 std artifacts
62 //!   Copying stage1 std
63 //!   Building stage1 test artifacts
64 //!   Copying stage1 test
65 //!   Building stage1 compiler artifacts
66 //!   Copying stage1 rustc
67 //!   Assembling stage2 compiler
68 //!   Uplifting stage1 std
69 //!   Uplifting stage1 test
70 //!   Uplifting stage1 rustc
71 //!
72 //! Let's disect that a little:
73 //!
74 //! ## Building stage0 {std,test,compiler} artifacts
75 //!
76 //! These steps use the provided (downloaded, usually) compiler to compile the
77 //! local Rust source into libraries we can use.
78 //!
79 //! ## Copying stage0 {std,test,rustc}
80 //!
81 //! This copies the build output from Cargo into
82 //! `build/$HOST/stage0-sysroot/lib/rustlib/$ARCH/lib`. FIXME: This step's
83 //! documentation should be expanded -- the information already here may be
84 //! incorrect.
85 //!
86 //! ## Assembling stage1 compiler
87 //!
88 //! This copies the libraries we built in "building stage0 ... artifacts" into
89 //! the stage1 compiler's lib directory. These are the host libraries that the
90 //! compiler itself uses to run. These aren't actually used by artifacts the new
91 //! compiler generates. This step also copies the rustc and rustdoc binaries we
92 //! generated into build/$HOST/stage/bin.
93 //!
94 //! The stage1/bin/rustc is a fully functional compiler, but it doesn't yet have
95 //! any libraries to link built binaries or libraries to. The next 3 steps will
96 //! provide those libraries for it; they are mostly equivalent to constructing
97 //! the stage1/bin compiler so we don't go through them individually.
98 //!
99 //! ## Uplifting stage1 {std,test,rustc}
100 //!
101 //! This step copies the libraries from the stage1 compiler sysroot into the
102 //! stage2 compiler. This is done to avoid rebuilding the compiler; libraries
103 //! we'd build in this step should be identical (in function, if not necessarily
104 //! identical on disk) so there's no need to recompile the compiler again. Note
105 //! that if you want to, you can enable the full-bootstrap option to change this
106 //! behavior.
107 //!
108 //! Each step is driven by a separate Cargo project and rustbuild orchestrates
109 //! copying files between steps and otherwise preparing for Cargo to run.
110 //!
111 //! ## Further information
112 //!
113 //! More documentation can be found in each respective module below, and you can
114 //! also check out the `src/bootstrap/README.md` file for more information.
115
116 #![deny(warnings)]
117 #![allow(stable_features)]
118 #![feature(associated_consts)]
119
120 #[macro_use]
121 extern crate build_helper;
122 #[macro_use]
123 extern crate serde_derive;
124 #[macro_use]
125 extern crate lazy_static;
126 extern crate serde_json;
127 extern crate cmake;
128 extern crate filetime;
129 extern crate cc;
130 extern crate getopts;
131 extern crate num_cpus;
132 extern crate toml;
133
134 #[cfg(unix)]
135 extern crate libc;
136
137 use std::cell::{RefCell, Cell};
138 use std::collections::{HashSet, HashMap};
139 use std::env;
140 use std::fs::{self, File};
141 use std::io::Read;
142 use std::path::{PathBuf, Path};
143 use std::process::{self, Command};
144 use std::slice;
145
146 use build_helper::{run_silent, run_suppressed, try_run_silent, try_run_suppressed, output, mtime};
147
148 use util::{exe, libdir, OutputFolder, CiEnv};
149
150 mod cc_detect;
151 mod channel;
152 mod check;
153 mod test;
154 mod clean;
155 mod compile;
156 mod metadata;
157 mod config;
158 mod dist;
159 mod doc;
160 mod flags;
161 mod install;
162 mod native;
163 mod sanity;
164 pub mod util;
165 mod builder;
166 mod cache;
167 mod tool;
168 mod toolstate;
169
170 #[cfg(windows)]
171 mod job;
172
173 #[cfg(unix)]
174 mod job {
175     use libc;
176
177     pub unsafe fn setup(build: &mut ::Build) {
178         if build.config.low_priority {
179             libc::setpriority(libc::PRIO_PGRP as _, 0, 10);
180         }
181     }
182 }
183
184 #[cfg(not(any(unix, windows)))]
185 mod job {
186     pub unsafe fn setup(_build: &mut ::Build) {
187     }
188 }
189
190 pub use config::Config;
191 use flags::Subcommand;
192 use cache::{Interned, INTERNER};
193 use toolstate::ToolState;
194
195 /// A structure representing a Rust compiler.
196 ///
197 /// Each compiler has a `stage` that it is associated with and a `host` that
198 /// corresponds to the platform the compiler runs on. This structure is used as
199 /// a parameter to many methods below.
200 #[derive(Eq, PartialEq, Clone, Copy, Hash, Debug)]
201 pub struct Compiler {
202     stage: u32,
203     host: Interned<String>,
204 }
205
206 /// Global configuration for the build system.
207 ///
208 /// This structure transitively contains all configuration for the build system.
209 /// All filesystem-encoded configuration is in `config`, all flags are in
210 /// `flags`, and then parsed or probed information is listed in the keys below.
211 ///
212 /// This structure is a parameter of almost all methods in the build system,
213 /// although most functions are implemented as free functions rather than
214 /// methods specifically on this structure itself (to make it easier to
215 /// organize).
216 pub struct Build {
217     // User-specified configuration via config.toml
218     config: Config,
219
220     // Derived properties from the above two configurations
221     src: PathBuf,
222     out: PathBuf,
223     rust_info: channel::GitInfo,
224     cargo_info: channel::GitInfo,
225     rls_info: channel::GitInfo,
226     rustfmt_info: channel::GitInfo,
227     local_rebuild: bool,
228     fail_fast: bool,
229     verbosity: usize,
230
231     // Targets for which to build.
232     build: Interned<String>,
233     hosts: Vec<Interned<String>>,
234     targets: Vec<Interned<String>>,
235
236     // Stage 0 (downloaded) compiler and cargo or their local rust equivalents.
237     initial_rustc: PathBuf,
238     initial_cargo: PathBuf,
239
240     // Probed tools at runtime
241     lldb_version: Option<String>,
242     lldb_python_dir: Option<String>,
243
244     // Runtime state filled in later on
245     // C/C++ compilers and archiver for all targets
246     cc: HashMap<Interned<String>, cc::Tool>,
247     cxx: HashMap<Interned<String>, cc::Tool>,
248     ar: HashMap<Interned<String>, PathBuf>,
249     // Misc
250     crates: HashMap<Interned<String>, Crate>,
251     is_sudo: bool,
252     ci_env: CiEnv,
253     delayed_failures: RefCell<Vec<String>>,
254     prerelease_version: Cell<Option<u32>>,
255 }
256
257 #[derive(Debug)]
258 struct Crate {
259     name: Interned<String>,
260     version: String,
261     deps: Vec<Interned<String>>,
262     path: PathBuf,
263     doc_step: String,
264     build_step: String,
265     test_step: String,
266     bench_step: String,
267 }
268
269 /// The various "modes" of invoking Cargo.
270 ///
271 /// These entries currently correspond to the various output directories of the
272 /// build system, with each mod generating output in a different directory.
273 #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
274 pub enum Mode {
275     /// Build the standard library, placing output in the "stageN-std" directory.
276     Libstd,
277
278     /// Build libtest, placing output in the "stageN-test" directory.
279     Libtest,
280
281     /// Build librustc and compiler libraries, placing output in the "stageN-rustc" directory.
282     Librustc,
283
284     /// Build some tool, placing output in the "stageN-tools" directory.
285     Tool,
286 }
287
288 impl Build {
289     /// Creates a new set of build configuration from the `flags` on the command
290     /// line and the filesystem `config`.
291     ///
292     /// By default all build output will be placed in the current directory.
293     pub fn new(config: Config) -> Build {
294         let cwd = t!(env::current_dir());
295         let src = config.src.clone();
296         let out = cwd.join("build");
297
298         let is_sudo = match env::var_os("SUDO_USER") {
299             Some(sudo_user) => {
300                 match env::var_os("USER") {
301                     Some(user) => user != sudo_user,
302                     None => false,
303                 }
304             }
305             None => false,
306         };
307         let rust_info = channel::GitInfo::new(&config, &src);
308         let cargo_info = channel::GitInfo::new(&config, &src.join("src/tools/cargo"));
309         let rls_info = channel::GitInfo::new(&config, &src.join("src/tools/rls"));
310         let rustfmt_info = channel::GitInfo::new(&config, &src.join("src/tools/rustfmt"));
311
312         Build {
313             initial_rustc: config.initial_rustc.clone(),
314             initial_cargo: config.initial_cargo.clone(),
315             local_rebuild: config.local_rebuild,
316             fail_fast: config.cmd.fail_fast(),
317             verbosity: config.verbose,
318
319             build: config.build,
320             hosts: config.hosts.clone(),
321             targets: config.targets.clone(),
322
323             config,
324             src,
325             out,
326
327             rust_info,
328             cargo_info,
329             rls_info,
330             rustfmt_info,
331             cc: HashMap::new(),
332             cxx: HashMap::new(),
333             ar: HashMap::new(),
334             crates: HashMap::new(),
335             lldb_version: None,
336             lldb_python_dir: None,
337             is_sudo,
338             ci_env: CiEnv::current(),
339             delayed_failures: RefCell::new(Vec::new()),
340             prerelease_version: Cell::new(None),
341         }
342     }
343
344     pub fn build_triple(&self) -> &[Interned<String>] {
345         unsafe {
346             slice::from_raw_parts(&self.build, 1)
347         }
348     }
349
350     /// Executes the entire build, as configured by the flags and configuration.
351     pub fn build(&mut self) {
352         unsafe {
353             job::setup(self);
354         }
355
356         if let Subcommand::Clean { all } = self.config.cmd {
357             return clean::clean(self, all);
358         }
359
360         self.verbose("finding compilers");
361         cc_detect::find(self);
362         self.verbose("running sanity check");
363         sanity::check(self);
364         // If local-rust is the same major.minor as the current version, then force a local-rebuild
365         let local_version_verbose = output(
366             Command::new(&self.initial_rustc).arg("--version").arg("--verbose"));
367         let local_release = local_version_verbose
368             .lines().filter(|x| x.starts_with("release:"))
369             .next().unwrap().trim_left_matches("release:").trim();
370         let my_version = channel::CFG_RELEASE_NUM;
371         if local_release.split('.').take(2).eq(my_version.split('.').take(2)) {
372             self.verbose(&format!("auto-detected local-rebuild {}", local_release));
373             self.local_rebuild = true;
374         }
375         self.verbose("learning about cargo");
376         metadata::build(self);
377
378         builder::Builder::run(&self);
379
380         // Check for postponed failures from `test --no-fail-fast`.
381         let failures = self.delayed_failures.borrow();
382         if failures.len() > 0 {
383             println!("\n{} command(s) did not execute successfully:\n", failures.len());
384             for failure in failures.iter() {
385                 println!("  - {}\n", failure);
386             }
387             process::exit(1);
388         }
389     }
390
391     /// Clear out `dir` if `input` is newer.
392     ///
393     /// After this executes, it will also ensure that `dir` exists.
394     fn clear_if_dirty(&self, dir: &Path, input: &Path) -> bool {
395         let stamp = dir.join(".stamp");
396         let mut cleared = false;
397         if mtime(&stamp) < mtime(input) {
398             self.verbose(&format!("Dirty - {}", dir.display()));
399             let _ = fs::remove_dir_all(dir);
400             cleared = true;
401         } else if stamp.exists() {
402             return cleared;
403         }
404         t!(fs::create_dir_all(dir));
405         t!(File::create(stamp));
406         cleared
407     }
408
409     /// Get the space-separated set of activated features for the standard
410     /// library.
411     fn std_features(&self) -> String {
412         let mut features = "panic-unwind".to_string();
413
414         if self.config.debug_jemalloc {
415             features.push_str(" debug-jemalloc");
416         }
417         if self.config.use_jemalloc {
418             features.push_str(" jemalloc");
419         }
420         if self.config.backtrace {
421             features.push_str(" backtrace");
422         }
423         if self.config.profiler {
424             features.push_str(" profiler");
425         }
426         features
427     }
428
429     /// Get the space-separated set of activated features for the compiler.
430     fn rustc_features(&self) -> String {
431         let mut features = String::new();
432         if self.config.use_jemalloc {
433             features.push_str(" jemalloc");
434         }
435         features
436     }
437
438     /// Component directory that Cargo will produce output into (e.g.
439     /// release/debug)
440     fn cargo_dir(&self) -> &'static str {
441         if self.config.rust_optimize {"release"} else {"debug"}
442     }
443
444     fn tools_dir(&self, compiler: Compiler) -> PathBuf {
445         let out = self.out.join(&*compiler.host).join(format!("stage{}-tools-bin", compiler.stage));
446         t!(fs::create_dir_all(&out));
447         out
448     }
449
450     /// Returns the root directory for all output generated in a particular
451     /// stage when running with a particular host compiler.
452     ///
453     /// The mode indicates what the root directory is for.
454     fn stage_out(&self, compiler: Compiler, mode: Mode) -> PathBuf {
455         let suffix = match mode {
456             Mode::Libstd => "-std",
457             Mode::Libtest => "-test",
458             Mode::Tool => "-tools",
459             Mode::Librustc => "-rustc",
460         };
461         self.out.join(&*compiler.host)
462                 .join(format!("stage{}{}", compiler.stage, suffix))
463     }
464
465     /// Returns the root output directory for all Cargo output in a given stage,
466     /// running a particular compiler, whether or not we're building the
467     /// standard library, and targeting the specified architecture.
468     fn cargo_out(&self,
469                  compiler: Compiler,
470                  mode: Mode,
471                  target: Interned<String>) -> PathBuf {
472         self.stage_out(compiler, mode).join(&*target).join(self.cargo_dir())
473     }
474
475     /// Root output directory for LLVM compiled for `target`
476     ///
477     /// Note that if LLVM is configured externally then the directory returned
478     /// will likely be empty.
479     fn llvm_out(&self, target: Interned<String>) -> PathBuf {
480         self.out.join(&*target).join("llvm")
481     }
482
483     fn emscripten_llvm_out(&self, target: Interned<String>) -> PathBuf {
484         self.out.join(&*target).join("llvm-emscripten")
485     }
486
487     /// Output directory for all documentation for a target
488     fn doc_out(&self, target: Interned<String>) -> PathBuf {
489         self.out.join(&*target).join("doc")
490     }
491
492     /// Output directory for some generated md crate documentation for a target (temporary)
493     fn md_doc_out(&self, target: Interned<String>) -> Interned<PathBuf> {
494         INTERNER.intern_path(self.out.join(&*target).join("md-doc"))
495     }
496
497     /// Output directory for all crate documentation for a target (temporary)
498     ///
499     /// The artifacts here are then copied into `doc_out` above.
500     fn crate_doc_out(&self, target: Interned<String>) -> PathBuf {
501         self.out.join(&*target).join("crate-docs")
502     }
503
504     /// Returns true if no custom `llvm-config` is set for the specified target.
505     ///
506     /// If no custom `llvm-config` was specified then Rust's llvm will be used.
507     fn is_rust_llvm(&self, target: Interned<String>) -> bool {
508         match self.config.target_config.get(&target) {
509             Some(ref c) => c.llvm_config.is_none(),
510             None => true
511         }
512     }
513
514     /// Returns the path to `llvm-config` for the specified target.
515     ///
516     /// If a custom `llvm-config` was specified for target then that's returned
517     /// instead.
518     fn llvm_config(&self, target: Interned<String>) -> PathBuf {
519         let target_config = self.config.target_config.get(&target);
520         if let Some(s) = target_config.and_then(|c| c.llvm_config.as_ref()) {
521             s.clone()
522         } else {
523             self.llvm_out(self.config.build).join("bin")
524                 .join(exe("llvm-config", &*target))
525         }
526     }
527
528     /// Returns the path to `FileCheck` binary for the specified target
529     fn llvm_filecheck(&self, target: Interned<String>) -> PathBuf {
530         let target_config = self.config.target_config.get(&target);
531         if let Some(s) = target_config.and_then(|c| c.llvm_config.as_ref()) {
532             let llvm_bindir = output(Command::new(s).arg("--bindir"));
533             Path::new(llvm_bindir.trim()).join(exe("FileCheck", &*target))
534         } else {
535             let base = self.llvm_out(self.config.build).join("build");
536             let exe = exe("FileCheck", &*target);
537             if !self.config.ninja && self.config.build.contains("msvc") {
538                 base.join("Release/bin").join(exe)
539             } else {
540                 base.join("bin").join(exe)
541             }
542         }
543     }
544
545     /// Directory for libraries built from C/C++ code and shared between stages.
546     fn native_dir(&self, target: Interned<String>) -> PathBuf {
547         self.out.join(&*target).join("native")
548     }
549
550     /// Root output directory for rust_test_helpers library compiled for
551     /// `target`
552     fn test_helpers_out(&self, target: Interned<String>) -> PathBuf {
553         self.native_dir(target).join("rust-test-helpers")
554     }
555
556     /// Adds the `RUST_TEST_THREADS` env var if necessary
557     fn add_rust_test_threads(&self, cmd: &mut Command) {
558         if env::var_os("RUST_TEST_THREADS").is_none() {
559             cmd.env("RUST_TEST_THREADS", self.jobs().to_string());
560         }
561     }
562
563     /// Returns the libdir of the snapshot compiler.
564     fn rustc_snapshot_libdir(&self) -> PathBuf {
565         self.initial_rustc.parent().unwrap().parent().unwrap()
566             .join(libdir(&self.config.build))
567     }
568
569     /// Runs a command, printing out nice contextual information if it fails.
570     fn run(&self, cmd: &mut Command) {
571         self.verbose(&format!("running: {:?}", cmd));
572         run_silent(cmd)
573     }
574
575     /// Runs a command, printing out nice contextual information if it fails.
576     fn run_quiet(&self, cmd: &mut Command) {
577         self.verbose(&format!("running: {:?}", cmd));
578         run_suppressed(cmd)
579     }
580
581     /// Runs a command, printing out nice contextual information if it fails.
582     /// Exits if the command failed to execute at all, otherwise returns its
583     /// `status.success()`.
584     fn try_run(&self, cmd: &mut Command) -> bool {
585         self.verbose(&format!("running: {:?}", cmd));
586         try_run_silent(cmd)
587     }
588
589     /// Runs a command, printing out nice contextual information if it fails.
590     /// Exits if the command failed to execute at all, otherwise returns its
591     /// `status.success()`.
592     fn try_run_quiet(&self, cmd: &mut Command) -> bool {
593         self.verbose(&format!("running: {:?}", cmd));
594         try_run_suppressed(cmd)
595     }
596
597     pub fn is_verbose(&self) -> bool {
598         self.verbosity > 0
599     }
600
601     pub fn is_very_verbose(&self) -> bool {
602         self.verbosity > 1
603     }
604
605     /// Prints a message if this build is configured in verbose mode.
606     fn verbose(&self, msg: &str) {
607         if self.is_verbose() {
608             println!("{}", msg);
609         }
610     }
611
612     /// Returns the number of parallel jobs that have been configured for this
613     /// build.
614     fn jobs(&self) -> u32 {
615         self.config.jobs.unwrap_or_else(|| num_cpus::get() as u32)
616     }
617
618     /// Returns the path to the C compiler for the target specified.
619     fn cc(&self, target: Interned<String>) -> &Path {
620         self.cc[&target].path()
621     }
622
623     /// Returns a list of flags to pass to the C compiler for the target
624     /// specified.
625     fn cflags(&self, target: Interned<String>) -> Vec<String> {
626         // Filter out -O and /O (the optimization flags) that we picked up from
627         // cc-rs because the build scripts will determine that for themselves.
628         let mut base = self.cc[&target].args().iter()
629                            .map(|s| s.to_string_lossy().into_owned())
630                            .filter(|s| !s.starts_with("-O") && !s.starts_with("/O"))
631                            .collect::<Vec<_>>();
632
633         // If we're compiling on macOS then we add a few unconditional flags
634         // indicating that we want libc++ (more filled out than libstdc++) and
635         // we want to compile for 10.7. This way we can ensure that
636         // LLVM/jemalloc/etc are all properly compiled.
637         if target.contains("apple-darwin") {
638             base.push("-stdlib=libc++".into());
639         }
640
641         // Work around an apparently bad MinGW / GCC optimization,
642         // See: http://lists.llvm.org/pipermail/cfe-dev/2016-December/051980.html
643         // See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78936
644         if &*target == "i686-pc-windows-gnu" {
645             base.push("-fno-omit-frame-pointer".into());
646         }
647         base
648     }
649
650     /// Returns the path to the `ar` archive utility for the target specified.
651     fn ar(&self, target: Interned<String>) -> Option<&Path> {
652         self.ar.get(&target).map(|p| &**p)
653     }
654
655     /// Returns the path to the C++ compiler for the target specified.
656     fn cxx(&self, target: Interned<String>) -> Result<&Path, String> {
657         match self.cxx.get(&target) {
658             Some(p) => Ok(p.path()),
659             None => Err(format!(
660                     "target `{}` is not configured as a host, only as a target",
661                     target))
662         }
663     }
664
665     /// Returns the path to the linker for the given target if it needs to be overriden.
666     fn linker(&self, target: Interned<String>) -> Option<&Path> {
667         if let Some(linker) = self.config.target_config.get(&target)
668                                                        .and_then(|c| c.linker.as_ref()) {
669             Some(linker)
670         } else if target != self.config.build &&
671                   !target.contains("msvc") && !target.contains("emscripten") {
672             Some(self.cc(target))
673         } else {
674             None
675         }
676     }
677
678     /// Returns if this target should statically link the C runtime, if specified
679     fn crt_static(&self, target: Interned<String>) -> Option<bool> {
680         if target.contains("pc-windows-msvc") {
681             Some(true)
682         } else {
683             self.config.target_config.get(&target)
684                 .and_then(|t| t.crt_static)
685         }
686     }
687
688     /// Returns the "musl root" for this `target`, if defined
689     fn musl_root(&self, target: Interned<String>) -> Option<&Path> {
690         self.config.target_config.get(&target)
691             .and_then(|t| t.musl_root.as_ref())
692             .or(self.config.musl_root.as_ref())
693             .map(|p| &**p)
694     }
695
696     /// Returns whether the target will be tested using the `remote-test-client`
697     /// and `remote-test-server` binaries.
698     fn remote_tested(&self, target: Interned<String>) -> bool {
699         self.qemu_rootfs(target).is_some() || target.contains("android") ||
700         env::var_os("TEST_DEVICE_ADDR").is_some()
701     }
702
703     /// Returns the root of the "rootfs" image that this target will be using,
704     /// if one was configured.
705     ///
706     /// If `Some` is returned then that means that tests for this target are
707     /// emulated with QEMU and binaries will need to be shipped to the emulator.
708     fn qemu_rootfs(&self, target: Interned<String>) -> Option<&Path> {
709         self.config.target_config.get(&target)
710             .and_then(|t| t.qemu_rootfs.as_ref())
711             .map(|p| &**p)
712     }
713
714     /// Path to the python interpreter to use
715     fn python(&self) -> &Path {
716         self.config.python.as_ref().unwrap()
717     }
718
719     /// Temporary directory that extended error information is emitted to.
720     fn extended_error_dir(&self) -> PathBuf {
721         self.out.join("tmp/extended-error-metadata")
722     }
723
724     /// Tests whether the `compiler` compiling for `target` should be forced to
725     /// use a stage1 compiler instead.
726     ///
727     /// Currently, by default, the build system does not perform a "full
728     /// bootstrap" by default where we compile the compiler three times.
729     /// Instead, we compile the compiler two times. The final stage (stage2)
730     /// just copies the libraries from the previous stage, which is what this
731     /// method detects.
732     ///
733     /// Here we return `true` if:
734     ///
735     /// * The build isn't performing a full bootstrap
736     /// * The `compiler` is in the final stage, 2
737     /// * We're not cross-compiling, so the artifacts are already available in
738     ///   stage1
739     ///
740     /// When all of these conditions are met the build will lift artifacts from
741     /// the previous stage forward.
742     fn force_use_stage1(&self, compiler: Compiler, target: Interned<String>) -> bool {
743         !self.config.full_bootstrap &&
744             compiler.stage >= 2 &&
745             (self.hosts.iter().any(|h| *h == target) || target == self.build)
746     }
747
748     /// Returns the directory that OpenSSL artifacts are compiled into if
749     /// configured to do so.
750     fn openssl_dir(&self, target: Interned<String>) -> Option<PathBuf> {
751         // OpenSSL not used on Windows
752         if target.contains("windows") {
753             None
754         } else if self.config.openssl_static {
755             Some(self.out.join(&*target).join("openssl"))
756         } else {
757             None
758         }
759     }
760
761     /// Returns the directory that OpenSSL artifacts are installed into if
762     /// configured as such.
763     fn openssl_install_dir(&self, target: Interned<String>) -> Option<PathBuf> {
764         self.openssl_dir(target).map(|p| p.join("install"))
765     }
766
767     /// Given `num` in the form "a.b.c" return a "release string" which
768     /// describes the release version number.
769     ///
770     /// For example on nightly this returns "a.b.c-nightly", on beta it returns
771     /// "a.b.c-beta.1" and on stable it just returns "a.b.c".
772     fn release(&self, num: &str) -> String {
773         match &self.config.channel[..] {
774             "stable" => num.to_string(),
775             "beta" => if self.rust_info.is_git() {
776                 format!("{}-beta.{}", num, self.beta_prerelease_version())
777             } else {
778                 format!("{}-beta", num)
779             },
780             "nightly" => format!("{}-nightly", num),
781             _ => format!("{}-dev", num),
782         }
783     }
784
785     fn beta_prerelease_version(&self) -> u32 {
786         if let Some(s) = self.prerelease_version.get() {
787             return s
788         }
789
790         let beta = output(
791             Command::new("git")
792                 .arg("ls-remote")
793                 .arg("origin")
794                 .arg("beta")
795                 .current_dir(&self.src)
796         );
797         let beta = beta.trim().split_whitespace().next().unwrap();
798         let master = output(
799             Command::new("git")
800                 .arg("ls-remote")
801                 .arg("origin")
802                 .arg("master")
803                 .current_dir(&self.src)
804         );
805         let master = master.trim().split_whitespace().next().unwrap();
806
807         // Figure out where the current beta branch started.
808         let base = output(
809             Command::new("git")
810                 .arg("merge-base")
811                 .arg(beta)
812                 .arg(master)
813                 .current_dir(&self.src),
814         );
815         let base = base.trim();
816
817         // Next figure out how many merge commits happened since we branched off
818         // beta. That's our beta number!
819         let count = output(
820             Command::new("git")
821                 .arg("rev-list")
822                 .arg("--count")
823                 .arg("--merges")
824                 .arg(format!("{}...HEAD", base))
825                 .current_dir(&self.src),
826         );
827         let n = count.trim().parse().unwrap();
828         self.prerelease_version.set(Some(n));
829         n
830     }
831
832     /// Returns the value of `release` above for Rust itself.
833     fn rust_release(&self) -> String {
834         self.release(channel::CFG_RELEASE_NUM)
835     }
836
837     /// Returns the "package version" for a component given the `num` release
838     /// number.
839     ///
840     /// The package version is typically what shows up in the names of tarballs.
841     /// For channels like beta/nightly it's just the channel name, otherwise
842     /// it's the `num` provided.
843     fn package_vers(&self, num: &str) -> String {
844         match &self.config.channel[..] {
845             "stable" => num.to_string(),
846             "beta" => "beta".to_string(),
847             "nightly" => "nightly".to_string(),
848             _ => format!("{}-dev", num),
849         }
850     }
851
852     /// Returns the value of `package_vers` above for Rust itself.
853     fn rust_package_vers(&self) -> String {
854         self.package_vers(channel::CFG_RELEASE_NUM)
855     }
856
857     /// Returns the value of `package_vers` above for Cargo
858     fn cargo_package_vers(&self) -> String {
859         self.package_vers(&self.release_num("cargo"))
860     }
861
862     /// Returns the value of `package_vers` above for rls
863     fn rls_package_vers(&self) -> String {
864         self.package_vers(&self.release_num("rls"))
865     }
866
867     /// Returns the value of `package_vers` above for rustfmt
868     fn rustfmt_package_vers(&self) -> String {
869         self.package_vers(&self.release_num("rustfmt"))
870     }
871
872     /// Returns the `version` string associated with this compiler for Rust
873     /// itself.
874     ///
875     /// Note that this is a descriptive string which includes the commit date,
876     /// sha, version, etc.
877     fn rust_version(&self) -> String {
878         self.rust_info.version(self, channel::CFG_RELEASE_NUM)
879     }
880
881     /// Return the full commit hash
882     fn rust_sha(&self) -> Option<&str> {
883         self.rust_info.sha()
884     }
885
886     /// Returns the `a.b.c` version that the given package is at.
887     fn release_num(&self, package: &str) -> String {
888         let mut toml = String::new();
889         let toml_file_name = self.src.join(&format!("src/tools/{}/Cargo.toml", package));
890         t!(t!(File::open(toml_file_name)).read_to_string(&mut toml));
891         for line in toml.lines() {
892             let prefix = "version = \"";
893             let suffix = "\"";
894             if line.starts_with(prefix) && line.ends_with(suffix) {
895                 return line[prefix.len()..line.len() - suffix.len()].to_string()
896             }
897         }
898
899         panic!("failed to find version in {}'s Cargo.toml", package)
900     }
901
902     /// Returns whether unstable features should be enabled for the compiler
903     /// we're building.
904     fn unstable_features(&self) -> bool {
905         match &self.config.channel[..] {
906             "stable" | "beta" => false,
907             "nightly" | _ => true,
908         }
909     }
910
911     /// Fold the output of the commands after this method into a group. The fold
912     /// ends when the returned object is dropped. Folding can only be used in
913     /// the Travis CI environment.
914     pub fn fold_output<D, F>(&self, name: F) -> Option<OutputFolder>
915         where D: Into<String>, F: FnOnce() -> D
916     {
917         if self.ci_env == CiEnv::Travis {
918             Some(OutputFolder::new(name().into()))
919         } else {
920             None
921         }
922     }
923
924     /// Updates the actual toolstate of a tool.
925     ///
926     /// The toolstates are saved to the file specified by the key
927     /// `rust.save-toolstates` in `config.toml`. If unspecified, nothing will be
928     /// done. The file is updated immediately after this function completes.
929     pub fn save_toolstate(&self, tool: &str, state: ToolState) {
930         use std::io::{Seek, SeekFrom};
931
932         if let Some(ref path) = self.config.save_toolstates {
933             let mut file = t!(fs::OpenOptions::new()
934                 .create(true)
935                 .read(true)
936                 .write(true)
937                 .open(path));
938
939             let mut current_toolstates: HashMap<Box<str>, ToolState> =
940                 serde_json::from_reader(&mut file).unwrap_or_default();
941             current_toolstates.insert(tool.into(), state);
942             t!(file.seek(SeekFrom::Start(0)));
943             t!(file.set_len(0));
944             t!(serde_json::to_writer(file, &current_toolstates));
945         }
946     }
947
948     /// Get a list of crates from a root crate.
949     ///
950     /// Returns Vec<(crate, path to crate, is_root_crate)>
951     fn crates(&self, root: &str) -> Vec<(Interned<String>, &Path)> {
952         let interned = INTERNER.intern_string(root.to_owned());
953         let mut ret = Vec::new();
954         let mut list = vec![interned];
955         let mut visited = HashSet::new();
956         while let Some(krate) = list.pop() {
957             let krate = &self.crates[&krate];
958             // If we can't strip prefix, then out-of-tree path
959             let path = krate.path.strip_prefix(&self.src).unwrap_or(&krate.path);
960             ret.push((krate.name, path));
961             for dep in &krate.deps {
962                 if visited.insert(dep) && dep != "build_helper" {
963                     list.push(*dep);
964                 }
965             }
966         }
967         ret
968     }
969 }
970
971 impl<'a> Compiler {
972     pub fn with_stage(mut self, stage: u32) -> Compiler {
973         self.stage = stage;
974         self
975     }
976
977     /// Returns whether this is a snapshot compiler for `build`'s configuration
978     pub fn is_snapshot(&self, build: &Build) -> bool {
979         self.stage == 0 && self.host == build.build
980     }
981
982     /// Returns if this compiler should be treated as a final stage one in the
983     /// current build session.
984     /// This takes into account whether we're performing a full bootstrap or
985     /// not; don't directly compare the stage with `2`!
986     pub fn is_final_stage(&self, build: &Build) -> bool {
987         let final_stage = if build.config.full_bootstrap { 2 } else { 1 };
988         self.stage >= final_stage
989     }
990 }