Rustc-1.52.0
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 bootstraper.
Il téléchargera un binaire stage0, et plusieurs fichier cargo (ce
sont en fait des archives de source en .tar.gz) au début de la
construction, donc vous ne pouvez pas le compiler sans connexion
internet.
Ces recettes resteront éternellement dans divers formats (caches,
répertoire des sources) dans ~/.cargo
. Les gros paquets rust utilisent régulièrement plusieurs
versions de certaines recettes. Si vous supprimez les fichiers
avant de mettre à jour ce paquet, très peut de recettes devront
être mises à jour par les paquets dans ce livre (et elles seront
téléchargé au besoin). Mais si vous gardez une ancienne version
comme option de secours puis l'utilisez (il ne faudrait alors
pas construire dans
/usr
), il est fort probable qu'elle
re-téléchargera certaines recettes. Pour un téléchargement complet
(c.-à-d. à partir d'un répertoire ~/.cargo
vide ou manquant), le téléchargement des
fichiers cargo externes pour cette version ne prend qu'une minute
ou deux sur un réseau rapide.
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 hashs 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é, ou dans la situation contraire) 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.52.0-build2.
Si vous préférez, vous pouvez évidemment changer le préfixe en
/usr
et omettre le lancement de
ldconfig et les
actions pour ajouter rustc au PATH.
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 2Go 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
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.
De manière inhabituelle, la méthode DESTDIR est utilisée pour
installer ce paquet. Cela est dû au fait que lancer
l'installation en root télécharge tous les fichiers cargo de
nouveau (dans /root/.cargo
) puis
passe encore beaucoup de temps à tout recompiler. Cette méthode
réduit de beaucoup le temps de construction au prix d'un espace
disque plus important.
This package is known to build and work properly using an LFS-11.0
platform.
Informations sur le paquet
-
Téléchargement (HTTP) : https://static.rust-lang.org/dist/rustc-1.52.0-src.tar.gz
-
Téléchargement (FTP) :
-
Somme de contrôle MD5 du téléchargement :
bd6fbe9ba5fe457d2514e92a6ccd7b24
-
Taille du téléchargement : 161 Mo
-
Estimation de l'espace disque requis : 9,3 Go (407 Mo
installés), dont 291 Mo de fichiers ~/.cargo pour
l'utilisateur qui le construit. Plus 4,0 Go si vous lancez
les tests, dont 179 Mo supplémentaires de fichiers ~/.cargo.
-
Estimation du temps de construction : 31 SBU (plus 13
SBU pour les tests, dans les deux cas avec 4 processeurs)
Dépendances de Rust
Requises
cURL-7.78.0, CMake-3.21.2 et libssh2-1.9.0
Recommandées
clang de LLVM-12.0.1 (construit avec
-DLLVM_LINK_LLVM_DYLIB=ON pour que rust puisse se lier au LLVM du
système au lieu de compiler la version intégrée). Si vous utilisez
une ancienne version, regardez le fichier config.toml ci-dessous et
réutilisez le llvm inclus, à cause du problème 69225 de rust.
Facultatives
GDB-10.2
(utilisé par la suite de tests s'il est présent)
Notes utilisateur : https://wiki.linuxfromscratch.org/blfs/wiki/rust
Installation de Rust
Pour installer dans le répertoire /opt
, supprimez le lien symbolique et créez un
nouveau répertoire (c.-à-d. avec un nom différent si vous essayez
une construction différente). En tant qu'utilisateur root
:
mkdir /opt/rustc-1.52.0 &&
ln -svfin rustc-1.52.0 /opt/rustc
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 example using shipped LLVM
# e.g. if not installing clang, or using a version before 10.0
[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 cargo as well as rust
extended = true
[install]
prefix = "/opt/rustc-1.52.0"
docdir = "share/doc/rustc-1.52.0"
[rust]
channel = "stable"
rpath = false
# BLFS does not install the FileCheck executable from llvm,
# so disable codegen tests
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 lançant les
commandes suivantes :
export RUSTFLAGS="$RUSTFLAGS -C link-args=-lffi" &&
python3 ./x.py build --exclude src/tools/miri
Note
La suite de tests générera certains 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 terminer.
Pour lancer les tests, lancez python3
./x.py test --verbose --no-fail-fast | tee
rustc-testlog : comme pour la construction,
cela utilisera tous les CPU disponibles.
Au minimum, sept tests échoueront :
ui/asm/inline-syntax.rs#arm,
assembly/target-feature-multiple.rs#SINGLEFLAG,
assembly/target-feature-multiple.rs#TWOFLAGS,
run-make-fulldeps/long-linker-command-lines,
run-make-fulldeps/split-debuginfo, run-make-fulldeps/split-dwarf,
run-make-fulldeps/sysroot-crates-are-unstable. Avec une version
récente de gdb,
quatre échecs supplémentaires (debuginfo/extern-c-fn.rs,
debuginfo/generator-objects.rs, debuginfo/issue-57822.rs,
debuginfo/pretty-huge-vec.rs) sont attendus.
Comme avec toutes les grosses suites de tests, les autres tests
peuvent échouer sur certaines machines - si le nombre d'échecs
supplémentaires n'a qu'un seul nombre, trouvez les
« FAILED » 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 échoués peut être trouvé avec :
grep '^test result:' rustc-testlog | awk '{ sum += $6 } END { print sum }'
Et pareil pour les tests qui ont réussi, utilisez $4, pour ceux qui
sont ignoré (c'est-à-dire passés) utilisez $8 (et $10 pour les
tests mesurés, $12 pour ceux qui ont été filtrés mais ces deux-là
sont probablement à 0).
Toujours en tant qu'utilisateur normal, installez avec la méthode
DESTDIR :
export LIBSSH2_SYS_USE_PKG_CONFIG=1 &&
DESTDIR=${PWD}/install python3 ./x.py install &&
unset LIBSSH2_SYS_USE_PKG_CONFIG
Maintenant, en tant qu'utilisateur root
installez les fichiers du DESTDIR :
chown -R root:root install &&
cp -a install/* /
Explication des commandes
ln -svfn rustc-1.52.0
/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 Cargo avec Rust.
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.
rpath = false :
par défaut, rust peut
être lancé depuis son emplacement de construction sans être
installé. Cela ajoute des entrées DT_RPATH à tous les fichiers ELF,
ce qui produit une sortie très chargée de la part de ldd, contenant les bibliothèques
à l'emplacement de leur construction, même si elles ont été
supprimées de là après l'installation.
[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 RUSTFLAGS="$RUSTFLAGS -C
link-args=-lffi" : Cela ajoute un lien vers
libffi dans les RUSTFLAGS que vous pourriez déjà passer à la
construction. Sur certains systèmes, l'édition de lien échoue à
inclure libffi à moins d'utiliser cela. La raison n'est pas très
claire.
--exclude
src/tools/miri : Depuis longtemps, la recette
de miri (un interpréteur pour la représentation intermédiaire de
mi-niveau) n'arrive pas à se construire dans les versions publiées.
Il est facultatif, mais les messages d'erreurs peuvent persuader
les gens que la construction complète a échouée. Cependant, bien
qu'il ne soit pas compilé pendant la compilation principale, avec
rust-1.35.0 il est maintenant compilé pendant l'installation, mais
il était cassé dans cette version. L'omettre devrait faire gagner
un peu de temps.
--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.
export
LIBSSH2_SYS_USE_PKG_CONFIG=1 : Sur certains
systèmes, cairo échoue à se lier pendant l'installation parce qu'il
ne trouve pas libssh2. Cela semble corriger le problème, mais la
raison en est inconnue.
DESTDIR=${PWD}/install python3 ./x.py
install : Cela fait une installation DESTDIR
dans l'arborescence des sources, en créant un répertoire
install
. Remarquez que les
installation DESTDIR ont besoin d'un chemin absolu. Passer
« install » ne fonctionnera pas.
chown -R root:root
install : l'installation DESTDIR a été lancée
par un utilsateur normal qui possède les fichiers. Par sécurité,
changez l'appartenance avant de faire une copie pour les installer.
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
,
mettez à jour le fichier /etc/ld.so.conf
et le fichier de cache
d'exécution de l'éditeur de lien dynamique :
cat >> /etc/ld.so.conf << EOF
# Begin rustc addition
/opt/rustc/lib
# End rustc addition
EOF
ldconfig
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
Contents
Programmes installés:
cargo-clippy, cargo-fmt, cargo-miri,
cargo, clippy-driver, miri, rls, rust-analyzer, rust-gdb,
rust-gdbgui, rust-lldb, rustc, rustdoc, rustfmt.
Bibliothèques installées:
Beaucoup de bibliothèques
lib*<16-byte-hash>.so.
Répertoires installés:
~/.cargo, /opt/rustc/lib/rustlib,
/opt/rustc/share/doc/rustc-1.52.0 et
/opt/rustc/share/zsh/site-functions
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-miri
|
est utilisé par Miri pour interpréter des recettes
binaires et des tests
|
cargo
|
est le gestionnaire de paquets de Rust
|
clippy-driver
|
fournit des tests de formatage pour Rust
|
miri
|
est un interpréteur pour la représentation intermédiaire
de mi-niveau de Rust (MIR). Il est cassé dans cette
version
|
rls
|
est le serveur du langage Rust. Il peut être lancé en
tâche de fond pour fournir des informations sur les
programmes Rust à des IDE, des éditeurs et d'autres
outils
|
rust-analyzer
|
est une implémentation du protocole de serveur de langue
pour le langage de programmation Rust.
|
rust-gdb
|
est un script enveloppe pour gdb qui récupère les modules
d'affichage Python installés dans /opt/rustc-1.52.0/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
|
Last updated on