#### Beyond Linux® From Scratch (System V Edition) - Version 12.3

### Chapter 13. Programming

- Prev

  Ruby-3.4.2

- Next

  rust-bindgen-0.71.1

- Up
- Home

# Rustc-1.85.0

## Introduction to Rust

The Rust programming language is designed to be a safe, concurrent, practical language.

This package is updated on a six-week release cycle. Because it is such a large and slow package to build, is at the moment only required by a few packages in this book, and particularly because newer versions tend to break older mozilla packages, the BLFS editors take the view that it should only be updated when that is necessary (either to fix problems, or to allow a new version of a package to build).

As with many other programming languages, rustc (the rust compiler) needs a binary from which to bootstrap. It will download a stage0 binary at the start of the build, so you cannot compile it without an Internet connection.

### Note

Although BLFS usually installs in `/usr`, when you later upgrade to a newer version of rust the old libraries in `/usr/lib/rustlib` will remain, with various hashes in their names, but will not be usable and will waste space. The editors recommend placing the files in the `/opt` directory. In particular, if you have reason to rebuild with a modified configuration (e.g. using the shipped LLVM after building with shared LLVM, perhaps to compile crates for architectures which the BLFS LLVM build does not support) it is possible for the install to leave a broken cargo program. In such a situation, either remove the existing installation first, or use a different prefix such as /opt/rustc-1.85.0-build2.

If you prefer, you can of course change the prefix to `/usr`.

The current rustbuild build-system will use all processors, although it does not scale well and often falls back to just using one core while waiting for a library to compile. However it can be mostly limited to a specified number of processors by a combination of adding the switch `--jobs <N>` (e.g. '--jobs 4' to limit to 4 processors) on each invocation of ./x.py and using an environment variable `CARGO_BUILD_JOBS=<N>`. At the moment this is not effective when some of the rustc tests are run.

The current version of rust's num_cpus crate now recognizes that cgroups can be used to restrict which processors it is allowed to use. So if your machine lacks DRAM (typically, less than 2 GB DRAM per core) that might be an alternative to taking CPUs offline. Read the section called “Use Linux Control Group to Limit the Resource Usage” for how to use a cgroup.

At the moment Rust does not provide any guarantees of a stable ABI.

### Note

Rustc defaults to building for ALL supported architectures, using a shipped copy of LLVM. In BLFS the build is only for the X86 architecture. If you intend to develop rust crates, this build may not be good enough for your purposes.

The build times of this version when repeated on the same machine are often reasonably consistent, but as with all compilations using rustc there can be some very slow outliers.

This package is known to build and work properly using an LFS 12.3 platform.

### Package Information

- Download (HTTP): https://static.rust-lang.org/dist/rustc-1.85.0-src.tar.xz

- Download MD5 sum: a0193e0a4925f772bd50f8d12e47860c

- Download size: 261 MB

- Estimated disk space required: 9.4 GB (252 MB installed); add 7.4 GB if running the tests

- Estimated build time: 9.0 SBU (including download time; add 15 SBU for tests, both using parallelism=8)

### Rust Dependencies

#### Required

CMake-3.31.5 and cURL-8.12.1

### Note

An Internet connection is needed for building this package. The system certificate store may need to be set up with make-ca-1.15 before building this package.

#### Recommended

libssh2-1.11.1, LLVM-19.1.7 (built with -D LLVM_LINK_LLVM_DYLIB=ON so that rust can link to system LLVM instead of building its shipped version), and SQLite-3.49.1

### Note

If a recommended dependency is not installed, a shipped copy in the Rustc source tarball will be built and used.

#### Optional

GDB-16.2 (used by the test suite if it is present), git-2.48.1 (required by the test suite), cranelift, jemalloc, libgccjit (read command explanation in GCC-14.2.0), and libgit2

Editor Notes: https://wiki.linuxfromscratch.org/blfs/wiki/rust

## Installation of Rust

To install into the `/opt` directory, remove any existing `/opt/rustc` symlink and create a new directory (i.e. with a different name if trying a modified build of the same version). As the `root` user:

    mkdir -pv /opt/rustc-1.85.0      &&
    ln -svfn rustc-1.85.0 /opt/rustc

### Note

If multiple versions of Rust are installed in `/opt`, changing to another version only requires changing the `/opt/rustc` symbolic link and then running ldconfig.

Create a suitable `config.toml` file which will configure the build.

    cat << EOF > config.toml
    # see config.toml.example for more possible options
    # See the 8.4 book for an old example using shipped LLVM
    # e.g. if not installing clang, or using a version before 13.0

    # Tell x.py the editors have reviewed the content of this file
    # and updated it to follow the major changes of the building system,
    # so x.py will not warn us to do such a review.
    change-id = 134650

    [llvm]
    # When using system llvm prefer shared libraries
    link-shared = true

    # Do not download pre-built LLVM, instead either use the system
    # LLVM or build LLVM from the shipped source.
    download-ci-llvm = false

    # If building the shipped LLVM source, only enable the x86 target
    # instead of all the targets supported by LLVM.
    targets = "X86"

    [build]
    # omit docs to save time and space (default is to build them)
    docs = false

    # install extended tools: cargo, clippy, etc
    extended = true

    # Do not query new versions of dependencies online.
    locked-deps = true

    # Specify which extended tools (those from the default install).
    tools = ["cargo", "clippy", "rustdoc", "rustfmt"]

    [install]
    prefix = "/opt/rustc-1.85.0"
    docdir = "share/doc/rustc-1.85.0"

    [rust]
    channel = "stable"
    description = "for BLFS 12.3"

    # Enable the same optimizations as the official upstream build.
    lto = "thin"
    codegen-units = 1

    [target.x86_64-unknown-linux-gnu]
    llvm-config = "/usr/bin/llvm-config"

    [target.i686-unknown-linux-gnu]
    llvm-config = "/usr/bin/llvm-config"
    EOF

Now remove some tests triggering a full rebuild of the Rust standard library and compiler:

    sed '/MirOpt/d' -i src/bootstrap/src/core/builder/mod.rs

Compile Rust by running the following commands:

    [ ! -e /usr/include/libssh2.h ] || export LIBSSH2_SYS_USE_PKG_CONFIG=1
    [ ! -e /usr/include/sqlite3.h ] || export LIBSQLITE3_SYS_USE_PKG_CONFIG=1
    ./x.py build

### Note

The test suite will generate some messages in the system log for traps on invalid opcodes, and for segmentation faults. In themselves these are nothing to worry about, just a way for the test to be terminated.

To run the tests (again using all available CPUs) issue:

    ./x.py test --verbose --no-fail-fast | tee rustc-testlog

Six tests in the bootstrap test suite are known to fail because they expect to run in the Rust Git repository.

As with all large test suites, some tests might fail on some machines - if the number of additional failures is low, check the log for 'failures:' and review lines above that, particularly the 'stderr:' lines. Any mention of SIGSEGV or signal 11 in a failing test is a cause for concern.

If you get any other failing test which reports an issue number then you should search for that issue. For example, when rustc >= 1.41.1 was built with a version of sysllvm before 10.0 the test for issue 69225 failed https://github.com/rust-lang/rust/issues/69225 and that should be regarded as a critical failure (they released 1.41.1 because of it). Most other failures will not be critical.

Therefore, you should determine the number of failures. The number of tests which passed and failed can be found by running:

    grep '^test result:' rustc-testlog |
     awk '{sum1 += $4; sum2 += $6} END { print sum1 " passed; " sum2 " failed" }'

The other available fields are $8 for those which were ignored (i.e. skipped), $10 for 'measured' and $12 for 'filtered out' but both those last two are probably zero.

Now, as the `root` user, install the package:

### Note

If sudo or su is invoked for switching to the `root` user, ensure `LIBSSH2_SYS_USE_PKG_CONFIG` and `LIBSQLITE3_SYS_USE_PKG_CONFIG` are correctly passed or the following command may rebuild cargo with shipped copies of libssh2 and sqlite. For sudo, use the `--preserve-env=LIB{SSH2,SQLITE3}_SYS_USE_PKG_CONFIG` option. For su, do not use the `-` or `--login` options.

    ./x.py install rustc std &&
    ./x.py install --stage=1 cargo clippy rustfmt

Still as the `root` user, fix the installation of documentation, symlink a Zsh completion file into the correct location, and move a Bash completion file into the location recommended by the Bash completion maintainers:

    rm -fv /opt/rustc-1.85.0/share/doc/rustc-1.85.0/*.old   &&
    install -vm644 README.md                                \
                   /opt/rustc-1.85.0/share/doc/rustc-1.85.0 &&

    install -vdm755 /usr/share/zsh/site-functions      &&
    ln -sfv /opt/rustc/share/zsh/site-functions/_cargo \
            /usr/share/zsh/site-functions

    mv -v /etc/bash_completion.d/cargo /usr/share/bash-completion/completions

Finally, unset the exported environment variables:

    unset LIB{SSH2,SQLITE3}_SYS_USE_PKG_CONFIG

## Command Explanations

ln -svfn rustc-1.85.0 /opt/rustc: if this is not the first use of the `/opt/rustc` symlink, overwrite it by forcing, and use the '-n' flag to avoid getting confusing results from e.g. ls -l.

`targets = "X86"`: this avoids building all the available linux cross-compilers (AArch64, MIPS, PowerPC, SystemZ, etc). Unfortunately, rust insists on installing source files for these below `/opt/rustc/lib/src`.

`extended = true`: this installs several tools (specified by the `tools` entry) alongside rustc.

`tools = ["cargo", "clippy", "rustdoc", "rustfmt"]`: only build the tools from the 'default' profile in binary command rustup which are recommended for most users. The other tools are unlikely to be useful unless using (old) code analyzers or editing the standard library.

`channel = "stable"`: this ensures only stable features can be used, the default in `config.toml` is to use development features, which is not appropriate for a released version.

`[target.x86_64-unknown-linux-gnu]`: the syntax of `config.toml` requires an `llvm-config` entry for each target for which system-llvm is to be used. Change the target to `[target.i686-unknown-linux-gnu]` if you are building on 32-bit x86. This whole section may be omitted if you wish to build against the shipped llvm, or do not have clang, but the resulting build will be larger and take longer.

export LIBSSH2_SYS_USE_PKG_CONFIG=1: Allow cargo to link to system libssh2.

export LIBSQLITE3_SYS_USE_PKG_CONFIG=1: Allow cargo to link to system sqlite.

`--verbose`: this switch can sometimes provide more information about a test which fails.

`--no-fail-fast`: this switch ensures that the test suite will not stop at the first error.

`--stage=1`: this switch works around an issue causing some Rustc components unnecessarily rebuilt running ./x.py install.

## Configuring Rust

### Configuration Information

If you installed rustc in `/opt`, you need to update the following configuration files so that rustc is correctly found by other packages and system processes.

As the `root` user, create the `/etc/profile.d/rustc.sh` file:

    cat > /etc/profile.d/rustc.sh << "EOF"
    # Begin /etc/profile.d/rustc.sh

    pathprepend /opt/rustc/bin           PATH

    # End /etc/profile.d/rustc.sh
    EOF

Immediately after installation, update the current PATH for your current shell as a normal user:

    source /etc/profile.d/rustc.sh

## Contents

Installed Programs: cargo-clippy, cargo-fmt, cargo, clippy-driver, rust-gdb, rust-gdbgui, rust-lldb, rustc, rustdoc, and rustfmt
Installed Libraries: librustc-driver-<16-byte-hash>.so, libstd-<16-byte-hash>.so, and libtest-<16-byte-hash>.so
Installed Directories: ~/.cargo, /opt/rustc, symbolic link to /opt/rustc-1.85.0

### Short Descriptions

cargo-clippy | provides lint checks for a cargo package
cargo-fmt | formats all bin and lib files of the current crate using rustfmt
cargo | is the Package Manager for Rust
clippy-driver | provides lint checks for Rust
rust-gdb | is a wrapper script for gdb, pulling in Python pretty-printing modules installed in `/opt/rustc-1.85.0/lib/rustlib/etc`
rust-gdbgui | is a wrapper script for a graphical front end to gdb that runs in a browser
rust-lldb | is a wrapper script for LLDB (the LLVM debugger) pulling in the Python pretty-printing modules
rustc | is the rust compiler
rustdoc | generates documentation from rust source code
rustfmt | formats rust code
`libstd-<16-byte-hash>.so` | is the Rust Standard Library, the foundation of portable Rust software

- Prev

  Ruby-3.4.2

- Next

  rust-bindgen-0.71.1

- Up
- Home