OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replace ./configure with config.toml in README.md and CONTRIBUTING.md

Browse Source
This commit is contained in:
Josh Driver 2017-02-23 21:15:30 +10:30
parent bfe45974a1
commit fb2d763eee
2 changed files with 71 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
CONTRIBUTING.md
View File

@ -97,33 +97,38 @@ system internals, try asking in [`#rust-internals`][pound-rust-internals].
Before you can start building the compiler you need to configure the build for
your system. In most cases, that will just mean using the defaults provided
for Rust. Configuring involves invoking the `configure` script in the project
root.
for Rust.
```
./configure
```
To change configuration, you must copy the file `src/bootstrap/config.toml.example`
to `config.toml` in the directory from which you will be running the build, and
change the settings provided.
There are large number of options accepted by this script to alter the
configuration used later in the build process. Some options to note:
There are large number of options provided in this config file that will alter the
configuration used in the build process. Some options to note:
- `--enable-debug` - Build a debug version of the compiler (disables optimizations,
which speeds up compilation of stage1 rustc)
- `--enable-optimize` - Enable optimizations (can be used with `--enable-debug`
to make a debug build with optimizations)
- `--disable-valgrind-rpass` - Don't run tests with valgrind
- `--enable-clang` - Prefer clang to gcc for building dependencies (e.g., LLVM)
- `--enable-ccache` - Invoke clang/gcc with ccache to re-use object files between builds
- `--enable-compiler-docs` - Build compiler documentation
#### `[llvm]`:
- `ccache = true` - Use ccache when building llvm
To see a full list of options, run `./configure --help`.
#### `[build]`:
- `compiler-docs = true` - Build compiler documentation
#### `[rust]`:
- `debuginfo = true` - Build a compiler with debuginfo
- `optimize = false` - Disable optimizations to speed up compilation of stage1 rust
For more options, the `config.toml` file contains commented out defaults, with
descriptions of what each option will do.
Note: Previously the `./configure` script was used to configure this
project. It can still be used, but it's recommended to use a `config.toml`
file. If you still have a `config.mk` file in your directory - from
`./configure` - you may need to delete it for `config.toml` to work.
### Building
Although the `./configure` script will generate a `Makefile`, this is actually
just a thin veneer over the actual build system driver, `x.py`. This file, at
the root of the repository, is used to build, test, and document various parts
of the compiler. You can execute it as:
The build system uses the `x.py` script to control the build process. This script
is used to build, test, and document various parts of the compiler. You can
execute it as:
```sh
python x.py build
@ -185,6 +190,9 @@ To learn about all possible rules you can execute, run:
python x.py build --help --verbose
```
Note: Previously `./configure` and `make` were used to build this project.
They are still available, but `x.py` is the recommended build system.
### Useful commands
Some common invocations of `x.py` are:
@ -235,8 +243,8 @@ feature. We use the 'fork and pull' model described there.
Please make pull requests against the `master` branch.
Compiling all of `make check` can take a while. When testing your pull request,
consider using one of the more specialized `make` targets to cut down on the
Compiling all of `./x.py test` can take a while. When testing your pull request,
consider using one of the more specialized `./x.py` targets to cut down on the
amount of time you have to wait. You need to have built the compiler at least
once before running these will work, but that’s only one full build rather than
one each time.
@ -307,7 +315,7 @@ To find documentation-related issues, sort by the [A-docs label][adocs].
[adocs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-docs
In many cases, you don't need a full `make doc`. You can use `rustdoc` directly
In many cases, you don't need a full `./x.py doc`. You can use `rustdoc` directly
to check small fixes. For example, `rustdoc src/doc/reference.md` will render
reference to `doc/reference.html`. The CSS might be messed up, but you can
verify that the HTML is right.

59
README.md
View File

@ -35,15 +35,15 @@ Read ["Installing Rust"] from [The Book].
3. Build and install:
```sh
$ ./configure
$ make && sudo make install
$ ./x.py build && sudo ./x.py dist --install
```
> ***Note:*** 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, `sudo 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.
@ -59,7 +59,6 @@ for interop with software produced by Visual Studio use the MSVC build of Rust;
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:
@ -94,11 +93,10 @@ build.
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
@ -114,13 +112,6 @@ shell with:
> python x.py build
```
If you're running inside of an msys shell, however, you can run:
```sh
$ ./configure --build=x86_64-pc-windows-msvc
$ make && make install
```
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
@ -131,13 +122,43 @@ CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\bin\amd64\vcvars64.
python x.py build
```
#### Specifying an ABI
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 && sudo make install
```
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
$ ./configure
$ make docs
$ ./x.py doc
```
The generated documentation will appear in a top-level `doc` directory,