Rustc-1.37.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 de firefox 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]

Note

Bien que BLFS installé 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é, mais peut-être aussi 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.37.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 disponible, bien qu'il ne passe pas bien à l'échelle et n'utilisera souvent qu'un cœur en attendant qu'une bibliothèque se compile.

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. Rustc continuera de prétendre qu'il a besoin de Python 2, mais ce n'est vraiment nécessaire que pour construire pour d'autres architectures avec le LLVM embarqué. 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.

Ce paquet est connu pour se construire correctement sur une plateforme LFS-9.1.

Informations sur le paquet

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

  • Téléchargement (FTP) :

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

  • Taille du téléchargement : 147 Mo

  • Estimation de l'espace disque requis : 5.3 Go (375 Mo installés), dont 429 Mo de fichiers ~/.cargo pour les utilisateurs qui le construisent. Plus 1.7 Go si vous lancez les tests.

  • Estimation du temps de construction : 24 SBU (plus 13 SBU pour les tests, dans les deux cas avec 4 processeurs)

Téléchargements supplémentaires

Dépendances de Rust

Requises

cURL-7.68.0, CMake-3.16.4 et libssh2-1.9.0

Recommandées

Facultatives

GDB-9.1 (utilisé par la suite de tests s'il est présent) et Python-2.7.17 (utilisé par la suite de tests)

Notes utilisateur : http://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.37.0             &&
ln -svfin rustc-1.37.0 /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 example using shipped LLVM
# e.g. if not installing clang, or using a version before 8.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.37.0"
docdir = "share/doc/rustc-1.37.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

Adaptez rustc pour lui permettre de construire et de fonctionner après des changements dans LLVM-9 :

patch -Np1 -i ../rustc-1.37.0-llvm9_fixes-1.patch

Maintenant compilez Rust en lançant les commandes suivantes :

export RUSTFLAGS="$RUSTFLAGS -C link-args=-lffi" &&
python3 ./x.py build --exclude src/tools/miri
[Note]

Note

La suite de tests générera certains 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 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.

Les instructions ci-dessus ne construisent pas de compilateurs ARM, donc la suite de test échouera et les tests rapporteront une erreur à la fin, avec une trace de débogage du dernier test en échec. Sur une bonne exécution, 3 tests qui nécessitent des compilateurs Thumb (ARM) échoueront, tous dans ui/issues pour les problèmes 37131, 49851 et 50993. Un quatrième test, run-make-fulldeps/sysroot-crates-are-unstable échoue, sans doute parce qu'on n'utilise que des fonctionnalités stables. Comme avec toutes les grandes suites de tests, d'autres tests peuvent échouer sur certaines machines — si le nombre d'échecs est inférieur à 10, vérifiez les journaux en cherchant « FAILED » et vérifiez les lignes qui précèdent. Toute mention de SIGSEGV ou signal 11 dans un test en échec est suspecte. Un cinquième test, run-make-fulldeps/linker-output-non-utf8, est connu pour échouer.

Donc, vous devriez déterminer le nombre de tests, d'échecs, etc. Vous pouvez trouvez le nombre total de tests lancés avec :

grep 'running .* tests' rustc-testlog | awk '{ sum += $2 } END { print sum }'

Cela devrait rapporter 16499 tests. De même, 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). La somme ne correspond pas au total.

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

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 est cassé dans cette version.

--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-gdb, 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.37.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-gdb

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

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 2020-02-17 00:15:05 +0100