Rustc-1.71.1

Introduction à Rust

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

Ce paquet est mis à jour sur un cycle de publication de six semaines. Comme c'est un gros paquet long à construire et qu'il n'est actuellement utilisé que par quelques paquets dans le livre, les éditeurs de BLFS pensent qu'il ne devrait être mis à jour que lorsque cela est nécessaire (soit pour corriger des problèmes, soit pour permettre à une nouvelle version d'un paquet d'être construite).

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 ne pouvez pas le compiler sans connexion internet.

[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 seront inutiles et gaspilleront de l'espace disque. Les éditeurs recommandent de placer ces fichiers dans le répertoire /opt. En particulier, si vous avez une raison pour reconstruire 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é. Dans une telle situation, vous pouvez soit supprimer l'installation existante avant, soit utiliser un préfixe différent, comme /opt/rust-1.71.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 python3 ./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 paquet rust num_cpus peut désormais utiliser les cgroups pour restreindre les processeurs qui peuvent être utilisés. Donc si votre machine manque de DRAM (typiquement moins de 2 Go de DRAM par cœur), cela peut être une bonne alternative à passer vos CPU hors-ligne. Pour les systèmes sysv, les cgroups nécessitent libcgroup.

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 voulez développer des crates rust, cette construction peut ne pas vous satisfaire.

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.

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

Informations sur le paquet

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

  • Téléchargement (FTP) :

  • Somme de contrôle MD5 : b6f9973de878e37a589f0989e4138480

  • Taille du téléchargement : 145 Mo

  • Estimation de l'espace disque requis : 8,9 Go (292 Mo installé) plus 6,4 Go si vous lancez les tests

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

Dépendances de Rust

Requises

CMake-3.27.2 et cURL-8.2.1

[Note]

Note

An Internet connection is needed for building this package.

Recommandées

[Note]

Note

Si une dépendance recommandée n'est pas installée, une copie embarquée dans l'archive des sources de Rustc sera construite et utilisée.

Facultatives

GDB-13.2 (utilisé par la suite de tests s'il est présent), git-2.41.0 (requis par la suite de tests) et libgit2

Notes des rédacteurs : https://wiki.linuxfromscratch.org/blfs/wiki/rust

Installation de Rust

[Note]

Note

Actuellement le compilateur rust produit des instructions SSE2 pour les systèmes x86 32 bits, ce qui casse le code généré sur les systèmes 32 bits sans processeur capable d'utiliser SSE2. Tous les modèles de processeur x86 vendus après 2004 devraient avoir SSE2. Exécutez lscpu | grep sse2 pour tester. Si la sortie affiche quelque chose, votre CPU prend en charge SSE2 et c'est bon. Sinon vous devrez essayer de construire ce paquet sur un système compatible SSE2 avec la correction suivante appliquée :

sed 's@pentium4@pentiumpro@' -i \
    compiler/rustc_target/src/spec/i686_unknown_linux_gnu.rs

Puis copiez le dossier /opt/rustc-1.71.1 qui en résulte vers le système sans SSE2. Mais ce changement est toujours en cours de revue en amont et n'est pas testé par les rédacteurs de BLFS.

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.71.1      &&
ln -svfn rustc-1.71.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 config.toml correct qui configurera la construction.

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 to not keep printing an annoying warning
changelog-seen = 2

[llvm]
# by default, rust will build for a myriad of architectures
targets = "X86"

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

[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"]

# Use the source code shipped in the tarball for the dependencies.
# The combination of this and the "locked-deps" entry avoids downloading
# many crates from Internet, and makes the Rustc build more stable.
vendor = true

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

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

# BLFS used to not install the FileCheck executable from llvm,
# so disabled codegen tests.  The assembly tests rely on FileCheck
# and cannot easily be disabled, so those will anyway fail if
# FileCheck has not been installed.
#codegen-tests = false

[target.x86_64-unknown-linux-gnu]
# NB the output of llvm-config (i.e. help options) may be
# dumped to the screen when config.toml is parsed.
llvm-config = "/usr/bin/llvm-config"

[target.i686-unknown-linux-gnu]
# NB the output of llvm-config (i.e. help options) may be
# dumped to the screen when config.toml is parsed.
llvm-config = "/usr/bin/llvm-config"


EOF

Compilez Rust en exécutant les commandes suivantes :

{ [ ! -e /usr/include/libssh2.h ] ||
  export LIBSSH2_SYS_USE_PKG_CONFIG=1; } &&
python3 ./x.py build
[Note]

Note

La suite de tests générera des messages dans le journal système à 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 (de nouveau avec tous les CPU disponibles), exécutez :

SSL_CERT_DIR=/etc/ssl/certs \
python3 ./x.py test --verbose --no-fail-fast | tee rustc-testlog

Certains tests ui peuvent échouer (le nombre d'échecs dépend de la longueur du chemin absolu du répertoire rustc-1.71.1-src). Ces échecs peuvent être identifiés en visualisant le fichier rustc-testlog et en recherchant les messages note: the full type name has been written to et peut être ignorés sans problème.

Si FileCeck de LLVM n'a pas été installé, les 47 tests de la suite « assembly » échoueront.

Sur certains systèmes, scripter les tests peut résulter en des tests qui attendent indéfiniment sur test: combine_install_with_separate_uninstall. Dans ce cas, vous pouvez contourner le problème en appuyant sur la touche Entrée. Le test peut également être supprimé avec :

sed -e '/runtest combine_install_with/s/^/#/g' -i src/tools/rust-installer/test.sh

Comme avec toutes les grosses suites de tests, d'autres 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.

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 d'échecs.

Le nombre de tests réussis et échoués peut être trouvé en exécutant :

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 est correctement passée ou la commande suivante pourrait complètement reconstruire le paquet. Pour sudo, utilisez l'option >--preserve-env=LIBSSH2_SYS_USE_PKG_CONFIG. Pour su, n'utilisez pas - ni --login.

python3 ./x.py install

Le système de construction essaye d'installer certains fichiers deux fois, et à la deuxième tentative il renomme le fichier installé à la tentative précédente avec le suffixe .old. En tant qu'utilisateur root, supprimez ces fichiers :

find /opt/rustc-1.71.1 -name "*.old" -delete

Toujours en tant qu'utilisateur root, créez un lien symbolique pour le fichier de complétion Zsh au bon endroit :

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

Explication des commandes

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

targets = "X86" : cela évite de construire tous les compilateurs croisés disponibles (Aarch64, MIPS, PowerPC, SystemZ, etc). Malheureusement, rust insiste pour installer leurs fichiers sources sous /opt/rustc/lib/src.

extended = true : cela installe plusieurs outils (spécifiés par l'entrée tools) à côté de rustc.

tools = ["cargo", "clippy", "rustdoc", "rustfmt"] : ne construit que les outils du profil « default » dans 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 peuvent être utilisée, la valeur par défaut dans config.toml est d'utiliser les fonctionnalités de développement, qui ne sont pas appropriées pour une version publique.

[target.x86_64-unknown-linux-gnu] : la syntaxe de config.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 peut être omise si vous souhaitez construire avec la version de llvm incluse ou que vous n'avez pas clang, 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 libssh2 du système.

SSL_CERT_DIR=/etc/ssl/certs : contourne un problème qui cause des échecs des tests avec la structure du magasin de certificats d'autorités de certification utilisée par make-ca-1.12.

--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

# Include /opt/rustc/man in the MANPATH variable to access manual pages
pathappend  /opt/rustc/share/man     MANPATH

# 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

Contents

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, libstd-<16-byte-hash>.so et libtest-<16-byte-hash>.so
Répertoires installés: ~/.cargo, /opt/rustc, lien symbolique vers /opt/rustc-1.71.1

Descriptions courtes

cargo-clippy

fournit des tests de formatage pour 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

fournit des tests de formatage pour Rust

rust-gdb

est un script enveloppe pour gdb qui récupère les modules d'affichage Python installés dans /opt/rustc-1.71.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