1 # rustbuild - Bootstrapping Rust
3 This is an in-progress README which is targeted at helping to explain how Rust
4 is bootstrapped and in general some of the technical details of the build
9 The rustbuild build system has a primary entry point, a top level `x.py` script:
15 Note that if you're on Unix you should be able to execute the script directly:
21 The script accepts commands, flags, and arguments to determine what to do:
23 * `build` - a general purpose command for compiling code. Alone `build` will
24 bootstrap the entire compiler, and otherwise arguments passed indicate what to
28 # build the whole compiler
31 # build the stage1 compiler
32 ./x.py build --stage 1
35 ./x.py build --stage 0 src/libstd
37 # build a particular crate in stage0
38 ./x.py build --stage 0 src/libtest
41 If files are dirty that would normally be rebuilt from stage 0, that can be
42 overridden using `--keep-stage 0`. Using `--keep-stage n` will skip all steps
43 that belong to stage n or earlier:
46 # keep old build products for stage 0 and build stage 1
47 ./x.py build --keep-stage 0 --stage 1
50 * `test` - a command for executing unit tests. Like the `build` command this
51 will execute the entire test suite by default, and otherwise it can be used to
52 select which test suite is run:
58 # execute the run-pass test suite
59 ./x.py test src/test/run-pass
61 # execute only some tests in the run-pass test suite
62 ./x.py test src/test/run-pass --test-args substring-of-test-name
64 # execute tests in the standard library in stage0
65 ./x.py test --stage 0 src/libstd
67 # execute tests in the core and standard library in stage0,
68 # without running doc tests (thus avoid depending on building the compiler)
69 ./x.py test --stage 0 --no-doc src/libcore src/libstd
71 # execute all doc tests
75 * `doc` - a command for building documentation. Like above can take arguments
78 ## Configuring rustbuild
80 There are currently two methods for configuring the rustbuild build system.
82 First, rustbuild offers a TOML-based configuration system with a `config.toml`
83 file. An example of this configuration can be found at `config.toml.example`,
84 and the configuration file can also be passed as `--config path/to/config.toml`
85 if the build system is being invoked manually (via the python script).
87 Next, the `./configure` options serialized in `config.mk` will be
88 parsed and read. That is, if any `./configure` options are passed, they'll be
89 handled naturally. `./configure` should almost never be used for local
90 installations, and is primarily useful for CI. Prefer to customize behavior
93 Finally, rustbuild makes use of the [gcc-rs crate] which has [its own
94 method][env-vars] of configuring C compilers and C flags via environment
97 [gcc-rs crate]: https://github.com/alexcrichton/gcc-rs
98 [env-vars]: https://github.com/alexcrichton/gcc-rs#external-configuration-via-environment-variables
102 The rustbuild build system goes through a few phases to actually build the
103 compiler. What actually happens when you invoke rustbuild is:
105 1. The entry point script, `x.py` is run. This script is
106 responsible for downloading the stage0 compiler/Cargo binaries, and it then
107 compiles the build system itself (this folder). Finally, it then invokes the
108 actual `bootstrap` binary build system.
109 2. In Rust, `bootstrap` will slurp up all configuration, perform a number of
110 sanity checks (compilers exist for example), and then start building the
112 3. The stage0 `cargo` downloaded earlier is used to build the standard library
113 and the compiler, and then these binaries are then copied to the `stage1`
114 directory. That compiler is then used to generate the stage1 artifacts which
115 are then copied to the stage2 directory, and then finally the stage2
116 artifacts are generated using that compiler.
118 The goal of each stage is to (a) leverage Cargo as much as possible and failing
119 that (b) leverage Rust as much as possible!
121 ## Incremental builds
123 You can configure rustbuild to use incremental compilation. Because
124 incremental is new and evolving rapidly, if you want to use it, it is
125 recommended that you replace the snapshot with a locally installed
126 nightly build of rustc. You will want to keep this up to date.
128 To follow this course of action, first thing you will want to do is to
129 install a nightly, presumably using `rustup`. You will then want to
130 configure your directory to use this build, like so:
133 # configure to use local rust instead of downloading a beta.
134 # `--local-rust-root` is optional here. If elided, we will
135 # use whatever rustc we find on your PATH.
136 > ./configure --local-rust-root=~/.cargo/ --enable-local-rebuild
139 After that, you can use the `--incremental` flag to actually do
143 > ./x.py build --incremental
146 The `--incremental` flag will store incremental compilation artifacts
147 in `build/<host>/stage0-incremental`. Note that we only use incremental
148 compilation for the stage0 -> stage1 compilation -- this is because
149 the stage1 compiler is changing, and we don't try to cache and reuse
150 incremental artifacts across different versions of the compiler. For
151 this reason, `--incremental` defaults to `--stage 1` (though you can
152 manually select a higher stage, if you prefer).
154 You can always drop the `--incremental` to build as normal (but you
155 will still be using the local nightly as your bootstrap).
159 This build system houses all output under the `build` directory, which looks
163 # Root folder of all output. Everything is scoped underneath here
166 # Location where the stage0 compiler downloads are all cached. This directory
167 # only contains the tarballs themselves as they're extracted elsewhere.
174 # Output directory for building this build system itself. The stage0
175 # cargo/rustc are used to build the build system into this location.
180 # Output of the dist-related steps like dist-std, dist-rustc, and dist-docs
183 # Temporary directory used for various input/output as part of various stages
186 # Each remaining directory is scoped by the "host" triple of compilation at
188 x86_64-unknown-linux-gnu/
190 # The build artifacts for the `compiler-rt` library for the target this
191 # folder is under. The exact layout here will likely depend on the platform,
192 # and this is also built with CMake so the build system is also likely
197 # Output folder for LLVM if it is compiled for this target
200 # build folder (e.g. the platform-specific build system). Like with
201 # compiler-rt this is compiled with CMake
204 # Installation of LLVM. Note that we run the equivalent of 'make install'
205 # for LLVM to setup these folders.
212 # Output folder for all documentation of this target. This is what's filled
213 # in whenever the `doc` step is run.
216 # Output for all compiletest-based test suites
223 # Location where the stage0 Cargo and Rust compiler are unpacked. This
224 # directory is purely an extracted and overlaid tarball of these two (done
225 # by the bootstrapy python script). In theory the build system does not
226 # modify anything under this directory afterwards.
229 # These to build directories are the cargo output directories for builds of
230 # the standard library and compiler, respectively. Internally these may also
231 # have other target directories, which represent artifacts being compiled
232 # from the host to the specified target.
234 # Essentially, each of these directories is filled in by one `cargo`
235 # invocation. The build system instruments calling Cargo in the right order
236 # with the right variables to ensure these are filled in correctly.
242 # This is a special case of the above directories, **not** filled in via
243 # Cargo but rather the build system itself. The stage0 compiler already has
244 # a set of target libraries for its own host triple (in its own sysroot)
245 # inside of stage0/. When we run the stage0 compiler to bootstrap more
246 # things, however, we don't want to use any of these libraries (as those are
247 # the ones that we're building). So essentially, when the stage1 compiler is
248 # being compiled (e.g. after libstd has been built), *this* is used as the
249 # sysroot for the stage0 compiler being run.
251 # Basically this directory is just a temporary artifact use to configure the
252 # stage0 compiler to ensure that the libstd we just built is used to
253 # compile the stage1 compiler.
256 # These output directories are intended to be standalone working
257 # implementations of the compiler (corresponding to each stage). The build
258 # system will link (using hard links) output from stageN-{std,rustc} into
259 # each of these directories.
261 # In theory there is no extra build output in these directories.
269 The current build is unfortunately not quite as simple as `cargo build` in a
270 directory, but rather the compiler is split into three different Cargo projects:
272 * `src/libstd` - the standard library
273 * `src/libtest` - testing support, depends on libstd
274 * `src/rustc` - the actual compiler itself
276 Each "project" has a corresponding Cargo.lock file with all dependencies, and
277 this means that building the compiler involves running Cargo three times. The
278 structure here serves two goals:
280 1. Facilitating dependencies coming from crates.io. These dependencies don't
281 depend on `std`, so libstd is a separate project compiled ahead of time
282 before the actual compiler builds.
283 2. Splitting "host artifacts" from "target artifacts". That is, when building
284 code for an arbitrary target you don't need the entire compiler, but you'll
285 end up needing libraries like libtest that depend on std but also want to use
286 crates.io dependencies. Hence, libtest is split out as its own project that
287 is sequenced after `std` but before `rustc`. This project is built for all
290 There is some loss in build parallelism here because libtest can be compiled in
291 parallel with a number of rustc artifacts, but in theory the loss isn't too bad!
295 We've actually got quite a few tools that we use in the compiler's build system
296 and for testing. To organize these, each tool is a project in `src/tools` with a
297 corresponding `Cargo.toml`. All tools are compiled with Cargo (currently having
298 independent `Cargo.lock` files) and do not currently explicitly depend on the
299 compiler or standard library. Compiling each tool is sequenced after the
300 appropriate libstd/libtest/librustc compile above.
302 ## Extending rustbuild
304 So you'd like to add a feature to the rustbuild build system or just fix a bug.
305 Great! One of the major motivational factors for moving away from `make` is that
306 Rust is in theory much easier to read, modify, and write. If you find anything
307 excessively confusing, please open an issue on this and we'll try to get it
308 documented or simplified pronto.
310 First up, you'll probably want to read over the documentation above as that'll
311 give you a high level overview of what rustbuild is doing. You also probably
312 want to play around a bit yourself by just getting it up and running before you
313 dive too much into the actual build system itself.
315 After that, each module in rustbuild should have enough documentation to keep
316 you up and running. Some general areas that you may be interested in modifying
319 * Adding a new build tool? Take a look at `bootstrap/tool.rs` for examples of
321 * Adding a new compiler crate? Look no further! Adding crates can be done by
322 adding a new directory with `Cargo.toml` followed by configuring all
323 `Cargo.toml` files accordingly.
324 * Adding a new dependency from crates.io? This should just work inside the
325 compiler artifacts stage (everything other than libtest and libstd).
326 * Adding a new configuration option? You'll want to modify `bootstrap/flags.rs`
327 for command line flags and then `bootstrap/config.rs` to copy the flags to the
329 * Adding a sanity check? Take a look at `bootstrap/sanity.rs`.
331 If you have any questions feel free to reach out on `#rust-infra` on IRC or ask on
332 internals.rust-lang.org. When you encounter bugs, please file issues on the
333 rust-lang/rust issue tracker.