3. Build and install:
```sh
- $ ./configure
- $ make && make install
+ $ ./x.py build && sudo ./x.py dist --install
```
- > ***Note:*** You may need to use `sudo make install` if you do not
- > normally have permission to modify the destination directory. The
- > install locations can be adjusted by passing a `--prefix` argument
- > to `configure`. Various other options are also supported – pass
- > `--help` for more information on them.
+ > ***Note:*** Install locations can be adjusted by copying the config file
+ > from `./src/bootstrap/config.toml.example` to `./config.toml`, and
+ > adjusting the `prefix` option under `[install]`. Various other options are
+ > also supported, and are documented in the config file.
- When complete, `make install` will place several programs into
+ When complete, `sudo ./x.py dist --install` will place several programs into
`/usr/local/bin`: `rustc`, the Rust compiler, and `rustdoc`, the
API-documentation tool. This install does not include [Cargo],
Rust's package manager, which you may also want to build.
for interop with GNU software built using the MinGW/MSYS2 toolchain use the GNU
build.
-
#### MinGW
[MSYS2][msys2] can be used to easily build Rust on Windows:
# Install build tools needed for Rust. If you're building a 32-bit compiler,
# then replace "x86_64" below with "i686". If you've already got git, python,
# or CMake installed and in PATH you can remove them from this list. Note
- # that it is important that the `python2` and `cmake` packages **not** used.
- # The build has historically been known to fail with these packages.
+ # that it is important that you do **not** use the 'python2' and 'cmake'
+ # packages from the 'msys2' subsystem. The build has historically been known
+ # to fail with these packages.
$ pacman -S git \
make \
diffutils \
mingw-w64-x86_64-gcc
```
-4. Navigate to Rust's source code (or clone it), then configure and build it:
+4. Navigate to Rust's source code (or clone it), then build it:
```sh
- $ ./configure
- $ make && make install
+ $ ./x.py build && ./x.py dist --install
```
#### MSVC
(or later) so `rustc` can use its linker. Make sure to check the “C++ tools”
option.
-With these dependencies installed, the build takes two steps:
+With these dependencies installed, you can build the compiler in a `cmd.exe`
+shell with:
```sh
-$ ./configure
-$ make && make install
+> python x.py build
```
-#### MSVC with rustbuild
-
-The old build system, based on makefiles, is currently being rewritten into a
-Rust-based build system called rustbuild. This can be used to bootstrap the
-compiler on MSVC without needing to install MSYS or MinGW. All you need are
-[Python 2](https://www.python.org/downloads/),
-[CMake](https://cmake.org/download/), and
-[Git](https://git-scm.com/downloads) in your PATH (make sure you do not use the
-ones from MSYS if you have it installed). You'll also need Visual Studio 2013 or
-newer with the C++ tools. Then all you need to do is to kick off rustbuild.
-
-```
-python x.py build
-```
-
-Currently rustbuild only works with some known versions of Visual Studio. If you
-have a more recent version installed that a part of rustbuild doesn't understand
+Currently building Rust only works with some known versions of Visual Studio. If
+you have a more recent version installed the build system doesn't understand
then you may need to force rustbuild to use an older version. This can be done
by manually calling the appropriate vcvars file before running the bootstrap.
python x.py build
```
-## Building Documentation
+#### Specifying an ABI
-If you’d like to build the documentation, it’s almost the same:
+Each specific ABI can also be used from either environment (for example, using
+the GNU ABI in powershell) by using an explicit build triple. The available
+Windows build triples are:
+- GNU ABI (using GCC)
+ - `i686-pc-windows-gnu`
+ - `x86_64-pc-windows-gnu`
+- The MSVC ABI
+ - `i686-pc-windows-msvc`
+ - `x86_64-pc-windows-msvc`
+
+The build triple can be specified by either specifying `--build=ABI` when
+invoking `x.py` commands, or by copying the `config.toml` file (as described
+in Building From Source), and modifying the `build` option under the `[build]`
+section.
+
+### Configure and Make
+
+While it's not the recommended build system, this project also provides a
+configure script and makefile (the latter of which just invokes `x.py`).
```sh
$ ./configure
-$ make docs
+$ make && sudo make install
```
-Building the documentation requires building the compiler, so the above
-details will apply. Once you have the compiler built, you can
+When using the configure script, the generated `config.mk` file may override the
+`config.toml` file. To go back to the `config.toml` file, delete the generated
+`config.mk` file.
+
+## Building Documentation
+
+If you’d like to build the documentation, it’s almost the same:
```sh
-$ make docs NO_REBUILD=1
+$ ./x.py doc
```
-To make sure you don’t re-build the compiler because you made a change
-to some documentation.
-
The generated documentation will appear in a top-level `doc` directory,
created by the `make` rule.
projects / rust.git / blobdiff