Rustc-1.93.1

Introduction à Rust

Le langage de programmation Rust est conçu pour être un langage sûr, concurrent et pratique.

Comme avec tous les langages de programmation, rustc (le compilateur rust) requiert un binaire à partir duquel s'amorcer. Il téléchargera un binaire stage0 au début de la construction, donc vous devez avoir une connexion internet pour construire ce paquet.

[Note]

Note

Bien que BLFS installe généralement ses logiciels dans /usr, lorsque vous mettez à jour vers une nouvelle version de rust les anciennes bibliothèques de /usr/lib/rustlib resteront présentes, avec divers condensats dans leur nom, mais elles seront inutiles et gaspilleront de l'espace disque. Les éditeurs recommandent de placer ces fichiers dans le répertoire /opt. En particulier, si vous devez reconstruire ce paquet avec une configuration différente (p. ex. pour utiliser le LLVM interne après avoir construit avec un LLVM partagé, peut-être pour compiler des crates pour des architectures non prises en charge par le LLVM de BLFS) il est possible que l'installation laisse un programme cargo cassé. Si cela arrive, vous devriez soit supprimer l'installation existante avant, soit utiliser un préfixe différent, comme /opt/rust-1.93.1-build2.

Si vous préférez, vous pouvez évidemment changer le préfixe en /usr.

Le système de construction rustbuild actuel utilisera tous les processeurs, bien qu'il ne passe pas bien à l'échelle et utilise souvent un seul cœur en attendant la compilation d'une bibliothèque. Cependant, il peut presque être limité à un nombre de cœurs donné en combinant l'option --jobs <N> (p. ex. « --jobs 4 » pour limiter à 4 processeurs) à chaque invocation de ./x.py et en utilisant la variable d'environnement CARGO_BUILD_JOBS=<N>. Pour l'instant cela n'est pas efficace lors du lancement de certains tests de rustc.

La version actuelle du crate rust num_cpus reconnais maintenant que les cgroups peuvent être utilisés pour restreindre les processeurs qui peuvent être utilisés. Si votre machine manque de DRAM (par exemple s'il a moins de 2 Go de DRAM par cœur) cela peut être une alternative à mettre des CPU hors-ligne. Consultez la section intitulée « Utiliser les groups de contrôle Linux pour limiter l'utilisation des ressources » pour des information sur l'utilisation d'un cgroup.

Pour l'instant, Rust ne donne aucune garantie de stabilité de son ABI.

[Note]

Note

Rustc construit par défaut pour TOUTES les architectures supportées, avec une copie embarquée de LLVM. Dans BLFS, la construction n'est utile que pour l'architecture X86. Si vous comptez développer des crates rust, cette construction peut ne pas être suffisante.

Les temps de construction de cette version lorsqu'elle est répétée sur la même machine sont souvent assez cohérents, mais comme avec toutes les compilations qui utilisent rustc, il peut y avoir quelques exceptions très lentes.

[Note]

Note

Les versions de développement de BLFS peuvent ne pas arriver à contruire ou à exécuter certains paquets correctement si LFS ou des dépendances ont été mises à jour depuis la dernière version stable des livres.

Informations sur le paquet

  • Téléchargement (HTTP) : https://static.rust-lang.org/dist/rustc-1.93.1-src.tar.xz

  • Téléchargement (FTP) :

  • Somme de contrôle MD5 du téléchargement : 65de3c1b0a9304b16ff27433a0dafb95

  • Taille du téléchargement : 258 Mo

  • Estimation de l'espace disque requis : 10 Go (324 Mo installé) plus 11 Go si vous lancez les tests

  • Estimation du temps de construction : 10 SBU (en comptant le temps de téléchargement, plus 15 SBU pour les tests, dans les deux cas avec parallélisme = 8)

Dépendances de Rust

Requises

CMake-4.2.3 et cURL-8.18.0

[Note]

Note

Il est nécessaire d'être connecté à internet pour construire ce paquet

Recommandées

[Note]

Note

Si une dépendance recommandée n'est pas installée, vous devrez modifier les instructions pour construire le paquet en utilisant une copie embarquée dans l'archive des sources de Rustc à la place. Consultez la section sur les explications des commandes pour plus de détails.

Facultatives

GDB-17.1 (utilisé par la suite de tests s'il est présent), git-2.53.0 (requis par la suite de tests), cranelift, jemalloc, libgccjit (consultez les explications des commandes de GCC-15.2.0) et libgit2

Notes des auteurs : https://wiki.linuxfromscratch.org/blfs/wiki/rust

Installation de Rust

Pour installer dans le répertoire /opt, supprimez le lien symbolique /opt/rustc s'il existe et créez un nouveau répertoire (c.-à-d. avec un nom différent si vous essayez une construction différente de la même version). En tant qu'utilisateur root :

mkdir -pv /opt/rustc-1.93.1      &&
ln -svfn rustc-1.93.1 /opt/rustc
[Note]

Note

Si vous avez installé plusieurs versions de Rust dans /opt, pour changer de version, vous n'aurez besoin que de changer le lien symbolique /opt/rustc puis de lancer ldconfig.

Créez un fichier bootstrap.toml correct qui configurera la construction.

cat << EOF > bootstrap.toml
# See bootstrap.toml.example for more possible options,
# and see src/bootstrap/defaults/bootstrap.dist.toml for a few options
# automatically set when building from a release tarball
# (unfortunately, we have to override many of them).

# Tell x.py that 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 users to review that information.
change-id = 148795

[llvm]
# When using the system installed copy of LLVM, prefer the shared libraries
link-shared = true

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

[build]
description = "for BLFS r12.4-1365-wip"

# Omit the documentation to save time and space (the default is to build them).
docs = false

# Do not look for new versions of the dependencies online.
locked-deps = true

# Only install these extended tools. Cargo, clippy, rustdoc, and rustfmt
# are installed by a default rustup installation, and rust-src is needed
# to build the Rust code in Linux kernel (in case you need such a kernel
# feature).
tools = ["cargo", "clippy", "rustdoc", "rustfmt", "src"]

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

[rust]
channel = "stable"

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

# Don't build llvm-bitcode-linker which is only useful for the NVPTX
# backend that we don't enable.
llvm-bitcode-linker = false

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

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

Compilez Rust en exécutant les commandes suivantes :

export LIBSSH2_SYS_USE_PKG_CONFIG=1
export LIBSQLITE3_SYS_USE_PKG_CONFIG=1
./x.py build
[Note]

Note

La suite de tests générera des messages dans le journal systemd à propos de capture d'opcodes invalides, et d'erreurs de segmentation. En soit il n'y a rien à craindre, ce n'est qu'une manière pour le test de se faire arrêter.

Pour lancer les tests, exécutez :

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

Le test nommé tests/run-make/rustdoc-target-modifiers est connu pour échouer car nous n'avons pas activé la cible AArch64 dans LLVM-21.1.8.

Comme avec toutes les grosses suites de tests, certains tests peuvent échouer sur certaines machines : s'il y a peu d'échecs supplémentaires, cherchez les lignes commençant par « failures: » dans le journal et regardez les lignes au-dessus, surtout les lignes « stderr: ». Toute mention de SIGSEGV ou signal 11 dans un test échoué peut s'avérer problématique.

[Note]

Note

Si vous avez nettoyé /usr/lib/libc.a avec strip --strip-unneeded, tous les programmes Rust liés statiquement crasheront au démarrage avec un SIGSEGV, ce qui fait échouer plusieurs tests (par exemple tests/ui/process/nofile-limit.rs) avec un SIGSEGV.

Cela est causé par un bogue de Glibc qui affecte Glibc-2.42 et plusieurs versions précédentes, donc pour l'instant nous avons remplacé --strip-unneeded par --strip-debug à la fois dans le livre LFS et dans le la section intitulée « Nettoyage une fois de plus » pour contourner le problème. Si vous rencontrez ce problème, reconstruisez Glibc et remplacez le fichier /usr/lib/libc.a par la libc.a non nettoyée de la nouvelle construction.

Si vous avez un autre test qui rapporte un numéro de problème vous devriez rechercher ce problème. Par exemple lorsque rustc >= 1.41.1 était construit avec une version de sysllvm avant 10.0 le test pour le problème 69225 échouait https://github.com/rust-lang/rust/issues/69225 et cela devrait être vu comme un problème critique (ils ont publié 1.41.1 à cause de ça). La plupart des autres problèmes ne seront pas critiques.

Donc, vous devriez déterminer le nombre de d'échecs. Vous pouvez trouvez le nombre total de tests réussis et échoués avec :

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

Les autres champs disponibles sont $8 pour ceux qui ont été ignorés (c.-à-d. passés), $10 pour les tests « mesurés » et $12 pour ceux qui ont été « filtrés » mais ces deux derniers sont probablement à 0.

Maintenant, en tant qu'utilisateur root, installez le paquet :

[Note]

Note

Si sudo ou su est invoqué pour passer à l'utilisateur root, assurez-vous que LIBSSH2_SYS_USE_PKG_CONFIG LIBSQLITE3_SYS_USE_PKG_CONFIG sont correctement passés ou la commande suivante pourrait reconstruire cargo avec des copies embarquées de libssh2 et sqlite. Pour sudo, utilisez l'option >--preserve-env=LIBSSH2_SYS_USE_PKG_CONFIG. Pour su, n'utilisez pas les options - ni --login.

./x.py install

Toujours en tant qu'utilisateur root, corrigez l’installation de la documentation, créez un lien symbolique pour le fichier de complétion Zsh au bon endroit et déplacez un fichier d'autocomplétion Bash vers l'emplacement recommandé par les mainteneurs de l'autocomplétion de Bash :

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

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

Enfin, effacez les variables d'environnement exportées :

unset LIB{SSH2,SQLITE3}_SYS_USE_PKG_CONFIG

Explication des commandes

ln -svfn rustc-1.93.1 /opt/rustc : si ce n'est pas la première fois que vous utilisez le lien symbolique /opt/rustc, le réécrit de force et utilise le drapeau « -n » pour éviter d'avoir des résultats bizarre avec p. ex. ls -l.

tools = ["cargo", "clippy", "rustdoc", "rustfmt"] : ne construit que les outils du profil « default » de la commande binaire rustup qui sont recommandées pour la plupart des utilisateurs. Les autres outils sont probablement inutiles à moins d'utiliser d'anciens analyseurs de code ou d'éditer la bibliothèque standard.

channel = "stable" : cela s'assure que seules les fonctionnalités stables seront utilisée. La valeur par défaut dans bootstrap.toml est d'utiliser les fonctionnalités de développement, qui ne sont pas appropriées pour une version publique de rust.

[target.x86_64-unknown-linux-gnu] : la syntaxe de bootstrap.toml requiert une entrée llvm-config pour chaque cible pour laquelle system-llvm doit être utilisé. Modifiez la cible en [target.i686-unknown-linux-gnu] si vous construisez sur x86 32 bits. La section complète devrait être omise si vous souhaitez construire avec la version de llvm incluse, mais la construction qui en résultera sera plus grande et prendra plus de temps.

export LIBSSH2_SYS_USE_PKG_CONFIG=1 : permet à cargo de se lier à la copie de libssh2 installée sur le système. Oubliez cette commande si vous n'avez pas installé libssh2-1.11.1.

export LIBSQLITE3_SYS_USE_PKG_CONFIG=1 : permet à cargo de se lier à la copie système de sqlite.

--verbose : ce paramètre peut parfois fournir plus d'informations sur un test qui échoue.

--no-fail-fast : ce paramètre s'assure que la suite de tests ne s'arrêtera pas après la première erreur.

Configuration de Rust

Informations sur la configuration

Si vous avez installé rustc dans /opt, vous devez mettre à jour les fichiers de configuration suivants pour que rustc puisse être trouvé correctement par les autres paquets et les processus du système.

En tant qu'utilisateur root, créez le fichier /etc/profile.d/rustc.sh :

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

Immédiatement après l'installation, mettez à jour le PATH actuel de votre shell en tant qu'utilisateur normal :

source /etc/profile.d/rustc.sh

Contenu

Programmes installés: cargo-clippy, cargo-fmt, cargo, clippy-driver, rust-gdb, rust-gdbgui, rust-lldb, rustc, rustdoc et rustfmt
Bibliothèques installées: librustc_driver-<16-byte-hash>.so et libstd-<16-byte-hash>.so
Répertoires installés: ~/.cargo, /opt/rustc, lien symbolique vers /opt/rustc-1.93.1

Descriptions courtes

cargo-clippy

effectue des tests de formatage sur un paquet cargo

cargo-fmt

formate tous les fichiers bin et lib de la source courante avec rustfmt

cargo

est le gestionnaire de paquets de Rust

clippy-driver

effectue des tests de formatage sur du code Rust

rust-gdb

est un script enveloppe pour gdb qui récupère les modules d'affichage Python installés dans /opt/rustc-1.93.1/lib/rustlib/etc

rust-gdbgui

est un script enveloppe pour une interface graphique de gdb qui se lance dans un navigateur

rust-lldb

est un script Python enveloppe pour LLDB (le débogueur de LLVM) qui récupère les modules d'affichage Python

rustc

est le compilateur rust

rustdoc

génère de la documentation à partir de code source rust

rustfmt

formatte du code rust

libstd-<16-byte-hash>.so

est la Bibliothèque Standard de Rust, le fondement des logiciels Rust portables